Last active
August 1, 2019 14:26
-
-
Save ritz078/3f49c8bd7a2b71429dcae28f2c2d1d97 to your computer and use it in GitHub Desktop.
flow-to-typescript
This file has been truncated, but you can view the full file.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /******/ (function(modules) { // webpackBootstrap | |
| /******/ function hotDisposeChunk(chunkId) { | |
| /******/ delete installedChunks[chunkId]; | |
| /******/ } | |
| /******/ var parentHotUpdateCallback = window["webpackHotUpdate"]; | |
| /******/ window["webpackHotUpdate"] = // eslint-disable-next-line no-unused-vars | |
| /******/ function webpackHotUpdateCallback(chunkId, moreModules) { | |
| /******/ hotAddUpdateChunk(chunkId, moreModules); | |
| /******/ if (parentHotUpdateCallback) parentHotUpdateCallback(chunkId, moreModules); | |
| /******/ } ; | |
| /******/ | |
| /******/ // eslint-disable-next-line no-unused-vars | |
| /******/ function hotDownloadUpdateChunk(chunkId) { | |
| /******/ var script = document.createElement("script"); | |
| /******/ script.charset = "utf-8"; | |
| /******/ script.src = __webpack_require__.p + "" + chunkId + "." + hotCurrentHash + ".hot-update.js"; | |
| /******/ if (null) script.crossOrigin = null; | |
| /******/ document.head.appendChild(script); | |
| /******/ } | |
| /******/ | |
| /******/ // eslint-disable-next-line no-unused-vars | |
| /******/ function hotDownloadManifest(requestTimeout) { | |
| /******/ requestTimeout = requestTimeout || 10000; | |
| /******/ return new Promise(function(resolve, reject) { | |
| /******/ if (typeof XMLHttpRequest === "undefined") { | |
| /******/ return reject(new Error("No browser support")); | |
| /******/ } | |
| /******/ try { | |
| /******/ var request = new XMLHttpRequest(); | |
| /******/ var requestPath = __webpack_require__.p + "" + hotCurrentHash + ".hot-update.json"; | |
| /******/ request.open("GET", requestPath, true); | |
| /******/ request.timeout = requestTimeout; | |
| /******/ request.send(null); | |
| /******/ } catch (err) { | |
| /******/ return reject(err); | |
| /******/ } | |
| /******/ request.onreadystatechange = function() { | |
| /******/ if (request.readyState !== 4) return; | |
| /******/ if (request.status === 0) { | |
| /******/ // timeout | |
| /******/ reject( | |
| /******/ new Error("Manifest request to " + requestPath + " timed out.") | |
| /******/ ); | |
| /******/ } else if (request.status === 404) { | |
| /******/ // no update available | |
| /******/ resolve(); | |
| /******/ } else if (request.status !== 200 && request.status !== 304) { | |
| /******/ // other failure | |
| /******/ reject(new Error("Manifest request to " + requestPath + " failed.")); | |
| /******/ } else { | |
| /******/ // success | |
| /******/ try { | |
| /******/ var update = JSON.parse(request.responseText); | |
| /******/ } catch (e) { | |
| /******/ reject(e); | |
| /******/ return; | |
| /******/ } | |
| /******/ resolve(update); | |
| /******/ } | |
| /******/ }; | |
| /******/ }); | |
| /******/ } | |
| /******/ | |
| /******/ var hotApplyOnUpdate = true; | |
| /******/ // eslint-disable-next-line no-unused-vars | |
| /******/ var hotCurrentHash = "cb5a13832ab4798ab388"; | |
| /******/ var hotRequestTimeout = 10000; | |
| /******/ var hotCurrentModuleData = {}; | |
| /******/ var hotCurrentChildModule; | |
| /******/ // eslint-disable-next-line no-unused-vars | |
| /******/ var hotCurrentParents = []; | |
| /******/ // eslint-disable-next-line no-unused-vars | |
| /******/ var hotCurrentParentsTemp = []; | |
| /******/ | |
| /******/ // eslint-disable-next-line no-unused-vars | |
| /******/ function hotCreateRequire(moduleId) { | |
| /******/ var me = installedModules[moduleId]; | |
| /******/ if (!me) return __webpack_require__; | |
| /******/ var fn = function(request) { | |
| /******/ if (me.hot.active) { | |
| /******/ if (installedModules[request]) { | |
| /******/ if (installedModules[request].parents.indexOf(moduleId) === -1) { | |
| /******/ installedModules[request].parents.push(moduleId); | |
| /******/ } | |
| /******/ } else { | |
| /******/ hotCurrentParents = [moduleId]; | |
| /******/ hotCurrentChildModule = request; | |
| /******/ } | |
| /******/ if (me.children.indexOf(request) === -1) { | |
| /******/ me.children.push(request); | |
| /******/ } | |
| /******/ } else { | |
| /******/ console.warn( | |
| /******/ "[HMR] unexpected require(" + | |
| /******/ request + | |
| /******/ ") from disposed module " + | |
| /******/ moduleId | |
| /******/ ); | |
| /******/ hotCurrentParents = []; | |
| /******/ } | |
| /******/ return __webpack_require__(request); | |
| /******/ }; | |
| /******/ var ObjectFactory = function ObjectFactory(name) { | |
| /******/ return { | |
| /******/ configurable: true, | |
| /******/ enumerable: true, | |
| /******/ get: function() { | |
| /******/ return __webpack_require__[name]; | |
| /******/ }, | |
| /******/ set: function(value) { | |
| /******/ __webpack_require__[name] = value; | |
| /******/ } | |
| /******/ }; | |
| /******/ }; | |
| /******/ for (var name in __webpack_require__) { | |
| /******/ if ( | |
| /******/ Object.prototype.hasOwnProperty.call(__webpack_require__, name) && | |
| /******/ name !== "e" && | |
| /******/ name !== "t" | |
| /******/ ) { | |
| /******/ Object.defineProperty(fn, name, ObjectFactory(name)); | |
| /******/ } | |
| /******/ } | |
| /******/ fn.e = function(chunkId) { | |
| /******/ if (hotStatus === "ready") hotSetStatus("prepare"); | |
| /******/ hotChunksLoading++; | |
| /******/ return __webpack_require__.e(chunkId).then(finishChunkLoading, function(err) { | |
| /******/ finishChunkLoading(); | |
| /******/ throw err; | |
| /******/ }); | |
| /******/ | |
| /******/ function finishChunkLoading() { | |
| /******/ hotChunksLoading--; | |
| /******/ if (hotStatus === "prepare") { | |
| /******/ if (!hotWaitingFilesMap[chunkId]) { | |
| /******/ hotEnsureUpdateChunk(chunkId); | |
| /******/ } | |
| /******/ if (hotChunksLoading === 0 && hotWaitingFiles === 0) { | |
| /******/ hotUpdateDownloaded(); | |
| /******/ } | |
| /******/ } | |
| /******/ } | |
| /******/ }; | |
| /******/ fn.t = function(value, mode) { | |
| /******/ if (mode & 1) value = fn(value); | |
| /******/ return __webpack_require__.t(value, mode & ~1); | |
| /******/ }; | |
| /******/ return fn; | |
| /******/ } | |
| /******/ | |
| /******/ // eslint-disable-next-line no-unused-vars | |
| /******/ function hotCreateModule(moduleId) { | |
| /******/ var hot = { | |
| /******/ // private stuff | |
| /******/ _acceptedDependencies: {}, | |
| /******/ _declinedDependencies: {}, | |
| /******/ _selfAccepted: false, | |
| /******/ _selfDeclined: false, | |
| /******/ _disposeHandlers: [], | |
| /******/ _main: hotCurrentChildModule !== moduleId, | |
| /******/ | |
| /******/ // Module API | |
| /******/ active: true, | |
| /******/ accept: function(dep, callback) { | |
| /******/ if (dep === undefined) hot._selfAccepted = true; | |
| /******/ else if (typeof dep === "function") hot._selfAccepted = dep; | |
| /******/ else if (typeof dep === "object") | |
| /******/ for (var i = 0; i < dep.length; i++) | |
| /******/ hot._acceptedDependencies[dep[i]] = callback || function() {}; | |
| /******/ else hot._acceptedDependencies[dep] = callback || function() {}; | |
| /******/ }, | |
| /******/ decline: function(dep) { | |
| /******/ if (dep === undefined) hot._selfDeclined = true; | |
| /******/ else if (typeof dep === "object") | |
| /******/ for (var i = 0; i < dep.length; i++) | |
| /******/ hot._declinedDependencies[dep[i]] = true; | |
| /******/ else hot._declinedDependencies[dep] = true; | |
| /******/ }, | |
| /******/ dispose: function(callback) { | |
| /******/ hot._disposeHandlers.push(callback); | |
| /******/ }, | |
| /******/ addDisposeHandler: function(callback) { | |
| /******/ hot._disposeHandlers.push(callback); | |
| /******/ }, | |
| /******/ removeDisposeHandler: function(callback) { | |
| /******/ var idx = hot._disposeHandlers.indexOf(callback); | |
| /******/ if (idx >= 0) hot._disposeHandlers.splice(idx, 1); | |
| /******/ }, | |
| /******/ | |
| /******/ // Management API | |
| /******/ check: hotCheck, | |
| /******/ apply: hotApply, | |
| /******/ status: function(l) { | |
| /******/ if (!l) return hotStatus; | |
| /******/ hotStatusHandlers.push(l); | |
| /******/ }, | |
| /******/ addStatusHandler: function(l) { | |
| /******/ hotStatusHandlers.push(l); | |
| /******/ }, | |
| /******/ removeStatusHandler: function(l) { | |
| /******/ var idx = hotStatusHandlers.indexOf(l); | |
| /******/ if (idx >= 0) hotStatusHandlers.splice(idx, 1); | |
| /******/ }, | |
| /******/ | |
| /******/ //inherit from previous dispose call | |
| /******/ data: hotCurrentModuleData[moduleId] | |
| /******/ }; | |
| /******/ hotCurrentChildModule = undefined; | |
| /******/ return hot; | |
| /******/ } | |
| /******/ | |
| /******/ var hotStatusHandlers = []; | |
| /******/ var hotStatus = "idle"; | |
| /******/ | |
| /******/ function hotSetStatus(newStatus) { | |
| /******/ hotStatus = newStatus; | |
| /******/ for (var i = 0; i < hotStatusHandlers.length; i++) | |
| /******/ hotStatusHandlers[i].call(null, newStatus); | |
| /******/ } | |
| /******/ | |
| /******/ // while downloading | |
| /******/ var hotWaitingFiles = 0; | |
| /******/ var hotChunksLoading = 0; | |
| /******/ var hotWaitingFilesMap = {}; | |
| /******/ var hotRequestedFilesMap = {}; | |
| /******/ var hotAvailableFilesMap = {}; | |
| /******/ var hotDeferred; | |
| /******/ | |
| /******/ // The update info | |
| /******/ var hotUpdate, hotUpdateNewHash; | |
| /******/ | |
| /******/ function toModuleId(id) { | |
| /******/ var isNumber = +id + "" === id; | |
| /******/ return isNumber ? +id : id; | |
| /******/ } | |
| /******/ | |
| /******/ function hotCheck(apply) { | |
| /******/ if (hotStatus !== "idle") { | |
| /******/ throw new Error("check() is only allowed in idle status"); | |
| /******/ } | |
| /******/ hotApplyOnUpdate = apply; | |
| /******/ hotSetStatus("check"); | |
| /******/ return hotDownloadManifest(hotRequestTimeout).then(function(update) { | |
| /******/ if (!update) { | |
| /******/ hotSetStatus("idle"); | |
| /******/ return null; | |
| /******/ } | |
| /******/ hotRequestedFilesMap = {}; | |
| /******/ hotWaitingFilesMap = {}; | |
| /******/ hotAvailableFilesMap = update.c; | |
| /******/ hotUpdateNewHash = update.h; | |
| /******/ | |
| /******/ hotSetStatus("prepare"); | |
| /******/ var promise = new Promise(function(resolve, reject) { | |
| /******/ hotDeferred = { | |
| /******/ resolve: resolve, | |
| /******/ reject: reject | |
| /******/ }; | |
| /******/ }); | |
| /******/ hotUpdate = {}; | |
| /******/ var chunkId = "index"; | |
| /******/ // eslint-disable-next-line no-lone-blocks | |
| /******/ { | |
| /******/ /*globals chunkId */ | |
| /******/ hotEnsureUpdateChunk(chunkId); | |
| /******/ } | |
| /******/ if ( | |
| /******/ hotStatus === "prepare" && | |
| /******/ hotChunksLoading === 0 && | |
| /******/ hotWaitingFiles === 0 | |
| /******/ ) { | |
| /******/ hotUpdateDownloaded(); | |
| /******/ } | |
| /******/ return promise; | |
| /******/ }); | |
| /******/ } | |
| /******/ | |
| /******/ // eslint-disable-next-line no-unused-vars | |
| /******/ function hotAddUpdateChunk(chunkId, moreModules) { | |
| /******/ if (!hotAvailableFilesMap[chunkId] || !hotRequestedFilesMap[chunkId]) | |
| /******/ return; | |
| /******/ hotRequestedFilesMap[chunkId] = false; | |
| /******/ for (var moduleId in moreModules) { | |
| /******/ if (Object.prototype.hasOwnProperty.call(moreModules, moduleId)) { | |
| /******/ hotUpdate[moduleId] = moreModules[moduleId]; | |
| /******/ } | |
| /******/ } | |
| /******/ if (--hotWaitingFiles === 0 && hotChunksLoading === 0) { | |
| /******/ hotUpdateDownloaded(); | |
| /******/ } | |
| /******/ } | |
| /******/ | |
| /******/ function hotEnsureUpdateChunk(chunkId) { | |
| /******/ if (!hotAvailableFilesMap[chunkId]) { | |
| /******/ hotWaitingFilesMap[chunkId] = true; | |
| /******/ } else { | |
| /******/ hotRequestedFilesMap[chunkId] = true; | |
| /******/ hotWaitingFiles++; | |
| /******/ hotDownloadUpdateChunk(chunkId); | |
| /******/ } | |
| /******/ } | |
| /******/ | |
| /******/ function hotUpdateDownloaded() { | |
| /******/ hotSetStatus("ready"); | |
| /******/ var deferred = hotDeferred; | |
| /******/ hotDeferred = null; | |
| /******/ if (!deferred) return; | |
| /******/ if (hotApplyOnUpdate) { | |
| /******/ // Wrap deferred object in Promise to mark it as a well-handled Promise to | |
| /******/ // avoid triggering uncaught exception warning in Chrome. | |
| /******/ // See https://bugs.chromium.org/p/chromium/issues/detail?id=465666 | |
| /******/ Promise.resolve() | |
| /******/ .then(function() { | |
| /******/ return hotApply(hotApplyOnUpdate); | |
| /******/ }) | |
| /******/ .then( | |
| /******/ function(result) { | |
| /******/ deferred.resolve(result); | |
| /******/ }, | |
| /******/ function(err) { | |
| /******/ deferred.reject(err); | |
| /******/ } | |
| /******/ ); | |
| /******/ } else { | |
| /******/ var outdatedModules = []; | |
| /******/ for (var id in hotUpdate) { | |
| /******/ if (Object.prototype.hasOwnProperty.call(hotUpdate, id)) { | |
| /******/ outdatedModules.push(toModuleId(id)); | |
| /******/ } | |
| /******/ } | |
| /******/ deferred.resolve(outdatedModules); | |
| /******/ } | |
| /******/ } | |
| /******/ | |
| /******/ function hotApply(options) { | |
| /******/ if (hotStatus !== "ready") | |
| /******/ throw new Error("apply() is only allowed in ready status"); | |
| /******/ options = options || {}; | |
| /******/ | |
| /******/ var cb; | |
| /******/ var i; | |
| /******/ var j; | |
| /******/ var module; | |
| /******/ var moduleId; | |
| /******/ | |
| /******/ function getAffectedStuff(updateModuleId) { | |
| /******/ var outdatedModules = [updateModuleId]; | |
| /******/ var outdatedDependencies = {}; | |
| /******/ | |
| /******/ var queue = outdatedModules.slice().map(function(id) { | |
| /******/ return { | |
| /******/ chain: [id], | |
| /******/ id: id | |
| /******/ }; | |
| /******/ }); | |
| /******/ while (queue.length > 0) { | |
| /******/ var queueItem = queue.pop(); | |
| /******/ var moduleId = queueItem.id; | |
| /******/ var chain = queueItem.chain; | |
| /******/ module = installedModules[moduleId]; | |
| /******/ if (!module || module.hot._selfAccepted) continue; | |
| /******/ if (module.hot._selfDeclined) { | |
| /******/ return { | |
| /******/ type: "self-declined", | |
| /******/ chain: chain, | |
| /******/ moduleId: moduleId | |
| /******/ }; | |
| /******/ } | |
| /******/ if (module.hot._main) { | |
| /******/ return { | |
| /******/ type: "unaccepted", | |
| /******/ chain: chain, | |
| /******/ moduleId: moduleId | |
| /******/ }; | |
| /******/ } | |
| /******/ for (var i = 0; i < module.parents.length; i++) { | |
| /******/ var parentId = module.parents[i]; | |
| /******/ var parent = installedModules[parentId]; | |
| /******/ if (!parent) continue; | |
| /******/ if (parent.hot._declinedDependencies[moduleId]) { | |
| /******/ return { | |
| /******/ type: "declined", | |
| /******/ chain: chain.concat([parentId]), | |
| /******/ moduleId: moduleId, | |
| /******/ parentId: parentId | |
| /******/ }; | |
| /******/ } | |
| /******/ if (outdatedModules.indexOf(parentId) !== -1) continue; | |
| /******/ if (parent.hot._acceptedDependencies[moduleId]) { | |
| /******/ if (!outdatedDependencies[parentId]) | |
| /******/ outdatedDependencies[parentId] = []; | |
| /******/ addAllToSet(outdatedDependencies[parentId], [moduleId]); | |
| /******/ continue; | |
| /******/ } | |
| /******/ delete outdatedDependencies[parentId]; | |
| /******/ outdatedModules.push(parentId); | |
| /******/ queue.push({ | |
| /******/ chain: chain.concat([parentId]), | |
| /******/ id: parentId | |
| /******/ }); | |
| /******/ } | |
| /******/ } | |
| /******/ | |
| /******/ return { | |
| /******/ type: "accepted", | |
| /******/ moduleId: updateModuleId, | |
| /******/ outdatedModules: outdatedModules, | |
| /******/ outdatedDependencies: outdatedDependencies | |
| /******/ }; | |
| /******/ } | |
| /******/ | |
| /******/ function addAllToSet(a, b) { | |
| /******/ for (var i = 0; i < b.length; i++) { | |
| /******/ var item = b[i]; | |
| /******/ if (a.indexOf(item) === -1) a.push(item); | |
| /******/ } | |
| /******/ } | |
| /******/ | |
| /******/ // at begin all updates modules are outdated | |
| /******/ // the "outdated" status can propagate to parents if they don't accept the children | |
| /******/ var outdatedDependencies = {}; | |
| /******/ var outdatedModules = []; | |
| /******/ var appliedUpdate = {}; | |
| /******/ | |
| /******/ var warnUnexpectedRequire = function warnUnexpectedRequire() { | |
| /******/ console.warn( | |
| /******/ "[HMR] unexpected require(" + result.moduleId + ") to disposed module" | |
| /******/ ); | |
| /******/ }; | |
| /******/ | |
| /******/ for (var id in hotUpdate) { | |
| /******/ if (Object.prototype.hasOwnProperty.call(hotUpdate, id)) { | |
| /******/ moduleId = toModuleId(id); | |
| /******/ /** @type {TODO} */ | |
| /******/ var result; | |
| /******/ if (hotUpdate[id]) { | |
| /******/ result = getAffectedStuff(moduleId); | |
| /******/ } else { | |
| /******/ result = { | |
| /******/ type: "disposed", | |
| /******/ moduleId: id | |
| /******/ }; | |
| /******/ } | |
| /******/ /** @type {Error|false} */ | |
| /******/ var abortError = false; | |
| /******/ var doApply = false; | |
| /******/ var doDispose = false; | |
| /******/ var chainInfo = ""; | |
| /******/ if (result.chain) { | |
| /******/ chainInfo = "\nUpdate propagation: " + result.chain.join(" -> "); | |
| /******/ } | |
| /******/ switch (result.type) { | |
| /******/ case "self-declined": | |
| /******/ if (options.onDeclined) options.onDeclined(result); | |
| /******/ if (!options.ignoreDeclined) | |
| /******/ abortError = new Error( | |
| /******/ "Aborted because of self decline: " + | |
| /******/ result.moduleId + | |
| /******/ chainInfo | |
| /******/ ); | |
| /******/ break; | |
| /******/ case "declined": | |
| /******/ if (options.onDeclined) options.onDeclined(result); | |
| /******/ if (!options.ignoreDeclined) | |
| /******/ abortError = new Error( | |
| /******/ "Aborted because of declined dependency: " + | |
| /******/ result.moduleId + | |
| /******/ " in " + | |
| /******/ result.parentId + | |
| /******/ chainInfo | |
| /******/ ); | |
| /******/ break; | |
| /******/ case "unaccepted": | |
| /******/ if (options.onUnaccepted) options.onUnaccepted(result); | |
| /******/ if (!options.ignoreUnaccepted) | |
| /******/ abortError = new Error( | |
| /******/ "Aborted because " + moduleId + " is not accepted" + chainInfo | |
| /******/ ); | |
| /******/ break; | |
| /******/ case "accepted": | |
| /******/ if (options.onAccepted) options.onAccepted(result); | |
| /******/ doApply = true; | |
| /******/ break; | |
| /******/ case "disposed": | |
| /******/ if (options.onDisposed) options.onDisposed(result); | |
| /******/ doDispose = true; | |
| /******/ break; | |
| /******/ default: | |
| /******/ throw new Error("Unexception type " + result.type); | |
| /******/ } | |
| /******/ if (abortError) { | |
| /******/ hotSetStatus("abort"); | |
| /******/ return Promise.reject(abortError); | |
| /******/ } | |
| /******/ if (doApply) { | |
| /******/ appliedUpdate[moduleId] = hotUpdate[moduleId]; | |
| /******/ addAllToSet(outdatedModules, result.outdatedModules); | |
| /******/ for (moduleId in result.outdatedDependencies) { | |
| /******/ if ( | |
| /******/ Object.prototype.hasOwnProperty.call( | |
| /******/ result.outdatedDependencies, | |
| /******/ moduleId | |
| /******/ ) | |
| /******/ ) { | |
| /******/ if (!outdatedDependencies[moduleId]) | |
| /******/ outdatedDependencies[moduleId] = []; | |
| /******/ addAllToSet( | |
| /******/ outdatedDependencies[moduleId], | |
| /******/ result.outdatedDependencies[moduleId] | |
| /******/ ); | |
| /******/ } | |
| /******/ } | |
| /******/ } | |
| /******/ if (doDispose) { | |
| /******/ addAllToSet(outdatedModules, [result.moduleId]); | |
| /******/ appliedUpdate[moduleId] = warnUnexpectedRequire; | |
| /******/ } | |
| /******/ } | |
| /******/ } | |
| /******/ | |
| /******/ // Store self accepted outdated modules to require them later by the module system | |
| /******/ var outdatedSelfAcceptedModules = []; | |
| /******/ for (i = 0; i < outdatedModules.length; i++) { | |
| /******/ moduleId = outdatedModules[i]; | |
| /******/ if ( | |
| /******/ installedModules[moduleId] && | |
| /******/ installedModules[moduleId].hot._selfAccepted | |
| /******/ ) | |
| /******/ outdatedSelfAcceptedModules.push({ | |
| /******/ module: moduleId, | |
| /******/ errorHandler: installedModules[moduleId].hot._selfAccepted | |
| /******/ }); | |
| /******/ } | |
| /******/ | |
| /******/ // Now in "dispose" phase | |
| /******/ hotSetStatus("dispose"); | |
| /******/ Object.keys(hotAvailableFilesMap).forEach(function(chunkId) { | |
| /******/ if (hotAvailableFilesMap[chunkId] === false) { | |
| /******/ hotDisposeChunk(chunkId); | |
| /******/ } | |
| /******/ }); | |
| /******/ | |
| /******/ var idx; | |
| /******/ var queue = outdatedModules.slice(); | |
| /******/ while (queue.length > 0) { | |
| /******/ moduleId = queue.pop(); | |
| /******/ module = installedModules[moduleId]; | |
| /******/ if (!module) continue; | |
| /******/ | |
| /******/ var data = {}; | |
| /******/ | |
| /******/ // Call dispose handlers | |
| /******/ var disposeHandlers = module.hot._disposeHandlers; | |
| /******/ for (j = 0; j < disposeHandlers.length; j++) { | |
| /******/ cb = disposeHandlers[j]; | |
| /******/ cb(data); | |
| /******/ } | |
| /******/ hotCurrentModuleData[moduleId] = data; | |
| /******/ | |
| /******/ // disable module (this disables requires from this module) | |
| /******/ module.hot.active = false; | |
| /******/ | |
| /******/ // remove module from cache | |
| /******/ delete installedModules[moduleId]; | |
| /******/ | |
| /******/ // when disposing there is no need to call dispose handler | |
| /******/ delete outdatedDependencies[moduleId]; | |
| /******/ | |
| /******/ // remove "parents" references from all children | |
| /******/ for (j = 0; j < module.children.length; j++) { | |
| /******/ var child = installedModules[module.children[j]]; | |
| /******/ if (!child) continue; | |
| /******/ idx = child.parents.indexOf(moduleId); | |
| /******/ if (idx >= 0) { | |
| /******/ child.parents.splice(idx, 1); | |
| /******/ } | |
| /******/ } | |
| /******/ } | |
| /******/ | |
| /******/ // remove outdated dependency from module children | |
| /******/ var dependency; | |
| /******/ var moduleOutdatedDependencies; | |
| /******/ for (moduleId in outdatedDependencies) { | |
| /******/ if ( | |
| /******/ Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId) | |
| /******/ ) { | |
| /******/ module = installedModules[moduleId]; | |
| /******/ if (module) { | |
| /******/ moduleOutdatedDependencies = outdatedDependencies[moduleId]; | |
| /******/ for (j = 0; j < moduleOutdatedDependencies.length; j++) { | |
| /******/ dependency = moduleOutdatedDependencies[j]; | |
| /******/ idx = module.children.indexOf(dependency); | |
| /******/ if (idx >= 0) module.children.splice(idx, 1); | |
| /******/ } | |
| /******/ } | |
| /******/ } | |
| /******/ } | |
| /******/ | |
| /******/ // Not in "apply" phase | |
| /******/ hotSetStatus("apply"); | |
| /******/ | |
| /******/ hotCurrentHash = hotUpdateNewHash; | |
| /******/ | |
| /******/ // insert new code | |
| /******/ for (moduleId in appliedUpdate) { | |
| /******/ if (Object.prototype.hasOwnProperty.call(appliedUpdate, moduleId)) { | |
| /******/ modules[moduleId] = appliedUpdate[moduleId]; | |
| /******/ } | |
| /******/ } | |
| /******/ | |
| /******/ // call accept handlers | |
| /******/ var error = null; | |
| /******/ for (moduleId in outdatedDependencies) { | |
| /******/ if ( | |
| /******/ Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId) | |
| /******/ ) { | |
| /******/ module = installedModules[moduleId]; | |
| /******/ if (module) { | |
| /******/ moduleOutdatedDependencies = outdatedDependencies[moduleId]; | |
| /******/ var callbacks = []; | |
| /******/ for (i = 0; i < moduleOutdatedDependencies.length; i++) { | |
| /******/ dependency = moduleOutdatedDependencies[i]; | |
| /******/ cb = module.hot._acceptedDependencies[dependency]; | |
| /******/ if (cb) { | |
| /******/ if (callbacks.indexOf(cb) !== -1) continue; | |
| /******/ callbacks.push(cb); | |
| /******/ } | |
| /******/ } | |
| /******/ for (i = 0; i < callbacks.length; i++) { | |
| /******/ cb = callbacks[i]; | |
| /******/ try { | |
| /******/ cb(moduleOutdatedDependencies); | |
| /******/ } catch (err) { | |
| /******/ if (options.onErrored) { | |
| /******/ options.onErrored({ | |
| /******/ type: "accept-errored", | |
| /******/ moduleId: moduleId, | |
| /******/ dependencyId: moduleOutdatedDependencies[i], | |
| /******/ error: err | |
| /******/ }); | |
| /******/ } | |
| /******/ if (!options.ignoreErrored) { | |
| /******/ if (!error) error = err; | |
| /******/ } | |
| /******/ } | |
| /******/ } | |
| /******/ } | |
| /******/ } | |
| /******/ } | |
| /******/ | |
| /******/ // Load self accepted modules | |
| /******/ for (i = 0; i < outdatedSelfAcceptedModules.length; i++) { | |
| /******/ var item = outdatedSelfAcceptedModules[i]; | |
| /******/ moduleId = item.module; | |
| /******/ hotCurrentParents = [moduleId]; | |
| /******/ try { | |
| /******/ __webpack_require__(moduleId); | |
| /******/ } catch (err) { | |
| /******/ if (typeof item.errorHandler === "function") { | |
| /******/ try { | |
| /******/ item.errorHandler(err); | |
| /******/ } catch (err2) { | |
| /******/ if (options.onErrored) { | |
| /******/ options.onErrored({ | |
| /******/ type: "self-accept-error-handler-errored", | |
| /******/ moduleId: moduleId, | |
| /******/ error: err2, | |
| /******/ originalError: err | |
| /******/ }); | |
| /******/ } | |
| /******/ if (!options.ignoreErrored) { | |
| /******/ if (!error) error = err2; | |
| /******/ } | |
| /******/ if (!error) error = err; | |
| /******/ } | |
| /******/ } else { | |
| /******/ if (options.onErrored) { | |
| /******/ options.onErrored({ | |
| /******/ type: "self-accept-errored", | |
| /******/ moduleId: moduleId, | |
| /******/ error: err | |
| /******/ }); | |
| /******/ } | |
| /******/ if (!options.ignoreErrored) { | |
| /******/ if (!error) error = err; | |
| /******/ } | |
| /******/ } | |
| /******/ } | |
| /******/ } | |
| /******/ | |
| /******/ // handle errors in accept handlers and self accepted module load | |
| /******/ if (error) { | |
| /******/ hotSetStatus("fail"); | |
| /******/ return Promise.reject(error); | |
| /******/ } | |
| /******/ | |
| /******/ hotSetStatus("idle"); | |
| /******/ return new Promise(function(resolve) { | |
| /******/ resolve(outdatedModules); | |
| /******/ }); | |
| /******/ } | |
| /******/ | |
| /******/ // The module cache | |
| /******/ var installedModules = {}; | |
| /******/ | |
| /******/ // The require function | |
| /******/ function __webpack_require__(moduleId) { | |
| /******/ | |
| /******/ // Check if module is in cache | |
| /******/ if(installedModules[moduleId]) { | |
| /******/ return installedModules[moduleId].exports; | |
| /******/ } | |
| /******/ // Create a new module (and put it into the cache) | |
| /******/ var module = installedModules[moduleId] = { | |
| /******/ i: moduleId, | |
| /******/ l: false, | |
| /******/ exports: {}, | |
| /******/ hot: hotCreateModule(moduleId), | |
| /******/ parents: (hotCurrentParentsTemp = hotCurrentParents, hotCurrentParents = [], hotCurrentParentsTemp), | |
| /******/ children: [] | |
| /******/ }; | |
| /******/ | |
| /******/ // Execute the module function | |
| /******/ modules[moduleId].call(module.exports, module, module.exports, hotCreateRequire(moduleId)); | |
| /******/ | |
| /******/ // Flag the module as loaded | |
| /******/ module.l = true; | |
| /******/ | |
| /******/ // Return the exports of the module | |
| /******/ return module.exports; | |
| /******/ } | |
| /******/ | |
| /******/ | |
| /******/ // expose the modules object (__webpack_modules__) | |
| /******/ __webpack_require__.m = modules; | |
| /******/ | |
| /******/ // expose the module cache | |
| /******/ __webpack_require__.c = installedModules; | |
| /******/ | |
| /******/ // define getter function for harmony exports | |
| /******/ __webpack_require__.d = function(exports, name, getter) { | |
| /******/ if(!__webpack_require__.o(exports, name)) { | |
| /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); | |
| /******/ } | |
| /******/ }; | |
| /******/ | |
| /******/ // define __esModule on exports | |
| /******/ __webpack_require__.r = function(exports) { | |
| /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { | |
| /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); | |
| /******/ } | |
| /******/ Object.defineProperty(exports, '__esModule', { value: true }); | |
| /******/ }; | |
| /******/ | |
| /******/ // create a fake namespace object | |
| /******/ // mode & 1: value is a module id, require it | |
| /******/ // mode & 2: merge all properties of value into the ns | |
| /******/ // mode & 4: return value when already ns object | |
| /******/ // mode & 8|1: behave like require | |
| /******/ __webpack_require__.t = function(value, mode) { | |
| /******/ if(mode & 1) value = __webpack_require__(value); | |
| /******/ if(mode & 8) return value; | |
| /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; | |
| /******/ var ns = Object.create(null); | |
| /******/ __webpack_require__.r(ns); | |
| /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); | |
| /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); | |
| /******/ return ns; | |
| /******/ }; | |
| /******/ | |
| /******/ // getDefaultExport function for compatibility with non-harmony modules | |
| /******/ __webpack_require__.n = function(module) { | |
| /******/ var getter = module && module.__esModule ? | |
| /******/ function getDefault() { return module['default']; } : | |
| /******/ function getModuleExports() { return module; }; | |
| /******/ __webpack_require__.d(getter, 'a', getter); | |
| /******/ return getter; | |
| /******/ }; | |
| /******/ | |
| /******/ // Object.prototype.hasOwnProperty.call | |
| /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; | |
| /******/ | |
| /******/ // __webpack_public_path__ | |
| /******/ __webpack_require__.p = "/"; | |
| /******/ | |
| /******/ // __webpack_hash__ | |
| /******/ __webpack_require__.h = function() { return hotCurrentHash; }; | |
| /******/ | |
| /******/ | |
| /******/ // Load entry module and return exports | |
| /******/ return hotCreateRequire(0)(__webpack_require__.s = 0); | |
| /******/ }) | |
| /************************************************************************/ | |
| /******/ ({ | |
| /***/ "../babel-generator/lib/buffer.js": | |
| /*!****************************************!*\ | |
| !*** ../babel-generator/lib/buffer.js ***! | |
| \****************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = void 0; | |
| function _trimRight() { | |
| const data = _interopRequireDefault(__webpack_require__(/*! trim-right */ "../babel-generator/node_modules/trim-right/index.js")); | |
| _trimRight = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function _interopRequireDefault(obj) { | |
| return obj && obj.__esModule ? obj : { | |
| default: obj | |
| }; | |
| } | |
| const SPACES_RE = /^[ \t]+$/; | |
| class Buffer { | |
| constructor(map) { | |
| this._map = null; | |
| this._buf = []; | |
| this._last = ""; | |
| this._queue = []; | |
| this._position = { | |
| line: 1, | |
| column: 0 | |
| }; | |
| this._sourcePosition = { | |
| identifierName: null, | |
| line: null, | |
| column: null, | |
| filename: null | |
| }; | |
| this._disallowedPop = null; | |
| this._map = map; | |
| } | |
| get() { | |
| this._flush(); | |
| const map = this._map; | |
| const result = { | |
| code: (0, _trimRight().default)(this._buf.join("")), | |
| map: null, | |
| rawMappings: map && map.getRawMappings() | |
| }; | |
| if (map) { | |
| Object.defineProperty(result, "map", { | |
| configurable: true, | |
| enumerable: true, | |
| get() { | |
| return this.map = map.get(); | |
| }, | |
| set(value) { | |
| Object.defineProperty(this, "map", { | |
| value, | |
| writable: true | |
| }); | |
| } | |
| }); | |
| } | |
| return result; | |
| } | |
| append(str) { | |
| this._flush(); | |
| const { | |
| line, | |
| column, | |
| filename, | |
| identifierName, | |
| force | |
| } = this._sourcePosition; | |
| this._append(str, line, column, identifierName, filename, force); | |
| } | |
| queue(str) { | |
| if (str === "\n") { | |
| while (this._queue.length > 0 && SPACES_RE.test(this._queue[0][0])) { | |
| this._queue.shift(); | |
| } | |
| } | |
| const { | |
| line, | |
| column, | |
| filename, | |
| identifierName, | |
| force | |
| } = this._sourcePosition; | |
| this._queue.unshift([str, line, column, identifierName, filename, force]); | |
| } | |
| _flush() { | |
| let item; | |
| while (item = this._queue.pop()) this._append(...item); | |
| } | |
| _append(str, line, column, identifierName, filename, force) { | |
| if (this._map && str[0] !== "\n") { | |
| this._map.mark(this._position.line, this._position.column, line, column, identifierName, filename, force); | |
| } | |
| this._buf.push(str); | |
| this._last = str[str.length - 1]; | |
| for (let i = 0; i < str.length; i++) { | |
| if (str[i] === "\n") { | |
| this._position.line++; | |
| this._position.column = 0; | |
| } else { | |
| this._position.column++; | |
| } | |
| } | |
| } | |
| removeTrailingNewline() { | |
| if (this._queue.length > 0 && this._queue[0][0] === "\n") { | |
| this._queue.shift(); | |
| } | |
| } | |
| removeLastSemicolon() { | |
| if (this._queue.length > 0 && this._queue[0][0] === ";") { | |
| this._queue.shift(); | |
| } | |
| } | |
| endsWith(suffix) { | |
| if (suffix.length === 1) { | |
| let last; | |
| if (this._queue.length > 0) { | |
| const str = this._queue[0][0]; | |
| last = str[str.length - 1]; | |
| } else { | |
| last = this._last; | |
| } | |
| return last === suffix; | |
| } | |
| const end = this._last + this._queue.reduce((acc, item) => item[0] + acc, ""); | |
| if (suffix.length <= end.length) { | |
| return end.slice(-suffix.length) === suffix; | |
| } | |
| return false; | |
| } | |
| hasContent() { | |
| return this._queue.length > 0 || !!this._last; | |
| } | |
| exactSource(loc, cb) { | |
| this.source("start", loc, true); | |
| cb(); | |
| this.source("end", loc); | |
| this._disallowPop("start", loc); | |
| } | |
| source(prop, loc, force) { | |
| if (prop && !loc) return; | |
| this._normalizePosition(prop, loc, this._sourcePosition, force); | |
| } | |
| withSource(prop, loc, cb) { | |
| if (!this._map) return cb(); | |
| const originalLine = this._sourcePosition.line; | |
| const originalColumn = this._sourcePosition.column; | |
| const originalFilename = this._sourcePosition.filename; | |
| const originalIdentifierName = this._sourcePosition.identifierName; | |
| this.source(prop, loc); | |
| cb(); | |
| if ((!this._sourcePosition.force || this._sourcePosition.line !== originalLine || this._sourcePosition.column !== originalColumn || this._sourcePosition.filename !== originalFilename) && (!this._disallowedPop || this._disallowedPop.line !== originalLine || this._disallowedPop.column !== originalColumn || this._disallowedPop.filename !== originalFilename)) { | |
| this._sourcePosition.line = originalLine; | |
| this._sourcePosition.column = originalColumn; | |
| this._sourcePosition.filename = originalFilename; | |
| this._sourcePosition.identifierName = originalIdentifierName; | |
| this._sourcePosition.force = false; | |
| this._disallowedPop = null; | |
| } | |
| } | |
| _disallowPop(prop, loc) { | |
| if (prop && !loc) return; | |
| this._disallowedPop = this._normalizePosition(prop, loc); | |
| } | |
| _normalizePosition(prop, loc, targetObj, force) { | |
| const pos = loc ? loc[prop] : null; | |
| if (targetObj === undefined) { | |
| targetObj = { | |
| identifierName: null, | |
| line: null, | |
| column: null, | |
| filename: null, | |
| force: false | |
| }; | |
| } | |
| const origLine = targetObj.line; | |
| const origColumn = targetObj.column; | |
| const origFilename = targetObj.filename; | |
| targetObj.identifierName = prop === "start" && loc && loc.identifierName || null; | |
| targetObj.line = pos ? pos.line : null; | |
| targetObj.column = pos ? pos.column : null; | |
| targetObj.filename = loc && loc.filename || null; | |
| if (force || targetObj.line !== origLine || targetObj.column !== origColumn || targetObj.filename !== origFilename) { | |
| targetObj.force = force; | |
| } | |
| return targetObj; | |
| } | |
| getCurrentColumn() { | |
| const extra = this._queue.reduce((acc, item) => item[0] + acc, ""); | |
| const lastIndex = extra.lastIndexOf("\n"); | |
| return lastIndex === -1 ? this._position.column + extra.length : extra.length - 1 - lastIndex; | |
| } | |
| getCurrentLine() { | |
| const extra = this._queue.reduce((acc, item) => item[0] + acc, ""); | |
| let count = 0; | |
| for (let i = 0; i < extra.length; i++) { | |
| if (extra[i] === "\n") count++; | |
| } | |
| return this._position.line + count; | |
| } | |
| } | |
| exports.default = Buffer; | |
| /***/ }), | |
| /***/ "../babel-generator/lib/generators/base.js": | |
| /*!*************************************************!*\ | |
| !*** ../babel-generator/lib/generators/base.js ***! | |
| \*************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.File = File; | |
| exports.Program = Program; | |
| exports.BlockStatement = BlockStatement; | |
| exports.Noop = Noop; | |
| exports.Directive = Directive; | |
| exports.DirectiveLiteral = DirectiveLiteral; | |
| exports.InterpreterDirective = InterpreterDirective; | |
| exports.Placeholder = Placeholder; | |
| function File(node) { | |
| if (node.program) { | |
| this.print(node.program.interpreter, node); | |
| } | |
| this.print(node.program, node); | |
| } | |
| function Program(node) { | |
| this.printInnerComments(node, false); | |
| this.printSequence(node.directives, node); | |
| if (node.directives && node.directives.length) this.newline(); | |
| this.printSequence(node.body, node); | |
| } | |
| function BlockStatement(node) { | |
| this.token("{"); | |
| this.printInnerComments(node); | |
| const hasDirectives = node.directives && node.directives.length; | |
| if (node.body.length || hasDirectives) { | |
| // Skip any newlines if the node has gaps. These are handled in the | |
| // print() method of printer.js. | |
| if (!node.newlines) { | |
| this.newline(); | |
| } | |
| this.printSequence(node.directives, node, { | |
| indent: true | |
| }); | |
| if (hasDirectives) this.newline(); | |
| this.printSequence(node.body, node, { | |
| indent: true | |
| }); | |
| if (!node.newlines) { | |
| this.removeTrailingNewline(); | |
| } | |
| this.source("end", node.loc); | |
| if (!node.newlines) { | |
| if (!this.endsWith("\n")) this.newline(); | |
| } | |
| this.rightBrace(); | |
| } else { | |
| this.source("end", node.loc); | |
| this.token("}"); | |
| } | |
| } | |
| function Noop() {} | |
| function Directive(node) { | |
| this.print(node.value, node); | |
| this.semicolon(); | |
| } | |
| const unescapedSingleQuoteRE = /(?:^|[^\\])(?:\\\\)*'/; | |
| const unescapedDoubleQuoteRE = /(?:^|[^\\])(?:\\\\)*"/; | |
| function DirectiveLiteral(node) { | |
| const raw = this.getPossibleRaw(node); | |
| if (raw != null) { | |
| this.token(raw); | |
| return; | |
| } | |
| const { | |
| value | |
| } = node; | |
| if (!unescapedDoubleQuoteRE.test(value)) { | |
| this.token(`"${value}"`); | |
| } else if (!unescapedSingleQuoteRE.test(value)) { | |
| this.token(`'${value}'`); | |
| } else { | |
| throw new Error("Malformed AST: it is not possible to print a directive containing" + " both unescaped single and double quotes."); | |
| } | |
| } | |
| function InterpreterDirective(node) { | |
| this.token(`#!${node.value}\n`); | |
| } | |
| function Placeholder(node) { | |
| this.token("%%"); | |
| this.print(node.name); | |
| this.token("%%"); | |
| if (node.expectedNode === "Statement") { | |
| this.semicolon(); | |
| } | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/generators/classes.js": | |
| /*!****************************************************!*\ | |
| !*** ../babel-generator/lib/generators/classes.js ***! | |
| \****************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.ClassExpression = exports.ClassDeclaration = ClassDeclaration; | |
| exports.ClassBody = ClassBody; | |
| exports.ClassProperty = ClassProperty; | |
| exports.ClassPrivateProperty = ClassPrivateProperty; | |
| exports.ClassMethod = ClassMethod; | |
| exports.ClassPrivateMethod = ClassPrivateMethod; | |
| exports._classMethodHead = _classMethodHead; | |
| function t() { | |
| const data = _interopRequireWildcard(__webpack_require__(/*! @babel/types */ "../babel-generator/node_modules/@babel/types/lib/index.js")); | |
| t = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function _interopRequireWildcard(obj) { | |
| if (obj && obj.__esModule) { | |
| return obj; | |
| } else { | |
| var newObj = {}; | |
| if (obj != null) { | |
| for (var key in obj) { | |
| if (Object.prototype.hasOwnProperty.call(obj, key)) { | |
| var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; | |
| if (desc.get || desc.set) { | |
| Object.defineProperty(newObj, key, desc); | |
| } else { | |
| newObj[key] = obj[key]; | |
| } | |
| } | |
| } | |
| } | |
| newObj.default = obj; | |
| return newObj; | |
| } | |
| } | |
| function ClassDeclaration(node, parent) { | |
| if (!this.format.decoratorsBeforeExport || !t().isExportDefaultDeclaration(parent) && !t().isExportNamedDeclaration(parent)) { | |
| this.printJoin(node.decorators, node); | |
| } | |
| if (node.declare) { | |
| this.word("declare"); | |
| this.space(); | |
| } | |
| if (node.abstract) { | |
| this.word("abstract"); | |
| this.space(); | |
| } | |
| this.word("class"); | |
| if (node.id) { | |
| this.space(); | |
| this.print(node.id, node); | |
| } | |
| this.print(node.typeParameters, node); | |
| if (node.superClass) { | |
| this.space(); | |
| this.word("extends"); | |
| this.space(); | |
| this.print(node.superClass, node); | |
| this.print(node.superTypeParameters, node); | |
| } | |
| if (node.implements) { | |
| this.space(); | |
| this.word("implements"); | |
| this.space(); | |
| this.printList(node.implements, node); | |
| } | |
| this.space(); | |
| this.print(node.body, node); | |
| } | |
| function ClassBody(node) { | |
| this.token("{"); | |
| this.printInnerComments(node); | |
| if (node.body.length === 0) { | |
| this.token("}"); | |
| } else { | |
| this.newline(); | |
| this.indent(); | |
| this.printSequence(node.body, node); | |
| this.dedent(); | |
| if (!this.endsWith("\n")) this.newline(); | |
| this.rightBrace(); | |
| } | |
| } | |
| function ClassProperty(node) { | |
| this.printJoin(node.decorators, node); | |
| if (node.accessibility) { | |
| this.word(node.accessibility); | |
| this.space(); | |
| } | |
| if (node.static) { | |
| this.word("static"); | |
| this.space(); | |
| } | |
| if (node.abstract) { | |
| this.word("abstract"); | |
| this.space(); | |
| } | |
| if (node.readonly) { | |
| this.word("readonly"); | |
| this.space(); | |
| } | |
| if (node.computed) { | |
| this.token("["); | |
| this.print(node.key, node); | |
| this.token("]"); | |
| } else { | |
| this._variance(node); | |
| this.print(node.key, node); | |
| } | |
| if (node.optional) { | |
| this.token("?"); | |
| } | |
| if (node.definite) { | |
| this.token("!"); | |
| } | |
| this.print(node.typeAnnotation, node); | |
| if (node.value) { | |
| this.space(); | |
| this.token("="); | |
| this.space(); | |
| this.print(node.value, node); | |
| } | |
| this.semicolon(); | |
| } | |
| function ClassPrivateProperty(node) { | |
| if (node.static) { | |
| this.word("static"); | |
| this.space(); | |
| } | |
| this.print(node.key, node); | |
| this.print(node.typeAnnotation, node); | |
| if (node.value) { | |
| this.space(); | |
| this.token("="); | |
| this.space(); | |
| this.print(node.value, node); | |
| } | |
| this.semicolon(); | |
| } | |
| function ClassMethod(node) { | |
| this._classMethodHead(node); | |
| this.space(); | |
| this.print(node.body, node); | |
| } | |
| function ClassPrivateMethod(node) { | |
| this._classMethodHead(node); | |
| this.space(); | |
| this.print(node.body, node); | |
| } | |
| function _classMethodHead(node) { | |
| this.printJoin(node.decorators, node); | |
| if (node.accessibility) { | |
| this.word(node.accessibility); | |
| this.space(); | |
| } | |
| if (node.abstract) { | |
| this.word("abstract"); | |
| this.space(); | |
| } | |
| if (node.static) { | |
| this.word("static"); | |
| this.space(); | |
| } | |
| this._methodHead(node); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/generators/expressions.js": | |
| /*!********************************************************!*\ | |
| !*** ../babel-generator/lib/generators/expressions.js ***! | |
| \********************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.UnaryExpression = UnaryExpression; | |
| exports.DoExpression = DoExpression; | |
| exports.ParenthesizedExpression = ParenthesizedExpression; | |
| exports.UpdateExpression = UpdateExpression; | |
| exports.ConditionalExpression = ConditionalExpression; | |
| exports.NewExpression = NewExpression; | |
| exports.SequenceExpression = SequenceExpression; | |
| exports.ThisExpression = ThisExpression; | |
| exports.Super = Super; | |
| exports.Decorator = Decorator; | |
| exports.OptionalMemberExpression = OptionalMemberExpression; | |
| exports.OptionalCallExpression = OptionalCallExpression; | |
| exports.CallExpression = CallExpression; | |
| exports.Import = Import; | |
| exports.EmptyStatement = EmptyStatement; | |
| exports.ExpressionStatement = ExpressionStatement; | |
| exports.AssignmentPattern = AssignmentPattern; | |
| exports.LogicalExpression = exports.BinaryExpression = exports.AssignmentExpression = AssignmentExpression; | |
| exports.BindExpression = BindExpression; | |
| exports.MemberExpression = MemberExpression; | |
| exports.MetaProperty = MetaProperty; | |
| exports.PrivateName = PrivateName; | |
| exports.AwaitExpression = exports.YieldExpression = void 0; | |
| function t() { | |
| const data = _interopRequireWildcard(__webpack_require__(/*! @babel/types */ "../babel-generator/node_modules/@babel/types/lib/index.js")); | |
| t = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| var n = _interopRequireWildcard(__webpack_require__(/*! ../node */ "../babel-generator/lib/node/index.js")); | |
| function _interopRequireWildcard(obj) { | |
| if (obj && obj.__esModule) { | |
| return obj; | |
| } else { | |
| var newObj = {}; | |
| if (obj != null) { | |
| for (var key in obj) { | |
| if (Object.prototype.hasOwnProperty.call(obj, key)) { | |
| var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; | |
| if (desc.get || desc.set) { | |
| Object.defineProperty(newObj, key, desc); | |
| } else { | |
| newObj[key] = obj[key]; | |
| } | |
| } | |
| } | |
| } | |
| newObj.default = obj; | |
| return newObj; | |
| } | |
| } | |
| function UnaryExpression(node) { | |
| if (node.operator === "void" || node.operator === "delete" || node.operator === "typeof" || node.operator === "throw") { | |
| this.word(node.operator); | |
| this.space(); | |
| } else { | |
| this.token(node.operator); | |
| } | |
| this.print(node.argument, node); | |
| } | |
| function DoExpression(node) { | |
| this.word("do"); | |
| this.space(); | |
| this.print(node.body, node); | |
| } | |
| function ParenthesizedExpression(node) { | |
| this.token("("); | |
| this.print(node.expression, node); | |
| this.token(")"); | |
| } | |
| function UpdateExpression(node) { | |
| if (node.prefix) { | |
| this.token(node.operator); | |
| this.print(node.argument, node); | |
| } else { | |
| this.startTerminatorless(true); | |
| this.print(node.argument, node); | |
| this.endTerminatorless(); | |
| this.token(node.operator); | |
| } | |
| } | |
| function ConditionalExpression(node) { | |
| this.print(node.test, node); | |
| this.space(); | |
| this.token("?"); | |
| this.space(); | |
| this.print(node.consequent, node); | |
| this.space(); | |
| this.token(":"); | |
| this.space(); | |
| this.print(node.alternate, node); | |
| } | |
| function NewExpression(node, parent) { | |
| this.word("new"); | |
| this.space(); | |
| this.print(node.callee, node); | |
| if (this.format.minified && node.arguments.length === 0 && !node.optional && !t().isCallExpression(parent, { | |
| callee: node | |
| }) && !t().isMemberExpression(parent) && !t().isNewExpression(parent)) { | |
| return; | |
| } | |
| this.print(node.typeArguments, node); | |
| this.print(node.typeParameters, node); | |
| if (node.optional) { | |
| this.token("?."); | |
| } | |
| this.token("("); | |
| this.printList(node.arguments, node); | |
| this.token(")"); | |
| } | |
| function SequenceExpression(node) { | |
| this.printList(node.expressions, node); | |
| } | |
| function ThisExpression() { | |
| this.word("this"); | |
| } | |
| function Super() { | |
| this.word("super"); | |
| } | |
| function Decorator(node) { | |
| this.token("@"); | |
| this.print(node.expression, node); | |
| this.newline(); | |
| } | |
| function OptionalMemberExpression(node) { | |
| this.print(node.object, node); | |
| if (!node.computed && t().isMemberExpression(node.property)) { | |
| throw new TypeError("Got a MemberExpression for MemberExpression property"); | |
| } | |
| let computed = node.computed; | |
| if (t().isLiteral(node.property) && typeof node.property.value === "number") { | |
| computed = true; | |
| } | |
| if (node.optional) { | |
| this.token("?."); | |
| } | |
| if (computed) { | |
| this.token("["); | |
| this.print(node.property, node); | |
| this.token("]"); | |
| } else { | |
| if (!node.optional) { | |
| this.token("."); | |
| } | |
| this.print(node.property, node); | |
| } | |
| } | |
| function OptionalCallExpression(node) { | |
| this.print(node.callee, node); | |
| this.print(node.typeArguments, node); | |
| this.print(node.typeParameters, node); | |
| if (node.optional) { | |
| this.token("?."); | |
| } | |
| this.token("("); | |
| this.printList(node.arguments, node); | |
| this.token(")"); | |
| } | |
| function CallExpression(node) { | |
| this.print(node.callee, node); | |
| this.print(node.typeArguments, node); | |
| this.print(node.typeParameters, node); | |
| this.token("("); | |
| this.printList(node.arguments, node); | |
| this.token(")"); | |
| } | |
| function Import() { | |
| this.word("import"); | |
| } | |
| function buildYieldAwait(keyword) { | |
| return function (node) { | |
| this.word(keyword); | |
| if (node.delegate) { | |
| this.token("*"); | |
| } | |
| if (node.argument) { | |
| this.space(); | |
| const terminatorState = this.startTerminatorless(); | |
| this.print(node.argument, node); | |
| this.endTerminatorless(terminatorState); | |
| } | |
| }; | |
| } | |
| const YieldExpression = buildYieldAwait("yield"); | |
| exports.YieldExpression = YieldExpression; | |
| const AwaitExpression = buildYieldAwait("await"); | |
| exports.AwaitExpression = AwaitExpression; | |
| function EmptyStatement() { | |
| this.semicolon(true); | |
| } | |
| function ExpressionStatement(node) { | |
| this.print(node.expression, node); | |
| this.semicolon(); | |
| } | |
| function AssignmentPattern(node) { | |
| this.print(node.left, node); | |
| if (node.left.optional) this.token("?"); | |
| this.print(node.left.typeAnnotation, node); | |
| this.space(); | |
| this.token("="); | |
| this.space(); | |
| this.print(node.right, node); | |
| } | |
| function AssignmentExpression(node, parent) { | |
| const parens = this.inForStatementInitCounter && node.operator === "in" && !n.needsParens(node, parent); | |
| if (parens) { | |
| this.token("("); | |
| } | |
| this.print(node.left, node); | |
| this.space(); | |
| if (node.operator === "in" || node.operator === "instanceof") { | |
| this.word(node.operator); | |
| } else { | |
| this.token(node.operator); | |
| } | |
| this.space(); | |
| this.print(node.right, node); | |
| if (parens) { | |
| this.token(")"); | |
| } | |
| } | |
| function BindExpression(node) { | |
| this.print(node.object, node); | |
| this.token("::"); | |
| this.print(node.callee, node); | |
| } | |
| function MemberExpression(node) { | |
| this.print(node.object, node); | |
| if (!node.computed && t().isMemberExpression(node.property)) { | |
| throw new TypeError("Got a MemberExpression for MemberExpression property"); | |
| } | |
| let computed = node.computed; | |
| if (t().isLiteral(node.property) && typeof node.property.value === "number") { | |
| computed = true; | |
| } | |
| if (computed) { | |
| this.token("["); | |
| this.print(node.property, node); | |
| this.token("]"); | |
| } else { | |
| this.token("."); | |
| this.print(node.property, node); | |
| } | |
| } | |
| function MetaProperty(node) { | |
| this.print(node.meta, node); | |
| this.token("."); | |
| this.print(node.property, node); | |
| } | |
| function PrivateName(node) { | |
| this.token("#"); | |
| this.print(node.id, node); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/generators/flow.js": | |
| /*!*************************************************!*\ | |
| !*** ../babel-generator/lib/generators/flow.js ***! | |
| \*************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.AnyTypeAnnotation = AnyTypeAnnotation; | |
| exports.ArrayTypeAnnotation = ArrayTypeAnnotation; | |
| exports.BooleanTypeAnnotation = BooleanTypeAnnotation; | |
| exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation; | |
| exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation; | |
| exports.DeclareClass = DeclareClass; | |
| exports.DeclareFunction = DeclareFunction; | |
| exports.InferredPredicate = InferredPredicate; | |
| exports.DeclaredPredicate = DeclaredPredicate; | |
| exports.DeclareInterface = DeclareInterface; | |
| exports.DeclareModule = DeclareModule; | |
| exports.DeclareModuleExports = DeclareModuleExports; | |
| exports.DeclareTypeAlias = DeclareTypeAlias; | |
| exports.DeclareOpaqueType = DeclareOpaqueType; | |
| exports.DeclareVariable = DeclareVariable; | |
| exports.DeclareExportDeclaration = DeclareExportDeclaration; | |
| exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration; | |
| exports.ExistsTypeAnnotation = ExistsTypeAnnotation; | |
| exports.FunctionTypeAnnotation = FunctionTypeAnnotation; | |
| exports.FunctionTypeParam = FunctionTypeParam; | |
| exports.GenericTypeAnnotation = exports.ClassImplements = exports.InterfaceExtends = InterfaceExtends; | |
| exports._interfaceish = _interfaceish; | |
| exports._variance = _variance; | |
| exports.InterfaceDeclaration = InterfaceDeclaration; | |
| exports.InterfaceTypeAnnotation = InterfaceTypeAnnotation; | |
| exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation; | |
| exports.MixedTypeAnnotation = MixedTypeAnnotation; | |
| exports.EmptyTypeAnnotation = EmptyTypeAnnotation; | |
| exports.NullableTypeAnnotation = NullableTypeAnnotation; | |
| exports.NumberTypeAnnotation = NumberTypeAnnotation; | |
| exports.StringTypeAnnotation = StringTypeAnnotation; | |
| exports.ThisTypeAnnotation = ThisTypeAnnotation; | |
| exports.TupleTypeAnnotation = TupleTypeAnnotation; | |
| exports.TypeofTypeAnnotation = TypeofTypeAnnotation; | |
| exports.TypeAlias = TypeAlias; | |
| exports.TypeAnnotation = TypeAnnotation; | |
| exports.TypeParameterDeclaration = exports.TypeParameterInstantiation = TypeParameterInstantiation; | |
| exports.TypeParameter = TypeParameter; | |
| exports.OpaqueType = OpaqueType; | |
| exports.ObjectTypeAnnotation = ObjectTypeAnnotation; | |
| exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot; | |
| exports.ObjectTypeCallProperty = ObjectTypeCallProperty; | |
| exports.ObjectTypeIndexer = ObjectTypeIndexer; | |
| exports.ObjectTypeProperty = ObjectTypeProperty; | |
| exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty; | |
| exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier; | |
| exports.UnionTypeAnnotation = UnionTypeAnnotation; | |
| exports.TypeCastExpression = TypeCastExpression; | |
| exports.Variance = Variance; | |
| exports.VoidTypeAnnotation = VoidTypeAnnotation; | |
| Object.defineProperty(exports, "NumberLiteralTypeAnnotation", { | |
| enumerable: true, | |
| get: function () { | |
| return _types2.NumericLiteral; | |
| } | |
| }); | |
| Object.defineProperty(exports, "StringLiteralTypeAnnotation", { | |
| enumerable: true, | |
| get: function () { | |
| return _types2.StringLiteral; | |
| } | |
| }); | |
| function t() { | |
| const data = _interopRequireWildcard(__webpack_require__(/*! @babel/types */ "../babel-generator/node_modules/@babel/types/lib/index.js")); | |
| t = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| var _modules = __webpack_require__(/*! ./modules */ "../babel-generator/lib/generators/modules.js"); | |
| var _types2 = __webpack_require__(/*! ./types */ "../babel-generator/lib/generators/types.js"); | |
| function _interopRequireWildcard(obj) { | |
| if (obj && obj.__esModule) { | |
| return obj; | |
| } else { | |
| var newObj = {}; | |
| if (obj != null) { | |
| for (var key in obj) { | |
| if (Object.prototype.hasOwnProperty.call(obj, key)) { | |
| var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; | |
| if (desc.get || desc.set) { | |
| Object.defineProperty(newObj, key, desc); | |
| } else { | |
| newObj[key] = obj[key]; | |
| } | |
| } | |
| } | |
| } | |
| newObj.default = obj; | |
| return newObj; | |
| } | |
| } | |
| function AnyTypeAnnotation() { | |
| this.word("any"); | |
| } | |
| function ArrayTypeAnnotation(node) { | |
| this.print(node.elementType, node); | |
| this.token("["); | |
| this.token("]"); | |
| } | |
| function BooleanTypeAnnotation() { | |
| this.word("boolean"); | |
| } | |
| function BooleanLiteralTypeAnnotation(node) { | |
| this.word(node.value ? "true" : "false"); | |
| } | |
| function NullLiteralTypeAnnotation() { | |
| this.word("null"); | |
| } | |
| function DeclareClass(node, parent) { | |
| if (!t().isDeclareExportDeclaration(parent)) { | |
| this.word("declare"); | |
| this.space(); | |
| } | |
| this.word("class"); | |
| this.space(); | |
| this._interfaceish(node); | |
| } | |
| function DeclareFunction(node, parent) { | |
| if (!t().isDeclareExportDeclaration(parent)) { | |
| this.word("declare"); | |
| this.space(); | |
| } | |
| this.word("function"); | |
| this.space(); | |
| this.print(node.id, node); | |
| this.print(node.id.typeAnnotation.typeAnnotation, node); | |
| if (node.predicate) { | |
| this.space(); | |
| this.print(node.predicate, node); | |
| } | |
| this.semicolon(); | |
| } | |
| function InferredPredicate() { | |
| this.token("%"); | |
| this.word("checks"); | |
| } | |
| function DeclaredPredicate(node) { | |
| this.token("%"); | |
| this.word("checks"); | |
| this.token("("); | |
| this.print(node.value, node); | |
| this.token(")"); | |
| } | |
| function DeclareInterface(node) { | |
| this.word("declare"); | |
| this.space(); | |
| this.InterfaceDeclaration(node); | |
| } | |
| function DeclareModule(node) { | |
| this.word("declare"); | |
| this.space(); | |
| this.word("module"); | |
| this.space(); | |
| this.print(node.id, node); | |
| this.space(); | |
| this.print(node.body, node); | |
| } | |
| function DeclareModuleExports(node) { | |
| this.word("declare"); | |
| this.space(); | |
| this.word("module"); | |
| this.token("."); | |
| this.word("exports"); | |
| this.print(node.typeAnnotation, node); | |
| } | |
| function DeclareTypeAlias(node) { | |
| this.word("declare"); | |
| this.space(); | |
| this.TypeAlias(node); | |
| } | |
| function DeclareOpaqueType(node, parent) { | |
| if (!t().isDeclareExportDeclaration(parent)) { | |
| this.word("declare"); | |
| this.space(); | |
| } | |
| this.OpaqueType(node); | |
| } | |
| function DeclareVariable(node, parent) { | |
| if (!t().isDeclareExportDeclaration(parent)) { | |
| this.word("declare"); | |
| this.space(); | |
| } | |
| this.word("var"); | |
| this.space(); | |
| this.print(node.id, node); | |
| this.print(node.id.typeAnnotation, node); | |
| this.semicolon(); | |
| } | |
| function DeclareExportDeclaration(node) { | |
| this.word("declare"); | |
| this.space(); | |
| this.word("export"); | |
| this.space(); | |
| if (node.default) { | |
| this.word("default"); | |
| this.space(); | |
| } | |
| FlowExportDeclaration.apply(this, arguments); | |
| } | |
| function DeclareExportAllDeclaration() { | |
| this.word("declare"); | |
| this.space(); | |
| _modules.ExportAllDeclaration.apply(this, arguments); | |
| } | |
| function FlowExportDeclaration(node) { | |
| if (node.declaration) { | |
| const declar = node.declaration; | |
| this.print(declar, node); | |
| if (!t().isStatement(declar)) this.semicolon(); | |
| } else { | |
| this.token("{"); | |
| if (node.specifiers.length) { | |
| this.space(); | |
| this.printList(node.specifiers, node); | |
| this.space(); | |
| } | |
| this.token("}"); | |
| if (node.source) { | |
| this.space(); | |
| this.word("from"); | |
| this.space(); | |
| this.print(node.source, node); | |
| } | |
| this.semicolon(); | |
| } | |
| } | |
| function ExistsTypeAnnotation() { | |
| this.token("*"); | |
| } | |
| function FunctionTypeAnnotation(node, parent) { | |
| this.print(node.typeParameters, node); | |
| this.token("("); | |
| this.printList(node.params, node); | |
| if (node.rest) { | |
| if (node.params.length) { | |
| this.token(","); | |
| this.space(); | |
| } | |
| this.token("..."); | |
| this.print(node.rest, node); | |
| } | |
| this.token(")"); | |
| if (parent.type === "ObjectTypeCallProperty" || parent.type === "DeclareFunction" || parent.type === "ObjectTypeProperty" && parent.method) { | |
| this.token(":"); | |
| } else { | |
| this.space(); | |
| this.token("=>"); | |
| } | |
| this.space(); | |
| this.print(node.returnType, node); | |
| } | |
| function FunctionTypeParam(node) { | |
| this.print(node.name, node); | |
| if (node.optional) this.token("?"); | |
| if (node.name) { | |
| this.token(":"); | |
| this.space(); | |
| } | |
| this.print(node.typeAnnotation, node); | |
| } | |
| function InterfaceExtends(node) { | |
| this.print(node.id, node); | |
| this.print(node.typeParameters, node); | |
| } | |
| function _interfaceish(node) { | |
| this.print(node.id, node); | |
| this.print(node.typeParameters, node); | |
| if (node.extends.length) { | |
| this.space(); | |
| this.word("extends"); | |
| this.space(); | |
| this.printList(node.extends, node); | |
| } | |
| if (node.mixins && node.mixins.length) { | |
| this.space(); | |
| this.word("mixins"); | |
| this.space(); | |
| this.printList(node.mixins, node); | |
| } | |
| if (node.implements && node.implements.length) { | |
| this.space(); | |
| this.word("implements"); | |
| this.space(); | |
| this.printList(node.implements, node); | |
| } | |
| this.space(); | |
| this.print(node.body, node); | |
| } | |
| function _variance(node) { | |
| if (node.variance) { | |
| if (node.variance.kind === "plus") { | |
| this.token("+"); | |
| } else if (node.variance.kind === "minus") { | |
| this.token("-"); | |
| } | |
| } | |
| } | |
| function InterfaceDeclaration(node) { | |
| this.word("interface"); | |
| this.space(); | |
| this._interfaceish(node); | |
| } | |
| function andSeparator() { | |
| this.space(); | |
| this.token("&"); | |
| this.space(); | |
| } | |
| function InterfaceTypeAnnotation(node) { | |
| this.word("interface"); | |
| if (node.extends && node.extends.length) { | |
| this.space(); | |
| this.word("extends"); | |
| this.space(); | |
| this.printList(node.extends, node); | |
| } | |
| this.space(); | |
| this.print(node.body, node); | |
| } | |
| function IntersectionTypeAnnotation(node) { | |
| this.printJoin(node.types, node, { | |
| separator: andSeparator | |
| }); | |
| } | |
| function MixedTypeAnnotation() { | |
| this.word("mixed"); | |
| } | |
| function EmptyTypeAnnotation() { | |
| this.word("empty"); | |
| } | |
| function NullableTypeAnnotation(node) { | |
| this.token("?"); | |
| this.print(node.typeAnnotation, node); | |
| } | |
| function NumberTypeAnnotation() { | |
| this.word("number"); | |
| } | |
| function StringTypeAnnotation() { | |
| this.word("string"); | |
| } | |
| function ThisTypeAnnotation() { | |
| this.word("this"); | |
| } | |
| function TupleTypeAnnotation(node) { | |
| this.token("["); | |
| this.printList(node.types, node); | |
| this.token("]"); | |
| } | |
| function TypeofTypeAnnotation(node) { | |
| this.word("typeof"); | |
| this.space(); | |
| this.print(node.argument, node); | |
| } | |
| function TypeAlias(node) { | |
| this.word("type"); | |
| this.space(); | |
| this.print(node.id, node); | |
| this.print(node.typeParameters, node); | |
| this.space(); | |
| this.token("="); | |
| this.space(); | |
| this.print(node.right, node); | |
| this.semicolon(); | |
| } | |
| function TypeAnnotation(node) { | |
| this.token(":"); | |
| this.space(); | |
| if (node.optional) this.token("?"); | |
| this.print(node.typeAnnotation, node); | |
| } | |
| function TypeParameterInstantiation(node) { | |
| this.token("<"); | |
| this.printList(node.params, node, {}); | |
| this.token(">"); | |
| } | |
| function TypeParameter(node) { | |
| this._variance(node); | |
| this.word(node.name); | |
| if (node.bound) { | |
| this.print(node.bound, node); | |
| } | |
| if (node.default) { | |
| this.space(); | |
| this.token("="); | |
| this.space(); | |
| this.print(node.default, node); | |
| } | |
| } | |
| function OpaqueType(node) { | |
| this.word("opaque"); | |
| this.space(); | |
| this.word("type"); | |
| this.space(); | |
| this.print(node.id, node); | |
| this.print(node.typeParameters, node); | |
| if (node.supertype) { | |
| this.token(":"); | |
| this.space(); | |
| this.print(node.supertype, node); | |
| } | |
| if (node.impltype) { | |
| this.space(); | |
| this.token("="); | |
| this.space(); | |
| this.print(node.impltype, node); | |
| } | |
| this.semicolon(); | |
| } | |
| function ObjectTypeAnnotation(node) { | |
| if (node.exact) { | |
| this.token("{|"); | |
| } else { | |
| this.token("{"); | |
| } | |
| const props = node.properties.concat(node.callProperties || [], node.indexers || [], node.internalSlots || []); | |
| if (props.length) { | |
| this.space(); | |
| this.printJoin(props, node, { | |
| addNewlines(leading) { | |
| if (leading && !props[0]) return 1; | |
| }, | |
| indent: true, | |
| statement: true, | |
| iterator: () => { | |
| if (props.length !== 1) { | |
| this.token(","); | |
| this.space(); | |
| } | |
| } | |
| }); | |
| this.space(); | |
| } | |
| if (node.exact) { | |
| this.token("|}"); | |
| } else { | |
| this.token("}"); | |
| } | |
| } | |
| function ObjectTypeInternalSlot(node) { | |
| if (node.static) { | |
| this.word("static"); | |
| this.space(); | |
| } | |
| this.token("["); | |
| this.token("["); | |
| this.print(node.id, node); | |
| this.token("]"); | |
| this.token("]"); | |
| if (node.optional) this.token("?"); | |
| if (!node.method) { | |
| this.token(":"); | |
| this.space(); | |
| } | |
| this.print(node.value, node); | |
| } | |
| function ObjectTypeCallProperty(node) { | |
| if (node.static) { | |
| this.word("static"); | |
| this.space(); | |
| } | |
| this.print(node.value, node); | |
| } | |
| function ObjectTypeIndexer(node) { | |
| if (node.static) { | |
| this.word("static"); | |
| this.space(); | |
| } | |
| this._variance(node); | |
| this.token("["); | |
| if (node.id) { | |
| this.print(node.id, node); | |
| this.token(":"); | |
| this.space(); | |
| } | |
| this.print(node.key, node); | |
| this.token("]"); | |
| this.token(":"); | |
| this.space(); | |
| this.print(node.value, node); | |
| } | |
| function ObjectTypeProperty(node) { | |
| if (node.proto) { | |
| this.word("proto"); | |
| this.space(); | |
| } | |
| if (node.static) { | |
| this.word("static"); | |
| this.space(); | |
| } | |
| this._variance(node); | |
| this.print(node.key, node); | |
| if (node.optional) this.token("?"); | |
| if (!node.method) { | |
| this.token(":"); | |
| this.space(); | |
| } | |
| this.print(node.value, node); | |
| } | |
| function ObjectTypeSpreadProperty(node) { | |
| this.token("..."); | |
| this.print(node.argument, node); | |
| } | |
| function QualifiedTypeIdentifier(node) { | |
| this.print(node.qualification, node); | |
| this.token("."); | |
| this.print(node.id, node); | |
| } | |
| function orSeparator() { | |
| this.space(); | |
| this.token("|"); | |
| this.space(); | |
| } | |
| function UnionTypeAnnotation(node) { | |
| this.printJoin(node.types, node, { | |
| separator: orSeparator | |
| }); | |
| } | |
| function TypeCastExpression(node) { | |
| this.token("("); | |
| this.print(node.expression, node); | |
| this.print(node.typeAnnotation, node); | |
| this.token(")"); | |
| } | |
| function Variance(node) { | |
| if (node.kind === "plus") { | |
| this.token("+"); | |
| } else { | |
| this.token("-"); | |
| } | |
| } | |
| function VoidTypeAnnotation() { | |
| this.word("void"); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/generators/index.js": | |
| /*!**************************************************!*\ | |
| !*** ../babel-generator/lib/generators/index.js ***! | |
| \**************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| var _templateLiterals = __webpack_require__(/*! ./template-literals */ "../babel-generator/lib/generators/template-literals.js"); | |
| Object.keys(_templateLiterals).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _templateLiterals[key]; | |
| } | |
| }); | |
| }); | |
| var _expressions = __webpack_require__(/*! ./expressions */ "../babel-generator/lib/generators/expressions.js"); | |
| Object.keys(_expressions).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _expressions[key]; | |
| } | |
| }); | |
| }); | |
| var _statements = __webpack_require__(/*! ./statements */ "../babel-generator/lib/generators/statements.js"); | |
| Object.keys(_statements).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _statements[key]; | |
| } | |
| }); | |
| }); | |
| var _classes = __webpack_require__(/*! ./classes */ "../babel-generator/lib/generators/classes.js"); | |
| Object.keys(_classes).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _classes[key]; | |
| } | |
| }); | |
| }); | |
| var _methods = __webpack_require__(/*! ./methods */ "../babel-generator/lib/generators/methods.js"); | |
| Object.keys(_methods).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _methods[key]; | |
| } | |
| }); | |
| }); | |
| var _modules = __webpack_require__(/*! ./modules */ "../babel-generator/lib/generators/modules.js"); | |
| Object.keys(_modules).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _modules[key]; | |
| } | |
| }); | |
| }); | |
| var _types = __webpack_require__(/*! ./types */ "../babel-generator/lib/generators/types.js"); | |
| Object.keys(_types).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _types[key]; | |
| } | |
| }); | |
| }); | |
| var _flow = __webpack_require__(/*! ./flow */ "../babel-generator/lib/generators/flow.js"); | |
| Object.keys(_flow).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _flow[key]; | |
| } | |
| }); | |
| }); | |
| var _base = __webpack_require__(/*! ./base */ "../babel-generator/lib/generators/base.js"); | |
| Object.keys(_base).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _base[key]; | |
| } | |
| }); | |
| }); | |
| var _jsx = __webpack_require__(/*! ./jsx */ "../babel-generator/lib/generators/jsx.js"); | |
| Object.keys(_jsx).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _jsx[key]; | |
| } | |
| }); | |
| }); | |
| var _typescript = __webpack_require__(/*! ./typescript */ "../babel-generator/lib/generators/typescript.js"); | |
| Object.keys(_typescript).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _typescript[key]; | |
| } | |
| }); | |
| }); | |
| /***/ }), | |
| /***/ "../babel-generator/lib/generators/jsx.js": | |
| /*!************************************************!*\ | |
| !*** ../babel-generator/lib/generators/jsx.js ***! | |
| \************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.JSXAttribute = JSXAttribute; | |
| exports.JSXIdentifier = JSXIdentifier; | |
| exports.JSXNamespacedName = JSXNamespacedName; | |
| exports.JSXMemberExpression = JSXMemberExpression; | |
| exports.JSXSpreadAttribute = JSXSpreadAttribute; | |
| exports.JSXExpressionContainer = JSXExpressionContainer; | |
| exports.JSXSpreadChild = JSXSpreadChild; | |
| exports.JSXText = JSXText; | |
| exports.JSXElement = JSXElement; | |
| exports.JSXOpeningElement = JSXOpeningElement; | |
| exports.JSXClosingElement = JSXClosingElement; | |
| exports.JSXEmptyExpression = JSXEmptyExpression; | |
| exports.JSXFragment = JSXFragment; | |
| exports.JSXOpeningFragment = JSXOpeningFragment; | |
| exports.JSXClosingFragment = JSXClosingFragment; | |
| function JSXAttribute(node) { | |
| this.print(node.name, node); | |
| if (node.value) { | |
| this.token("="); | |
| this.print(node.value, node); | |
| } | |
| } | |
| function JSXIdentifier(node) { | |
| this.word(node.name); | |
| } | |
| function JSXNamespacedName(node) { | |
| this.print(node.namespace, node); | |
| this.token(":"); | |
| this.print(node.name, node); | |
| } | |
| function JSXMemberExpression(node) { | |
| this.print(node.object, node); | |
| this.token("."); | |
| this.print(node.property, node); | |
| } | |
| function JSXSpreadAttribute(node) { | |
| this.token("{"); | |
| this.token("..."); | |
| this.print(node.argument, node); | |
| this.token("}"); | |
| } | |
| function JSXExpressionContainer(node) { | |
| this.token("{"); | |
| this.print(node.expression, node); | |
| this.token("}"); | |
| } | |
| function JSXSpreadChild(node) { | |
| this.token("{"); | |
| this.token("..."); | |
| this.print(node.expression, node); | |
| this.token("}"); | |
| } | |
| function JSXText(node) { | |
| const raw = this.getPossibleRaw(node); | |
| if (raw != null) { | |
| this.token(raw); | |
| } else { | |
| this.token(node.value); | |
| } | |
| } | |
| function JSXElement(node) { | |
| const open = node.openingElement; | |
| this.print(open, node); | |
| if (open.selfClosing) return; | |
| this.indent(); | |
| for (const child of node.children) { | |
| this.print(child, node); | |
| } | |
| this.dedent(); | |
| this.print(node.closingElement, node); | |
| } | |
| function spaceSeparator() { | |
| this.space(); | |
| } | |
| function JSXOpeningElement(node) { | |
| this.token("<"); | |
| this.print(node.name, node); | |
| this.print(node.typeParameters, node); | |
| if (node.attributes.length > 0) { | |
| this.space(); | |
| this.printJoin(node.attributes, node, { | |
| separator: spaceSeparator | |
| }); | |
| } | |
| if (node.selfClosing) { | |
| this.space(); | |
| this.token("/>"); | |
| } else { | |
| this.token(">"); | |
| } | |
| } | |
| function JSXClosingElement(node) { | |
| this.token("</"); | |
| this.print(node.name, node); | |
| this.token(">"); | |
| } | |
| function JSXEmptyExpression(node) { | |
| this.printInnerComments(node); | |
| } | |
| function JSXFragment(node) { | |
| this.print(node.openingFragment, node); | |
| this.indent(); | |
| for (const child of node.children) { | |
| this.print(child, node); | |
| } | |
| this.dedent(); | |
| this.print(node.closingFragment, node); | |
| } | |
| function JSXOpeningFragment() { | |
| this.token("<"); | |
| this.token(">"); | |
| } | |
| function JSXClosingFragment() { | |
| this.token("</"); | |
| this.token(">"); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/generators/methods.js": | |
| /*!****************************************************!*\ | |
| !*** ../babel-generator/lib/generators/methods.js ***! | |
| \****************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports._params = _params; | |
| exports._parameters = _parameters; | |
| exports._param = _param; | |
| exports._methodHead = _methodHead; | |
| exports._predicate = _predicate; | |
| exports._functionHead = _functionHead; | |
| exports.FunctionDeclaration = exports.FunctionExpression = FunctionExpression; | |
| exports.ArrowFunctionExpression = ArrowFunctionExpression; | |
| function t() { | |
| const data = _interopRequireWildcard(__webpack_require__(/*! @babel/types */ "../babel-generator/node_modules/@babel/types/lib/index.js")); | |
| t = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function _interopRequireWildcard(obj) { | |
| if (obj && obj.__esModule) { | |
| return obj; | |
| } else { | |
| var newObj = {}; | |
| if (obj != null) { | |
| for (var key in obj) { | |
| if (Object.prototype.hasOwnProperty.call(obj, key)) { | |
| var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; | |
| if (desc.get || desc.set) { | |
| Object.defineProperty(newObj, key, desc); | |
| } else { | |
| newObj[key] = obj[key]; | |
| } | |
| } | |
| } | |
| } | |
| newObj.default = obj; | |
| return newObj; | |
| } | |
| } | |
| function _params(node) { | |
| this.print(node.typeParameters, node); | |
| this.token("("); | |
| this._parameters(node.params, node); | |
| this.token(")"); | |
| this.print(node.returnType, node); | |
| } | |
| function _parameters(parameters, parent) { | |
| for (let i = 0; i < parameters.length; i++) { | |
| this._param(parameters[i], parent); | |
| if (i < parameters.length - 1) { | |
| this.token(","); | |
| this.space(); | |
| } | |
| } | |
| } | |
| function _param(parameter, parent) { | |
| this.printJoin(parameter.decorators, parameter); | |
| this.print(parameter, parent); | |
| if (parameter.optional) this.token("?"); | |
| this.print(parameter.typeAnnotation, parameter); | |
| } | |
| function _methodHead(node) { | |
| const kind = node.kind; | |
| const key = node.key; | |
| if (kind === "get" || kind === "set") { | |
| this.word(kind); | |
| this.space(); | |
| } | |
| if (node.async) { | |
| this.word("async"); | |
| this.space(); | |
| } | |
| if (kind === "method" || kind === "init") { | |
| if (node.generator) { | |
| this.token("*"); | |
| } | |
| } | |
| if (node.computed) { | |
| this.token("["); | |
| this.print(key, node); | |
| this.token("]"); | |
| } else { | |
| this.print(key, node); | |
| } | |
| if (node.optional) { | |
| this.token("?"); | |
| } | |
| this._params(node); | |
| } | |
| function _predicate(node) { | |
| if (node.predicate) { | |
| if (!node.returnType) { | |
| this.token(":"); | |
| } | |
| this.space(); | |
| this.print(node.predicate, node); | |
| } | |
| } | |
| function _functionHead(node) { | |
| if (node.async) { | |
| this.word("async"); | |
| this.space(); | |
| } | |
| this.word("function"); | |
| if (node.generator) this.token("*"); | |
| this.space(); | |
| if (node.id) { | |
| this.print(node.id, node); | |
| } | |
| this._params(node); | |
| this._predicate(node); | |
| } | |
| function FunctionExpression(node) { | |
| this._functionHead(node); | |
| this.space(); | |
| this.print(node.body, node); | |
| } | |
| function ArrowFunctionExpression(node) { | |
| if (node.async) { | |
| this.word("async"); | |
| this.space(); | |
| } | |
| const firstParam = node.params[0]; | |
| if (node.params.length === 1 && t().isIdentifier(firstParam) && !hasTypes(node, firstParam)) { | |
| if (this.format.retainLines && node.loc && node.body.loc && node.loc.start.line < node.body.loc.start.line) { | |
| this.token("("); | |
| if (firstParam.loc && firstParam.loc.start.line > node.loc.start.line) { | |
| this.indent(); | |
| this.print(firstParam, node); | |
| this.dedent(); | |
| this._catchUp("start", node.body.loc); | |
| } else { | |
| this.print(firstParam, node); | |
| } | |
| this.token(")"); | |
| } else { | |
| this.print(firstParam, node); | |
| } | |
| } else { | |
| this._params(node); | |
| } | |
| this._predicate(node); | |
| this.space(); | |
| this.token("=>"); | |
| this.space(); | |
| this.print(node.body, node); | |
| } | |
| function hasTypes(node, param) { | |
| return node.typeParameters || node.returnType || param.typeAnnotation || param.optional || param.trailingComments; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/generators/modules.js": | |
| /*!****************************************************!*\ | |
| !*** ../babel-generator/lib/generators/modules.js ***! | |
| \****************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.ImportSpecifier = ImportSpecifier; | |
| exports.ImportDefaultSpecifier = ImportDefaultSpecifier; | |
| exports.ExportDefaultSpecifier = ExportDefaultSpecifier; | |
| exports.ExportSpecifier = ExportSpecifier; | |
| exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier; | |
| exports.ExportAllDeclaration = ExportAllDeclaration; | |
| exports.ExportNamedDeclaration = ExportNamedDeclaration; | |
| exports.ExportDefaultDeclaration = ExportDefaultDeclaration; | |
| exports.ImportDeclaration = ImportDeclaration; | |
| exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier; | |
| function t() { | |
| const data = _interopRequireWildcard(__webpack_require__(/*! @babel/types */ "../babel-generator/node_modules/@babel/types/lib/index.js")); | |
| t = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function _interopRequireWildcard(obj) { | |
| if (obj && obj.__esModule) { | |
| return obj; | |
| } else { | |
| var newObj = {}; | |
| if (obj != null) { | |
| for (var key in obj) { | |
| if (Object.prototype.hasOwnProperty.call(obj, key)) { | |
| var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; | |
| if (desc.get || desc.set) { | |
| Object.defineProperty(newObj, key, desc); | |
| } else { | |
| newObj[key] = obj[key]; | |
| } | |
| } | |
| } | |
| } | |
| newObj.default = obj; | |
| return newObj; | |
| } | |
| } | |
| function ImportSpecifier(node) { | |
| if (node.importKind === "type" || node.importKind === "typeof") { | |
| this.word(node.importKind); | |
| this.space(); | |
| } | |
| this.print(node.imported, node); | |
| if (node.local && node.local.name !== node.imported.name) { | |
| this.space(); | |
| this.word("as"); | |
| this.space(); | |
| this.print(node.local, node); | |
| } | |
| } | |
| function ImportDefaultSpecifier(node) { | |
| this.print(node.local, node); | |
| } | |
| function ExportDefaultSpecifier(node) { | |
| this.print(node.exported, node); | |
| } | |
| function ExportSpecifier(node) { | |
| this.print(node.local, node); | |
| if (node.exported && node.local.name !== node.exported.name) { | |
| this.space(); | |
| this.word("as"); | |
| this.space(); | |
| this.print(node.exported, node); | |
| } | |
| } | |
| function ExportNamespaceSpecifier(node) { | |
| this.token("*"); | |
| this.space(); | |
| this.word("as"); | |
| this.space(); | |
| this.print(node.exported, node); | |
| } | |
| function ExportAllDeclaration(node) { | |
| this.word("export"); | |
| this.space(); | |
| if (node.exportKind === "type") { | |
| this.word("type"); | |
| this.space(); | |
| } | |
| this.token("*"); | |
| this.space(); | |
| this.word("from"); | |
| this.space(); | |
| this.print(node.source, node); | |
| this.semicolon(); | |
| } | |
| function ExportNamedDeclaration(node) { | |
| if (this.format.decoratorsBeforeExport && t().isClassDeclaration(node.declaration)) { | |
| this.printJoin(node.declaration.decorators, node); | |
| } | |
| this.word("export"); | |
| this.space(); | |
| ExportDeclaration.apply(this, arguments); | |
| } | |
| function ExportDefaultDeclaration(node) { | |
| if (this.format.decoratorsBeforeExport && t().isClassDeclaration(node.declaration)) { | |
| this.printJoin(node.declaration.decorators, node); | |
| } | |
| this.word("export"); | |
| this.space(); | |
| this.word("default"); | |
| this.space(); | |
| ExportDeclaration.apply(this, arguments); | |
| } | |
| function ExportDeclaration(node) { | |
| if (node.declaration) { | |
| const declar = node.declaration; | |
| this.print(declar, node); | |
| if (!t().isStatement(declar)) this.semicolon(); | |
| } else { | |
| if (node.exportKind === "type") { | |
| this.word("type"); | |
| this.space(); | |
| } | |
| const specifiers = node.specifiers.slice(0); | |
| let hasSpecial = false; | |
| while (true) { | |
| const first = specifiers[0]; | |
| if (t().isExportDefaultSpecifier(first) || t().isExportNamespaceSpecifier(first)) { | |
| hasSpecial = true; | |
| this.print(specifiers.shift(), node); | |
| if (specifiers.length) { | |
| this.token(","); | |
| this.space(); | |
| } | |
| } else { | |
| break; | |
| } | |
| } | |
| if (specifiers.length || !specifiers.length && !hasSpecial) { | |
| this.token("{"); | |
| if (specifiers.length) { | |
| this.space(); | |
| this.printList(specifiers, node); | |
| this.space(); | |
| } | |
| this.token("}"); | |
| } | |
| if (node.source) { | |
| this.space(); | |
| this.word("from"); | |
| this.space(); | |
| this.print(node.source, node); | |
| } | |
| this.semicolon(); | |
| } | |
| } | |
| function ImportDeclaration(node) { | |
| this.word("import"); | |
| this.space(); | |
| if (node.importKind === "type" || node.importKind === "typeof") { | |
| this.word(node.importKind); | |
| this.space(); | |
| } | |
| const specifiers = node.specifiers.slice(0); | |
| if (specifiers && specifiers.length) { | |
| while (true) { | |
| const first = specifiers[0]; | |
| if (t().isImportDefaultSpecifier(first) || t().isImportNamespaceSpecifier(first)) { | |
| this.print(specifiers.shift(), node); | |
| if (specifiers.length) { | |
| this.token(","); | |
| this.space(); | |
| } | |
| } else { | |
| break; | |
| } | |
| } | |
| if (specifiers.length) { | |
| this.token("{"); | |
| this.space(); | |
| this.printList(specifiers, node); | |
| this.space(); | |
| this.token("}"); | |
| } | |
| this.space(); | |
| this.word("from"); | |
| this.space(); | |
| } | |
| this.print(node.source, node); | |
| this.semicolon(); | |
| } | |
| function ImportNamespaceSpecifier(node) { | |
| this.token("*"); | |
| this.space(); | |
| this.word("as"); | |
| this.space(); | |
| this.print(node.local, node); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/generators/statements.js": | |
| /*!*******************************************************!*\ | |
| !*** ../babel-generator/lib/generators/statements.js ***! | |
| \*******************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.WithStatement = WithStatement; | |
| exports.IfStatement = IfStatement; | |
| exports.ForStatement = ForStatement; | |
| exports.WhileStatement = WhileStatement; | |
| exports.DoWhileStatement = DoWhileStatement; | |
| exports.LabeledStatement = LabeledStatement; | |
| exports.TryStatement = TryStatement; | |
| exports.CatchClause = CatchClause; | |
| exports.SwitchStatement = SwitchStatement; | |
| exports.SwitchCase = SwitchCase; | |
| exports.DebuggerStatement = DebuggerStatement; | |
| exports.VariableDeclaration = VariableDeclaration; | |
| exports.VariableDeclarator = VariableDeclarator; | |
| exports.ThrowStatement = exports.BreakStatement = exports.ReturnStatement = exports.ContinueStatement = exports.ForOfStatement = exports.ForInStatement = void 0; | |
| function t() { | |
| const data = _interopRequireWildcard(__webpack_require__(/*! @babel/types */ "../babel-generator/node_modules/@babel/types/lib/index.js")); | |
| t = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function _interopRequireWildcard(obj) { | |
| if (obj && obj.__esModule) { | |
| return obj; | |
| } else { | |
| var newObj = {}; | |
| if (obj != null) { | |
| for (var key in obj) { | |
| if (Object.prototype.hasOwnProperty.call(obj, key)) { | |
| var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; | |
| if (desc.get || desc.set) { | |
| Object.defineProperty(newObj, key, desc); | |
| } else { | |
| newObj[key] = obj[key]; | |
| } | |
| } | |
| } | |
| } | |
| newObj.default = obj; | |
| return newObj; | |
| } | |
| } | |
| function WithStatement(node) { | |
| this.word("with"); | |
| this.space(); | |
| this.token("("); | |
| this.print(node.object, node); | |
| this.token(")"); | |
| this.printBlock(node); | |
| } | |
| function IfStatement(node) { | |
| this.word("if"); | |
| this.space(); | |
| this.token("("); | |
| this.print(node.test, node); | |
| this.token(")"); | |
| this.space(); | |
| const needsBlock = node.alternate && t().isIfStatement(getLastStatement(node.consequent)); | |
| if (needsBlock) { | |
| this.token("{"); | |
| this.newline(); | |
| this.indent(); | |
| } | |
| this.printAndIndentOnComments(node.consequent, node); | |
| if (needsBlock) { | |
| this.dedent(); | |
| this.newline(); | |
| this.token("}"); | |
| } | |
| if (node.alternate) { | |
| if (this.endsWith("}")) this.space(); | |
| this.word("else"); | |
| this.space(); | |
| this.printAndIndentOnComments(node.alternate, node); | |
| } | |
| } | |
| function getLastStatement(statement) { | |
| if (!t().isStatement(statement.body)) return statement; | |
| return getLastStatement(statement.body); | |
| } | |
| function ForStatement(node) { | |
| this.word("for"); | |
| this.space(); | |
| this.token("("); | |
| this.inForStatementInitCounter++; | |
| this.print(node.init, node); | |
| this.inForStatementInitCounter--; | |
| this.token(";"); | |
| if (node.test) { | |
| this.space(); | |
| this.print(node.test, node); | |
| } | |
| this.token(";"); | |
| if (node.update) { | |
| this.space(); | |
| this.print(node.update, node); | |
| } | |
| this.token(")"); | |
| this.printBlock(node); | |
| } | |
| function WhileStatement(node) { | |
| this.word("while"); | |
| this.space(); | |
| this.token("("); | |
| this.print(node.test, node); | |
| this.token(")"); | |
| this.printBlock(node); | |
| } | |
| const buildForXStatement = function (op) { | |
| return function (node) { | |
| this.word("for"); | |
| this.space(); | |
| if (op === "of" && node.await) { | |
| this.word("await"); | |
| this.space(); | |
| } | |
| this.token("("); | |
| this.print(node.left, node); | |
| this.space(); | |
| this.word(op); | |
| this.space(); | |
| this.print(node.right, node); | |
| this.token(")"); | |
| this.printBlock(node); | |
| }; | |
| }; | |
| const ForInStatement = buildForXStatement("in"); | |
| exports.ForInStatement = ForInStatement; | |
| const ForOfStatement = buildForXStatement("of"); | |
| exports.ForOfStatement = ForOfStatement; | |
| function DoWhileStatement(node) { | |
| this.word("do"); | |
| this.space(); | |
| this.print(node.body, node); | |
| this.space(); | |
| this.word("while"); | |
| this.space(); | |
| this.token("("); | |
| this.print(node.test, node); | |
| this.token(")"); | |
| this.semicolon(); | |
| } | |
| function buildLabelStatement(prefix, key = "label") { | |
| return function (node) { | |
| this.word(prefix); | |
| const label = node[key]; | |
| if (label) { | |
| this.space(); | |
| const isLabel = key == "label"; | |
| const terminatorState = this.startTerminatorless(isLabel); | |
| this.print(label, node); | |
| this.endTerminatorless(terminatorState); | |
| } | |
| this.semicolon(); | |
| }; | |
| } | |
| const ContinueStatement = buildLabelStatement("continue"); | |
| exports.ContinueStatement = ContinueStatement; | |
| const ReturnStatement = buildLabelStatement("return", "argument"); | |
| exports.ReturnStatement = ReturnStatement; | |
| const BreakStatement = buildLabelStatement("break"); | |
| exports.BreakStatement = BreakStatement; | |
| const ThrowStatement = buildLabelStatement("throw", "argument"); | |
| exports.ThrowStatement = ThrowStatement; | |
| function LabeledStatement(node) { | |
| this.print(node.label, node); | |
| this.token(":"); | |
| this.space(); | |
| this.print(node.body, node); | |
| } | |
| function TryStatement(node) { | |
| this.word("try"); | |
| this.space(); | |
| this.print(node.block, node); | |
| this.space(); | |
| if (node.handlers) { | |
| this.print(node.handlers[0], node); | |
| } else { | |
| this.print(node.handler, node); | |
| } | |
| if (node.finalizer) { | |
| this.space(); | |
| this.word("finally"); | |
| this.space(); | |
| this.print(node.finalizer, node); | |
| } | |
| } | |
| function CatchClause(node) { | |
| this.word("catch"); | |
| this.space(); | |
| if (node.param) { | |
| this.token("("); | |
| this.print(node.param, node); | |
| this.token(")"); | |
| this.space(); | |
| } | |
| this.print(node.body, node); | |
| } | |
| function SwitchStatement(node) { | |
| this.word("switch"); | |
| this.space(); | |
| this.token("("); | |
| this.print(node.discriminant, node); | |
| this.token(")"); | |
| this.space(); | |
| this.token("{"); | |
| this.printSequence(node.cases, node, { | |
| indent: true, | |
| addNewlines(leading, cas) { | |
| if (!leading && node.cases[node.cases.length - 1] === cas) return -1; | |
| } | |
| }); | |
| this.token("}"); | |
| } | |
| function SwitchCase(node) { | |
| if (node.test) { | |
| this.word("case"); | |
| this.space(); | |
| this.print(node.test, node); | |
| this.token(":"); | |
| } else { | |
| this.word("default"); | |
| this.token(":"); | |
| } | |
| if (node.consequent.length) { | |
| this.newline(); | |
| this.printSequence(node.consequent, node, { | |
| indent: true | |
| }); | |
| } | |
| } | |
| function DebuggerStatement() { | |
| this.word("debugger"); | |
| this.semicolon(); | |
| } | |
| function variableDeclarationIndent() { | |
| this.token(","); | |
| this.newline(); | |
| if (this.endsWith("\n")) for (let i = 0; i < 4; i++) this.space(true); | |
| } | |
| function constDeclarationIndent() { | |
| this.token(","); | |
| this.newline(); | |
| if (this.endsWith("\n")) for (let i = 0; i < 6; i++) this.space(true); | |
| } | |
| function VariableDeclaration(node, parent) { | |
| if (node.declare) { | |
| this.word("declare"); | |
| this.space(); | |
| } | |
| this.word(node.kind); | |
| this.space(); | |
| let hasInits = false; | |
| if (!t().isFor(parent)) { | |
| for (const declar of node.declarations) { | |
| if (declar.init) { | |
| hasInits = true; | |
| } | |
| } | |
| } | |
| let separator; | |
| if (hasInits) { | |
| separator = node.kind === "const" ? constDeclarationIndent : variableDeclarationIndent; | |
| } | |
| this.printList(node.declarations, node, { | |
| separator | |
| }); | |
| if (t().isFor(parent)) { | |
| if (parent.left === node || parent.init === node) return; | |
| } | |
| this.semicolon(); | |
| } | |
| function VariableDeclarator(node) { | |
| this.print(node.id, node); | |
| if (node.definite) this.token("!"); | |
| this.print(node.id.typeAnnotation, node); | |
| if (node.init) { | |
| this.space(); | |
| this.token("="); | |
| this.space(); | |
| this.print(node.init, node); | |
| } | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/generators/template-literals.js": | |
| /*!**************************************************************!*\ | |
| !*** ../babel-generator/lib/generators/template-literals.js ***! | |
| \**************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.TaggedTemplateExpression = TaggedTemplateExpression; | |
| exports.TemplateElement = TemplateElement; | |
| exports.TemplateLiteral = TemplateLiteral; | |
| function TaggedTemplateExpression(node) { | |
| this.print(node.tag, node); | |
| this.print(node.typeParameters, node); | |
| this.print(node.quasi, node); | |
| } | |
| function TemplateElement(node, parent) { | |
| const isFirst = parent.quasis[0] === node; | |
| const isLast = parent.quasis[parent.quasis.length - 1] === node; | |
| const value = (isFirst ? "`" : "}") + node.value.raw + (isLast ? "`" : "${"); | |
| this.token(value); | |
| } | |
| function TemplateLiteral(node) { | |
| const quasis = node.quasis; | |
| for (let i = 0; i < quasis.length; i++) { | |
| this.print(quasis[i], node); | |
| if (i + 1 < quasis.length) { | |
| this.print(node.expressions[i], node); | |
| } | |
| } | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/generators/types.js": | |
| /*!**************************************************!*\ | |
| !*** ../babel-generator/lib/generators/types.js ***! | |
| \**************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.Identifier = Identifier; | |
| exports.ArgumentPlaceholder = ArgumentPlaceholder; | |
| exports.SpreadElement = exports.RestElement = RestElement; | |
| exports.ObjectPattern = exports.ObjectExpression = ObjectExpression; | |
| exports.ObjectMethod = ObjectMethod; | |
| exports.ObjectProperty = ObjectProperty; | |
| exports.ArrayPattern = exports.ArrayExpression = ArrayExpression; | |
| exports.RegExpLiteral = RegExpLiteral; | |
| exports.BooleanLiteral = BooleanLiteral; | |
| exports.NullLiteral = NullLiteral; | |
| exports.NumericLiteral = NumericLiteral; | |
| exports.StringLiteral = StringLiteral; | |
| exports.BigIntLiteral = BigIntLiteral; | |
| exports.PipelineTopicExpression = PipelineTopicExpression; | |
| exports.PipelineBareFunction = PipelineBareFunction; | |
| exports.PipelinePrimaryTopicReference = PipelinePrimaryTopicReference; | |
| function t() { | |
| const data = _interopRequireWildcard(__webpack_require__(/*! @babel/types */ "../babel-generator/node_modules/@babel/types/lib/index.js")); | |
| t = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function _jsesc() { | |
| const data = _interopRequireDefault(__webpack_require__(/*! jsesc */ "../babel-generator/node_modules/jsesc/jsesc.js")); | |
| _jsesc = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function _interopRequireDefault(obj) { | |
| return obj && obj.__esModule ? obj : { | |
| default: obj | |
| }; | |
| } | |
| function _interopRequireWildcard(obj) { | |
| if (obj && obj.__esModule) { | |
| return obj; | |
| } else { | |
| var newObj = {}; | |
| if (obj != null) { | |
| for (var key in obj) { | |
| if (Object.prototype.hasOwnProperty.call(obj, key)) { | |
| var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; | |
| if (desc.get || desc.set) { | |
| Object.defineProperty(newObj, key, desc); | |
| } else { | |
| newObj[key] = obj[key]; | |
| } | |
| } | |
| } | |
| } | |
| newObj.default = obj; | |
| return newObj; | |
| } | |
| } | |
| function Identifier(node) { | |
| this.exactSource(node.loc, () => { | |
| this.word(node.name); | |
| }); | |
| } | |
| function ArgumentPlaceholder() { | |
| this.token("?"); | |
| } | |
| function RestElement(node) { | |
| this.token("..."); | |
| this.print(node.argument, node); | |
| } | |
| function ObjectExpression(node) { | |
| const props = node.properties; | |
| this.token("{"); | |
| this.printInnerComments(node); | |
| if (props.length) { | |
| this.space(); | |
| this.printList(props, node, { | |
| indent: true, | |
| statement: true | |
| }); | |
| this.space(); | |
| } | |
| this.token("}"); | |
| } | |
| function ObjectMethod(node) { | |
| this.printJoin(node.decorators, node); | |
| this._methodHead(node); | |
| this.space(); | |
| this.print(node.body, node); | |
| } | |
| function ObjectProperty(node) { | |
| this.printJoin(node.decorators, node); | |
| if (node.computed) { | |
| this.token("["); | |
| this.print(node.key, node); | |
| this.token("]"); | |
| } else { | |
| if (t().isAssignmentPattern(node.value) && t().isIdentifier(node.key) && node.key.name === node.value.left.name) { | |
| this.print(node.value, node); | |
| return; | |
| } | |
| this.print(node.key, node); | |
| if (node.shorthand && t().isIdentifier(node.key) && t().isIdentifier(node.value) && node.key.name === node.value.name) { | |
| return; | |
| } | |
| } | |
| this.token(":"); | |
| this.space(); | |
| this.print(node.value, node); | |
| } | |
| function ArrayExpression(node) { | |
| const elems = node.elements; | |
| const len = elems.length; | |
| this.token("["); | |
| this.printInnerComments(node); | |
| for (let i = 0; i < elems.length; i++) { | |
| const elem = elems[i]; | |
| if (elem) { | |
| if (i > 0) this.space(); | |
| this.print(elem, node); | |
| if (i < len - 1) this.token(","); | |
| } else { | |
| this.token(","); | |
| } | |
| } | |
| this.token("]"); | |
| } | |
| function RegExpLiteral(node) { | |
| this.word(`/${node.pattern}/${node.flags}`); | |
| } | |
| function BooleanLiteral(node) { | |
| this.word(node.value ? "true" : "false"); | |
| } | |
| function NullLiteral() { | |
| this.word("null"); | |
| } | |
| function NumericLiteral(node) { | |
| const raw = this.getPossibleRaw(node); | |
| const value = node.value + ""; | |
| if (raw == null) { | |
| this.number(value); | |
| } else if (this.format.minified) { | |
| this.number(raw.length < value.length ? raw : value); | |
| } else { | |
| this.number(raw); | |
| } | |
| } | |
| function StringLiteral(node) { | |
| const raw = this.getPossibleRaw(node); | |
| if (!this.format.minified && raw != null) { | |
| this.token(raw); | |
| return; | |
| } | |
| const opts = this.format.jsescOption; | |
| if (this.format.jsonCompatibleStrings) { | |
| opts.json = true; | |
| } | |
| const val = (0, _jsesc().default)(node.value, opts); | |
| return this.token(val); | |
| } | |
| function BigIntLiteral(node) { | |
| const raw = this.getPossibleRaw(node); | |
| if (!this.format.minified && raw != null) { | |
| this.token(raw); | |
| return; | |
| } | |
| this.token(node.value); | |
| } | |
| function PipelineTopicExpression(node) { | |
| this.print(node.expression, node); | |
| } | |
| function PipelineBareFunction(node) { | |
| this.print(node.callee, node); | |
| } | |
| function PipelinePrimaryTopicReference() { | |
| this.token("#"); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/generators/typescript.js": | |
| /*!*******************************************************!*\ | |
| !*** ../babel-generator/lib/generators/typescript.js ***! | |
| \*******************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.TSTypeAnnotation = TSTypeAnnotation; | |
| exports.TSTypeParameterDeclaration = exports.TSTypeParameterInstantiation = TSTypeParameterInstantiation; | |
| exports.TSTypeParameter = TSTypeParameter; | |
| exports.TSParameterProperty = TSParameterProperty; | |
| exports.TSDeclareFunction = TSDeclareFunction; | |
| exports.TSDeclareMethod = TSDeclareMethod; | |
| exports.TSQualifiedName = TSQualifiedName; | |
| exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration; | |
| exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration; | |
| exports.TSPropertySignature = TSPropertySignature; | |
| exports.tsPrintPropertyOrMethodName = tsPrintPropertyOrMethodName; | |
| exports.TSMethodSignature = TSMethodSignature; | |
| exports.TSIndexSignature = TSIndexSignature; | |
| exports.TSAnyKeyword = TSAnyKeyword; | |
| exports.TSUnknownKeyword = TSUnknownKeyword; | |
| exports.TSNumberKeyword = TSNumberKeyword; | |
| exports.TSObjectKeyword = TSObjectKeyword; | |
| exports.TSBooleanKeyword = TSBooleanKeyword; | |
| exports.TSStringKeyword = TSStringKeyword; | |
| exports.TSSymbolKeyword = TSSymbolKeyword; | |
| exports.TSVoidKeyword = TSVoidKeyword; | |
| exports.TSUndefinedKeyword = TSUndefinedKeyword; | |
| exports.TSNullKeyword = TSNullKeyword; | |
| exports.TSNeverKeyword = TSNeverKeyword; | |
| exports.TSThisType = TSThisType; | |
| exports.TSFunctionType = TSFunctionType; | |
| exports.TSConstructorType = TSConstructorType; | |
| exports.tsPrintFunctionOrConstructorType = tsPrintFunctionOrConstructorType; | |
| exports.TSTypeReference = TSTypeReference; | |
| exports.TSTypePredicate = TSTypePredicate; | |
| exports.TSTypeQuery = TSTypeQuery; | |
| exports.TSTypeLiteral = TSTypeLiteral; | |
| exports.tsPrintTypeLiteralOrInterfaceBody = tsPrintTypeLiteralOrInterfaceBody; | |
| exports.tsPrintBraced = tsPrintBraced; | |
| exports.TSArrayType = TSArrayType; | |
| exports.TSTupleType = TSTupleType; | |
| exports.TSOptionalType = TSOptionalType; | |
| exports.TSRestType = TSRestType; | |
| exports.TSUnionType = TSUnionType; | |
| exports.TSIntersectionType = TSIntersectionType; | |
| exports.tsPrintUnionOrIntersectionType = tsPrintUnionOrIntersectionType; | |
| exports.TSConditionalType = TSConditionalType; | |
| exports.TSInferType = TSInferType; | |
| exports.TSParenthesizedType = TSParenthesizedType; | |
| exports.TSTypeCastExpression = TSTypeCastExpression; | |
| exports.TSTypeOperator = TSTypeOperator; | |
| exports.TSIndexedAccessType = TSIndexedAccessType; | |
| exports.TSMappedType = TSMappedType; | |
| exports.TSLiteralType = TSLiteralType; | |
| exports.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments; | |
| exports.TSInterfaceDeclaration = TSInterfaceDeclaration; | |
| exports.TSInterfaceBody = TSInterfaceBody; | |
| exports.TSTypeAliasDeclaration = TSTypeAliasDeclaration; | |
| exports.TSAsExpression = TSAsExpression; | |
| exports.TSTypeAssertion = TSTypeAssertion; | |
| exports.TSEnumDeclaration = TSEnumDeclaration; | |
| exports.TSEnumMember = TSEnumMember; | |
| exports.TSModuleDeclaration = TSModuleDeclaration; | |
| exports.TSModuleBlock = TSModuleBlock; | |
| exports.TSImportType = TSImportType; | |
| exports.TSImportEqualsDeclaration = TSImportEqualsDeclaration; | |
| exports.TSExternalModuleReference = TSExternalModuleReference; | |
| exports.TSNonNullExpression = TSNonNullExpression; | |
| exports.TSExportAssignment = TSExportAssignment; | |
| exports.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration; | |
| exports.tsPrintSignatureDeclarationBase = tsPrintSignatureDeclarationBase; | |
| function TSTypeAnnotation(node) { | |
| this.token(":"); | |
| this.space(); | |
| if (node.optional) this.token("?"); | |
| this.print(node.typeAnnotation, node); | |
| } | |
| function TSTypeParameterInstantiation(node) { | |
| this.token("<"); | |
| this.printList(node.params, node, {}); | |
| this.token(">"); | |
| } | |
| function TSTypeParameter(node) { | |
| this.word(node.name); | |
| if (node.constraint) { | |
| this.space(); | |
| this.word("extends"); | |
| this.space(); | |
| this.print(node.constraint, node); | |
| } | |
| if (node.default) { | |
| this.space(); | |
| this.token("="); | |
| this.space(); | |
| this.print(node.default, node); | |
| } | |
| } | |
| function TSParameterProperty(node) { | |
| if (node.accessibility) { | |
| this.word(node.accessibility); | |
| this.space(); | |
| } | |
| if (node.readonly) { | |
| this.word("readonly"); | |
| this.space(); | |
| } | |
| this._param(node.parameter); | |
| } | |
| function TSDeclareFunction(node) { | |
| if (node.declare) { | |
| this.word("declare"); | |
| this.space(); | |
| } | |
| this._functionHead(node); | |
| this.token(";"); | |
| } | |
| function TSDeclareMethod(node) { | |
| this._classMethodHead(node); | |
| this.token(";"); | |
| } | |
| function TSQualifiedName(node) { | |
| this.print(node.left, node); | |
| this.token("."); | |
| this.print(node.right, node); | |
| } | |
| function TSCallSignatureDeclaration(node) { | |
| this.tsPrintSignatureDeclarationBase(node); | |
| } | |
| function TSConstructSignatureDeclaration(node) { | |
| this.word("new"); | |
| this.space(); | |
| this.tsPrintSignatureDeclarationBase(node); | |
| } | |
| function TSPropertySignature(node) { | |
| const { | |
| readonly, | |
| initializer | |
| } = node; | |
| if (readonly) { | |
| this.word("readonly"); | |
| this.space(); | |
| } | |
| this.tsPrintPropertyOrMethodName(node); | |
| this.print(node.typeAnnotation, node); | |
| if (initializer) { | |
| this.space(); | |
| this.token("="); | |
| this.space(); | |
| this.print(initializer, node); | |
| } | |
| this.token(";"); | |
| } | |
| function tsPrintPropertyOrMethodName(node) { | |
| if (node.computed) { | |
| this.token("["); | |
| } | |
| this.print(node.key, node); | |
| if (node.computed) { | |
| this.token("]"); | |
| } | |
| if (node.optional) { | |
| this.token("?"); | |
| } | |
| } | |
| function TSMethodSignature(node) { | |
| this.tsPrintPropertyOrMethodName(node); | |
| this.tsPrintSignatureDeclarationBase(node); | |
| this.token(";"); | |
| } | |
| function TSIndexSignature(node) { | |
| const { | |
| readonly | |
| } = node; | |
| if (readonly) { | |
| this.word("readonly"); | |
| this.space(); | |
| } | |
| this.token("["); | |
| this._parameters(node.parameters, node); | |
| this.token("]"); | |
| this.print(node.typeAnnotation, node); | |
| this.token(";"); | |
| } | |
| function TSAnyKeyword() { | |
| this.word("any"); | |
| } | |
| function TSUnknownKeyword() { | |
| this.word("unknown"); | |
| } | |
| function TSNumberKeyword() { | |
| this.word("number"); | |
| } | |
| function TSObjectKeyword() { | |
| this.word("object"); | |
| } | |
| function TSBooleanKeyword() { | |
| this.word("boolean"); | |
| } | |
| function TSStringKeyword() { | |
| this.word("string"); | |
| } | |
| function TSSymbolKeyword() { | |
| this.word("symbol"); | |
| } | |
| function TSVoidKeyword() { | |
| this.word("void"); | |
| } | |
| function TSUndefinedKeyword() { | |
| this.word("undefined"); | |
| } | |
| function TSNullKeyword() { | |
| this.word("null"); | |
| } | |
| function TSNeverKeyword() { | |
| this.word("never"); | |
| } | |
| function TSThisType() { | |
| this.word("this"); | |
| } | |
| function TSFunctionType(node) { | |
| this.tsPrintFunctionOrConstructorType(node); | |
| } | |
| function TSConstructorType(node) { | |
| this.word("new"); | |
| this.space(); | |
| this.tsPrintFunctionOrConstructorType(node); | |
| } | |
| function tsPrintFunctionOrConstructorType(node) { | |
| const { | |
| typeParameters, | |
| parameters | |
| } = node; | |
| this.print(typeParameters, node); | |
| this.token("("); | |
| this._parameters(parameters, node); | |
| this.token(")"); | |
| this.space(); | |
| this.token("=>"); | |
| this.space(); | |
| this.print(node.typeAnnotation.typeAnnotation, node); | |
| } | |
| function TSTypeReference(node) { | |
| this.print(node.typeName, node); | |
| this.print(node.typeParameters, node); | |
| } | |
| function TSTypePredicate(node) { | |
| this.print(node.parameterName); | |
| this.space(); | |
| this.word("is"); | |
| this.space(); | |
| this.print(node.typeAnnotation.typeAnnotation); | |
| } | |
| function TSTypeQuery(node) { | |
| this.word("typeof"); | |
| this.space(); | |
| this.print(node.exprName); | |
| } | |
| function TSTypeLiteral(node) { | |
| this.tsPrintTypeLiteralOrInterfaceBody(node.members, node); | |
| } | |
| function tsPrintTypeLiteralOrInterfaceBody(members, node) { | |
| this.tsPrintBraced(members, node); | |
| } | |
| function tsPrintBraced(members, node) { | |
| this.token("{"); | |
| if (members.length) { | |
| this.indent(); | |
| if (!node.newlines) { | |
| this.newline(); | |
| } | |
| for (const member of members) { | |
| this.print(member, node); | |
| if (!node.newlines) { | |
| this.newline(); | |
| } | |
| } | |
| this.dedent(); | |
| this.rightBrace(); | |
| } else { | |
| this.token("}"); | |
| } | |
| } | |
| function TSArrayType(node) { | |
| this.print(node.elementType, node); | |
| this.token("[]"); | |
| } | |
| function TSTupleType(node) { | |
| this.token("["); | |
| this.printList(node.elementTypes, node); | |
| this.token("]"); | |
| } | |
| function TSOptionalType(node) { | |
| this.print(node.typeAnnotation, node); | |
| this.token("?"); | |
| } | |
| function TSRestType(node) { | |
| this.token("..."); | |
| this.print(node.typeAnnotation, node); | |
| } | |
| function TSUnionType(node) { | |
| this.tsPrintUnionOrIntersectionType(node, "|"); | |
| } | |
| function TSIntersectionType(node) { | |
| this.tsPrintUnionOrIntersectionType(node, "&"); | |
| } | |
| function tsPrintUnionOrIntersectionType(node, sep) { | |
| this.printJoin(node.types, node, { | |
| separator() { | |
| this.space(); | |
| this.token(sep); | |
| this.space(); | |
| } | |
| }); | |
| } | |
| function TSConditionalType(node) { | |
| this.print(node.checkType); | |
| this.space(); | |
| this.word("extends"); | |
| this.space(); | |
| this.print(node.extendsType); | |
| this.space(); | |
| this.token("?"); | |
| this.space(); | |
| this.print(node.trueType); | |
| this.space(); | |
| this.token(":"); | |
| this.space(); | |
| this.print(node.falseType); | |
| } | |
| function TSInferType(node) { | |
| this.token("infer"); | |
| this.space(); | |
| this.print(node.typeParameter); | |
| } | |
| function TSParenthesizedType(node) { | |
| this.token("("); | |
| this.print(node.typeAnnotation, node); | |
| this.token(")"); | |
| } | |
| function TSTypeCastExpression(node) { | |
| this.token("("); | |
| this.print(node.expression); | |
| this.print(node.typeAnnotation); | |
| this.token(")"); | |
| } | |
| function TSTypeOperator(node) { | |
| this.token(node.operator); | |
| this.space(); | |
| this.print(node.typeAnnotation, node); | |
| } | |
| function TSIndexedAccessType(node) { | |
| this.print(node.objectType, node); | |
| this.token("["); | |
| this.print(node.indexType, node); | |
| this.token("]"); | |
| } | |
| function TSMappedType(node) { | |
| const { | |
| readonly, | |
| typeParameter, | |
| optional | |
| } = node; | |
| this.token("{"); | |
| this.space(); | |
| if (readonly) { | |
| tokenIfPlusMinus(this, readonly); | |
| this.word("readonly"); | |
| this.space(); | |
| } | |
| this.token("["); | |
| this.word(typeParameter.name); | |
| this.space(); | |
| this.word("in"); | |
| this.space(); | |
| this.print(typeParameter.constraint, typeParameter); | |
| this.token("]"); | |
| if (optional) { | |
| tokenIfPlusMinus(this, optional); | |
| this.token("?"); | |
| } | |
| this.token(":"); | |
| this.space(); | |
| this.print(node.typeAnnotation, node); | |
| this.space(); | |
| this.token("}"); | |
| } | |
| function tokenIfPlusMinus(self, tok) { | |
| if (tok !== true) { | |
| self.token(tok); | |
| } | |
| } | |
| function TSLiteralType(node) { | |
| this.print(node.literal, node); | |
| } | |
| function TSExpressionWithTypeArguments(node) { | |
| this.print(node.expression, node); | |
| this.print(node.typeParameters, node); | |
| } | |
| function TSInterfaceDeclaration(node) { | |
| const { | |
| declare, | |
| id, | |
| typeParameters, | |
| extends: extendz, | |
| body | |
| } = node; | |
| if (declare) { | |
| this.word("declare"); | |
| this.space(); | |
| } | |
| this.word("interface"); | |
| this.space(); | |
| this.print(id, node); | |
| this.print(typeParameters, node); | |
| if (extendz) { | |
| this.space(); | |
| this.word("extends"); | |
| this.space(); | |
| this.printList(extendz, node); | |
| } | |
| this.space(); | |
| this.print(body, node); | |
| } | |
| function TSInterfaceBody(node) { | |
| this.tsPrintTypeLiteralOrInterfaceBody(node.body, node); | |
| } | |
| function TSTypeAliasDeclaration(node) { | |
| const { | |
| declare, | |
| id, | |
| typeParameters, | |
| typeAnnotation | |
| } = node; | |
| if (declare) { | |
| this.word("declare"); | |
| this.space(); | |
| } | |
| this.word("type"); | |
| this.space(); | |
| this.print(id, node); | |
| this.print(typeParameters, node); | |
| this.space(); | |
| this.token("="); | |
| this.space(); | |
| this.print(typeAnnotation, node); | |
| this.token(";"); | |
| } | |
| function TSAsExpression(node) { | |
| const { | |
| expression, | |
| typeAnnotation | |
| } = node; | |
| this.print(expression, node); | |
| this.space(); | |
| this.word("as"); | |
| this.space(); | |
| this.print(typeAnnotation, node); | |
| } | |
| function TSTypeAssertion(node) { | |
| const { | |
| typeAnnotation, | |
| expression | |
| } = node; | |
| this.token("<"); | |
| this.print(typeAnnotation, node); | |
| this.token(">"); | |
| this.space(); | |
| this.print(expression, node); | |
| } | |
| function TSEnumDeclaration(node) { | |
| const { | |
| declare, | |
| const: isConst, | |
| id, | |
| members | |
| } = node; | |
| if (declare) { | |
| this.word("declare"); | |
| this.space(); | |
| } | |
| if (isConst) { | |
| this.word("const"); | |
| this.space(); | |
| } | |
| this.word("enum"); | |
| this.space(); | |
| this.print(id, node); | |
| this.space(); | |
| this.tsPrintBraced(members, node); | |
| } | |
| function TSEnumMember(node) { | |
| const { | |
| id, | |
| initializer | |
| } = node; | |
| this.print(id, node); | |
| if (initializer) { | |
| this.space(); | |
| this.token("="); | |
| this.space(); | |
| this.print(initializer, node); | |
| } | |
| this.token(","); | |
| } | |
| function TSModuleDeclaration(node) { | |
| const { | |
| declare, | |
| id | |
| } = node; | |
| if (declare) { | |
| this.word("declare"); | |
| this.space(); | |
| } | |
| if (!node.global) { | |
| this.word(id.type === "Identifier" ? "namespace" : "module"); | |
| this.space(); | |
| } | |
| this.print(id, node); | |
| if (!node.body) { | |
| this.token(";"); | |
| return; | |
| } | |
| let body = node.body; | |
| while (body.type === "TSModuleDeclaration") { | |
| this.token("."); | |
| this.print(body.id, body); | |
| body = body.body; | |
| } | |
| this.space(); | |
| this.print(body, node); | |
| } | |
| function TSModuleBlock(node) { | |
| this.tsPrintBraced(node.body, node); | |
| } | |
| function TSImportType(node) { | |
| const { | |
| argument, | |
| qualifier, | |
| typeParameters | |
| } = node; | |
| this.word("import"); | |
| this.token("("); | |
| this.print(argument, node); | |
| this.token(")"); | |
| if (qualifier) { | |
| this.token("."); | |
| this.print(qualifier, node); | |
| } | |
| if (typeParameters) { | |
| this.print(typeParameters, node); | |
| } | |
| } | |
| function TSImportEqualsDeclaration(node) { | |
| const { | |
| isExport, | |
| id, | |
| moduleReference | |
| } = node; | |
| if (isExport) { | |
| this.word("export"); | |
| this.space(); | |
| } | |
| this.word("import"); | |
| this.space(); | |
| this.print(id, node); | |
| this.space(); | |
| this.token("="); | |
| this.space(); | |
| this.print(moduleReference, node); | |
| this.token(";"); | |
| } | |
| function TSExternalModuleReference(node) { | |
| this.token("require("); | |
| this.print(node.expression, node); | |
| this.token(")"); | |
| } | |
| function TSNonNullExpression(node) { | |
| this.print(node.expression, node); | |
| this.token("!"); | |
| } | |
| function TSExportAssignment(node) { | |
| this.word("export"); | |
| this.space(); | |
| this.token("="); | |
| this.space(); | |
| this.print(node.expression, node); | |
| this.token(";"); | |
| } | |
| function TSNamespaceExportDeclaration(node) { | |
| this.word("export"); | |
| this.space(); | |
| this.word("as"); | |
| this.space(); | |
| this.word("namespace"); | |
| this.space(); | |
| this.print(node.id, node); | |
| } | |
| function tsPrintSignatureDeclarationBase(node) { | |
| const { | |
| typeParameters, | |
| parameters | |
| } = node; | |
| this.print(typeParameters, node); | |
| this.token("("); | |
| this._parameters(parameters, node); | |
| this.token(")"); | |
| this.print(node.typeAnnotation, node); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/index.js": | |
| /*!***************************************!*\ | |
| !*** ../babel-generator/lib/index.js ***! | |
| \***************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = _default; | |
| exports.CodeGenerator = void 0; | |
| var _sourceMap = _interopRequireDefault(__webpack_require__(/*! ./source-map */ "../babel-generator/lib/source-map.js")); | |
| var _printer = _interopRequireDefault(__webpack_require__(/*! ./printer */ "../babel-generator/lib/printer.js")); | |
| function _interopRequireDefault(obj) { | |
| return obj && obj.__esModule ? obj : { | |
| default: obj | |
| }; | |
| } | |
| class Generator extends _printer.default { | |
| constructor(ast, opts = {}, code) { | |
| const format = normalizeOptions(code, opts); | |
| const map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null; | |
| super(format, map); | |
| this.ast = ast; | |
| } | |
| generate() { | |
| return super.generate(this.ast); | |
| } | |
| } | |
| function normalizeOptions(code, opts) { | |
| const format = { | |
| auxiliaryCommentBefore: opts.auxiliaryCommentBefore, | |
| auxiliaryCommentAfter: opts.auxiliaryCommentAfter, | |
| shouldPrintComment: opts.shouldPrintComment, | |
| retainLines: opts.retainLines, | |
| retainFunctionParens: opts.retainFunctionParens, | |
| comments: opts.comments == null || opts.comments, | |
| compact: opts.compact, | |
| minified: opts.minified, | |
| concise: opts.concise, | |
| jsonCompatibleStrings: opts.jsonCompatibleStrings, | |
| indent: { | |
| adjustMultilineComment: true, | |
| style: " ", | |
| base: 0 | |
| }, | |
| decoratorsBeforeExport: !!opts.decoratorsBeforeExport, | |
| jsescOption: Object.assign({ | |
| quotes: "double", | |
| wrap: true | |
| }, opts.jsescOption) | |
| }; | |
| if (format.minified) { | |
| format.compact = true; | |
| format.shouldPrintComment = format.shouldPrintComment || (() => format.comments); | |
| } else { | |
| format.shouldPrintComment = format.shouldPrintComment || (value => format.comments || value.indexOf("@license") >= 0 || value.indexOf("@preserve") >= 0); | |
| } | |
| if (format.compact === "auto") { | |
| format.compact = code.length > 500000; | |
| if (format.compact) { | |
| console.error("[BABEL] Note: The code generator has deoptimised the styling of " + `${opts.filename} as it exceeds the max of ${"500KB"}.`); | |
| } | |
| } | |
| if (format.compact) { | |
| format.indent.adjustMultilineComment = false; | |
| } | |
| return format; | |
| } | |
| class CodeGenerator { | |
| constructor(ast, opts, code) { | |
| this._generator = new Generator(ast, opts, code); | |
| } | |
| generate() { | |
| return this._generator.generate(); | |
| } | |
| } | |
| exports.CodeGenerator = CodeGenerator; | |
| function _default(ast, opts, code) { | |
| const gen = new Generator(ast, opts, code); | |
| return gen.generate(); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/node/index.js": | |
| /*!********************************************!*\ | |
| !*** ../babel-generator/lib/node/index.js ***! | |
| \********************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.needsWhitespace = needsWhitespace; | |
| exports.needsWhitespaceBefore = needsWhitespaceBefore; | |
| exports.needsWhitespaceAfter = needsWhitespaceAfter; | |
| exports.needsParens = needsParens; | |
| var whitespace = _interopRequireWildcard(__webpack_require__(/*! ./whitespace */ "../babel-generator/lib/node/whitespace.js")); | |
| var parens = _interopRequireWildcard(__webpack_require__(/*! ./parentheses */ "../babel-generator/lib/node/parentheses.js")); | |
| function t() { | |
| const data = _interopRequireWildcard(__webpack_require__(/*! @babel/types */ "../babel-generator/node_modules/@babel/types/lib/index.js")); | |
| t = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function _interopRequireWildcard(obj) { | |
| if (obj && obj.__esModule) { | |
| return obj; | |
| } else { | |
| var newObj = {}; | |
| if (obj != null) { | |
| for (var key in obj) { | |
| if (Object.prototype.hasOwnProperty.call(obj, key)) { | |
| var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; | |
| if (desc.get || desc.set) { | |
| Object.defineProperty(newObj, key, desc); | |
| } else { | |
| newObj[key] = obj[key]; | |
| } | |
| } | |
| } | |
| } | |
| newObj.default = obj; | |
| return newObj; | |
| } | |
| } | |
| function expandAliases(obj) { | |
| const newObj = {}; | |
| function add(type, func) { | |
| const fn = newObj[type]; | |
| newObj[type] = fn ? function (node, parent, stack) { | |
| const result = fn(node, parent, stack); | |
| return result == null ? func(node, parent, stack) : result; | |
| } : func; | |
| } | |
| for (const type of Object.keys(obj)) { | |
| const aliases = t().FLIPPED_ALIAS_KEYS[type]; | |
| if (aliases) { | |
| for (const alias of aliases) { | |
| add(alias, obj[type]); | |
| } | |
| } else { | |
| add(type, obj[type]); | |
| } | |
| } | |
| return newObj; | |
| } | |
| const expandedParens = expandAliases(parens); | |
| const expandedWhitespaceNodes = expandAliases(whitespace.nodes); | |
| const expandedWhitespaceList = expandAliases(whitespace.list); | |
| function find(obj, node, parent, printStack) { | |
| const fn = obj[node.type]; | |
| return fn ? fn(node, parent, printStack) : null; | |
| } | |
| function isOrHasCallExpression(node) { | |
| if (t().isCallExpression(node)) { | |
| return true; | |
| } | |
| if (t().isMemberExpression(node)) { | |
| return isOrHasCallExpression(node.object) || !node.computed && isOrHasCallExpression(node.property); | |
| } else { | |
| return false; | |
| } | |
| } | |
| function needsWhitespace(node, parent, type) { | |
| if (!node) return 0; | |
| if (t().isExpressionStatement(node)) { | |
| node = node.expression; | |
| } | |
| let linesInfo = find(expandedWhitespaceNodes, node, parent); | |
| if (!linesInfo) { | |
| const items = find(expandedWhitespaceList, node, parent); | |
| if (items) { | |
| for (let i = 0; i < items.length; i++) { | |
| linesInfo = needsWhitespace(items[i], node, type); | |
| if (linesInfo) break; | |
| } | |
| } | |
| } | |
| if (typeof linesInfo === "object" && linesInfo !== null) { | |
| return linesInfo[type] || 0; | |
| } | |
| return 0; | |
| } | |
| function needsWhitespaceBefore(node, parent) { | |
| return needsWhitespace(node, parent, "before"); | |
| } | |
| function needsWhitespaceAfter(node, parent) { | |
| return needsWhitespace(node, parent, "after"); | |
| } | |
| function needsParens(node, parent, printStack) { | |
| if (!parent) return false; | |
| if (t().isNewExpression(parent) && parent.callee === node) { | |
| if (isOrHasCallExpression(node)) return true; | |
| } | |
| return find(expandedParens, node, parent, printStack); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/node/parentheses.js": | |
| /*!**************************************************!*\ | |
| !*** ../babel-generator/lib/node/parentheses.js ***! | |
| \**************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.NullableTypeAnnotation = NullableTypeAnnotation; | |
| exports.FunctionTypeAnnotation = FunctionTypeAnnotation; | |
| exports.UpdateExpression = UpdateExpression; | |
| exports.ObjectExpression = ObjectExpression; | |
| exports.DoExpression = DoExpression; | |
| exports.Binary = Binary; | |
| exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation; | |
| exports.TSAsExpression = TSAsExpression; | |
| exports.TSTypeAssertion = TSTypeAssertion; | |
| exports.TSIntersectionType = exports.TSUnionType = TSUnionType; | |
| exports.BinaryExpression = BinaryExpression; | |
| exports.SequenceExpression = SequenceExpression; | |
| exports.AwaitExpression = exports.YieldExpression = YieldExpression; | |
| exports.ClassExpression = ClassExpression; | |
| exports.UnaryLike = UnaryLike; | |
| exports.FunctionExpression = FunctionExpression; | |
| exports.ArrowFunctionExpression = ArrowFunctionExpression; | |
| exports.ConditionalExpression = ConditionalExpression; | |
| exports.OptionalMemberExpression = OptionalMemberExpression; | |
| exports.AssignmentExpression = AssignmentExpression; | |
| exports.NewExpression = NewExpression; | |
| function t() { | |
| const data = _interopRequireWildcard(__webpack_require__(/*! @babel/types */ "../babel-generator/node_modules/@babel/types/lib/index.js")); | |
| t = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function _interopRequireWildcard(obj) { | |
| if (obj && obj.__esModule) { | |
| return obj; | |
| } else { | |
| var newObj = {}; | |
| if (obj != null) { | |
| for (var key in obj) { | |
| if (Object.prototype.hasOwnProperty.call(obj, key)) { | |
| var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; | |
| if (desc.get || desc.set) { | |
| Object.defineProperty(newObj, key, desc); | |
| } else { | |
| newObj[key] = obj[key]; | |
| } | |
| } | |
| } | |
| } | |
| newObj.default = obj; | |
| return newObj; | |
| } | |
| } | |
| const PRECEDENCE = { | |
| "||": 0, | |
| "&&": 1, | |
| "|": 2, | |
| "^": 3, | |
| "&": 4, | |
| "==": 5, | |
| "===": 5, | |
| "!=": 5, | |
| "!==": 5, | |
| "<": 6, | |
| ">": 6, | |
| "<=": 6, | |
| ">=": 6, | |
| in: 6, | |
| instanceof: 6, | |
| ">>": 7, | |
| "<<": 7, | |
| ">>>": 7, | |
| "+": 8, | |
| "-": 8, | |
| "*": 9, | |
| "/": 9, | |
| "%": 9, | |
| "**": 10 | |
| }; | |
| const isClassExtendsClause = (node, parent) => (t().isClassDeclaration(parent) || t().isClassExpression(parent)) && parent.superClass === node; | |
| function NullableTypeAnnotation(node, parent) { | |
| return t().isArrayTypeAnnotation(parent); | |
| } | |
| function FunctionTypeAnnotation(node, parent) { | |
| return t().isUnionTypeAnnotation(parent) || t().isIntersectionTypeAnnotation(parent) || t().isArrayTypeAnnotation(parent); | |
| } | |
| function UpdateExpression(node, parent) { | |
| return t().isMemberExpression(parent, { | |
| object: node | |
| }) || t().isCallExpression(parent, { | |
| callee: node | |
| }) || t().isNewExpression(parent, { | |
| callee: node | |
| }) || isClassExtendsClause(node, parent); | |
| } | |
| function ObjectExpression(node, parent, printStack) { | |
| return isFirstInStatement(printStack, { | |
| considerArrow: true | |
| }); | |
| } | |
| function DoExpression(node, parent, printStack) { | |
| return isFirstInStatement(printStack); | |
| } | |
| function Binary(node, parent) { | |
| if (node.operator === "**" && t().isBinaryExpression(parent, { | |
| operator: "**" | |
| })) { | |
| return parent.left === node; | |
| } | |
| if (isClassExtendsClause(node, parent)) { | |
| return true; | |
| } | |
| if ((t().isCallExpression(parent) || t().isNewExpression(parent)) && parent.callee === node || t().isUnaryLike(parent) || t().isMemberExpression(parent) && parent.object === node || t().isAwaitExpression(parent)) { | |
| return true; | |
| } | |
| if (t().isBinary(parent)) { | |
| const parentOp = parent.operator; | |
| const parentPos = PRECEDENCE[parentOp]; | |
| const nodeOp = node.operator; | |
| const nodePos = PRECEDENCE[nodeOp]; | |
| if (parentPos === nodePos && parent.right === node && !t().isLogicalExpression(parent) || parentPos > nodePos) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| function UnionTypeAnnotation(node, parent) { | |
| return t().isArrayTypeAnnotation(parent) || t().isNullableTypeAnnotation(parent) || t().isIntersectionTypeAnnotation(parent) || t().isUnionTypeAnnotation(parent); | |
| } | |
| function TSAsExpression() { | |
| return true; | |
| } | |
| function TSTypeAssertion() { | |
| return true; | |
| } | |
| function TSUnionType(node, parent) { | |
| return t().isTSArrayType(parent) || t().isTSOptionalType(parent) || t().isTSIntersectionType(parent) || t().isTSUnionType(parent) || t().isTSRestType(parent); | |
| } | |
| function BinaryExpression(node, parent) { | |
| return node.operator === "in" && (t().isVariableDeclarator(parent) || t().isFor(parent)); | |
| } | |
| function SequenceExpression(node, parent) { | |
| if (t().isForStatement(parent) || t().isThrowStatement(parent) || t().isReturnStatement(parent) || t().isIfStatement(parent) && parent.test === node || t().isWhileStatement(parent) && parent.test === node || t().isForInStatement(parent) && parent.right === node || t().isSwitchStatement(parent) && parent.discriminant === node || t().isExpressionStatement(parent) && parent.expression === node) { | |
| return false; | |
| } | |
| return true; | |
| } | |
| function YieldExpression(node, parent) { | |
| return t().isBinary(parent) || t().isUnaryLike(parent) || t().isCallExpression(parent) || t().isMemberExpression(parent) || t().isNewExpression(parent) || t().isAwaitExpression(parent) && t().isYieldExpression(node) || t().isConditionalExpression(parent) && node === parent.test || isClassExtendsClause(node, parent); | |
| } | |
| function ClassExpression(node, parent, printStack) { | |
| return isFirstInStatement(printStack, { | |
| considerDefaultExports: true | |
| }); | |
| } | |
| function UnaryLike(node, parent) { | |
| return t().isMemberExpression(parent, { | |
| object: node | |
| }) || t().isCallExpression(parent, { | |
| callee: node | |
| }) || t().isNewExpression(parent, { | |
| callee: node | |
| }) || t().isBinaryExpression(parent, { | |
| operator: "**", | |
| left: node | |
| }) || isClassExtendsClause(node, parent); | |
| } | |
| function FunctionExpression(node, parent, printStack) { | |
| return isFirstInStatement(printStack, { | |
| considerDefaultExports: true | |
| }); | |
| } | |
| function ArrowFunctionExpression(node, parent) { | |
| return t().isExportDeclaration(parent) || ConditionalExpression(node, parent); | |
| } | |
| function ConditionalExpression(node, parent) { | |
| if (t().isUnaryLike(parent) || t().isBinary(parent) || t().isConditionalExpression(parent, { | |
| test: node | |
| }) || t().isAwaitExpression(parent) || t().isOptionalMemberExpression(parent) || t().isTaggedTemplateExpression(parent) || t().isTSTypeAssertion(parent) || t().isTSAsExpression(parent)) { | |
| return true; | |
| } | |
| return UnaryLike(node, parent); | |
| } | |
| function OptionalMemberExpression(node, parent) { | |
| return t().isCallExpression(parent) || t().isMemberExpression(parent); | |
| } | |
| function AssignmentExpression(node) { | |
| if (t().isObjectPattern(node.left)) { | |
| return true; | |
| } else { | |
| return ConditionalExpression(...arguments); | |
| } | |
| } | |
| function NewExpression(node, parent) { | |
| return isClassExtendsClause(node, parent); | |
| } | |
| function isFirstInStatement(printStack, { | |
| considerArrow = false, | |
| considerDefaultExports = false | |
| } = {}) { | |
| let i = printStack.length - 1; | |
| let node = printStack[i]; | |
| i--; | |
| let parent = printStack[i]; | |
| while (i > 0) { | |
| if (t().isExpressionStatement(parent, { | |
| expression: node | |
| }) || t().isTaggedTemplateExpression(parent) || considerDefaultExports && t().isExportDefaultDeclaration(parent, { | |
| declaration: node | |
| }) || considerArrow && t().isArrowFunctionExpression(parent, { | |
| body: node | |
| })) { | |
| return true; | |
| } | |
| if (t().isCallExpression(parent, { | |
| callee: node | |
| }) || t().isSequenceExpression(parent) && parent.expressions[0] === node || t().isMemberExpression(parent, { | |
| object: node | |
| }) || t().isConditional(parent, { | |
| test: node | |
| }) || t().isBinary(parent, { | |
| left: node | |
| }) || t().isAssignmentExpression(parent, { | |
| left: node | |
| })) { | |
| node = parent; | |
| i--; | |
| parent = printStack[i]; | |
| } else { | |
| return false; | |
| } | |
| } | |
| return false; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/node/whitespace.js": | |
| /*!*************************************************!*\ | |
| !*** ../babel-generator/lib/node/whitespace.js ***! | |
| \*************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.list = exports.nodes = void 0; | |
| function t() { | |
| const data = _interopRequireWildcard(__webpack_require__(/*! @babel/types */ "../babel-generator/node_modules/@babel/types/lib/index.js")); | |
| t = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function _interopRequireWildcard(obj) { | |
| if (obj && obj.__esModule) { | |
| return obj; | |
| } else { | |
| var newObj = {}; | |
| if (obj != null) { | |
| for (var key in obj) { | |
| if (Object.prototype.hasOwnProperty.call(obj, key)) { | |
| var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; | |
| if (desc.get || desc.set) { | |
| Object.defineProperty(newObj, key, desc); | |
| } else { | |
| newObj[key] = obj[key]; | |
| } | |
| } | |
| } | |
| } | |
| newObj.default = obj; | |
| return newObj; | |
| } | |
| } | |
| function crawl(node, state = {}) { | |
| if (t().isMemberExpression(node)) { | |
| crawl(node.object, state); | |
| if (node.computed) crawl(node.property, state); | |
| } else if (t().isBinary(node) || t().isAssignmentExpression(node)) { | |
| crawl(node.left, state); | |
| crawl(node.right, state); | |
| } else if (t().isCallExpression(node)) { | |
| state.hasCall = true; | |
| crawl(node.callee, state); | |
| } else if (t().isFunction(node)) { | |
| state.hasFunction = true; | |
| } else if (t().isIdentifier(node)) { | |
| state.hasHelper = state.hasHelper || isHelper(node.callee); | |
| } | |
| return state; | |
| } | |
| function isHelper(node) { | |
| if (t().isMemberExpression(node)) { | |
| return isHelper(node.object) || isHelper(node.property); | |
| } else if (t().isIdentifier(node)) { | |
| return node.name === "require" || node.name[0] === "_"; | |
| } else if (t().isCallExpression(node)) { | |
| return isHelper(node.callee); | |
| } else if (t().isBinary(node) || t().isAssignmentExpression(node)) { | |
| return t().isIdentifier(node.left) && isHelper(node.left) || isHelper(node.right); | |
| } else { | |
| return false; | |
| } | |
| } | |
| function isType(node) { | |
| return t().isLiteral(node) || t().isObjectExpression(node) || t().isArrayExpression(node) || t().isIdentifier(node) || t().isMemberExpression(node); | |
| } | |
| const nodes = { | |
| AssignmentExpression(node) { | |
| const state = crawl(node.right); | |
| if (state.hasCall && state.hasHelper || state.hasFunction) { | |
| return { | |
| before: state.hasFunction, | |
| after: true | |
| }; | |
| } | |
| }, | |
| SwitchCase(node, parent) { | |
| return { | |
| before: node.consequent.length || parent.cases[0] === node, | |
| after: !node.consequent.length && parent.cases[parent.cases.length - 1] === node | |
| }; | |
| }, | |
| LogicalExpression(node) { | |
| if (t().isFunction(node.left) || t().isFunction(node.right)) { | |
| return { | |
| after: true | |
| }; | |
| } | |
| }, | |
| Literal(node) { | |
| if (node.value === "use strict") { | |
| return { | |
| after: true | |
| }; | |
| } | |
| }, | |
| CallExpression(node) { | |
| if (t().isFunction(node.callee) || isHelper(node)) { | |
| return { | |
| before: true, | |
| after: true | |
| }; | |
| } | |
| }, | |
| VariableDeclaration(node) { | |
| for (let i = 0; i < node.declarations.length; i++) { | |
| const declar = node.declarations[i]; | |
| let enabled = isHelper(declar.id) && !isType(declar.init); | |
| if (!enabled) { | |
| const state = crawl(declar.init); | |
| enabled = isHelper(declar.init) && state.hasCall || state.hasFunction; | |
| } | |
| if (enabled) { | |
| return { | |
| before: true, | |
| after: true | |
| }; | |
| } | |
| } | |
| }, | |
| IfStatement(node) { | |
| if (t().isBlockStatement(node.consequent)) { | |
| return { | |
| before: true, | |
| after: true | |
| }; | |
| } | |
| } | |
| }; | |
| exports.nodes = nodes; | |
| nodes.ObjectProperty = nodes.ObjectTypeProperty = nodes.ObjectMethod = function (node, parent) { | |
| if (parent.properties[0] === node) { | |
| return { | |
| before: true | |
| }; | |
| } | |
| }; | |
| nodes.ObjectTypeCallProperty = function (node, parent) { | |
| if (parent.callProperties[0] === node && (!parent.properties || !parent.properties.length)) { | |
| return { | |
| before: true | |
| }; | |
| } | |
| }; | |
| nodes.ObjectTypeIndexer = function (node, parent) { | |
| if (parent.indexers[0] === node && (!parent.properties || !parent.properties.length) && (!parent.callProperties || !parent.callProperties.length)) { | |
| return { | |
| before: true | |
| }; | |
| } | |
| }; | |
| nodes.ObjectTypeInternalSlot = function (node, parent) { | |
| if (parent.internalSlots[0] === node && (!parent.properties || !parent.properties.length) && (!parent.callProperties || !parent.callProperties.length) && (!parent.indexers || !parent.indexers.length)) { | |
| return { | |
| before: true | |
| }; | |
| } | |
| }; | |
| const list = { | |
| VariableDeclaration(node) { | |
| return node.declarations.map(decl => decl.init); | |
| }, | |
| ArrayExpression(node) { | |
| return node.elements; | |
| }, | |
| ObjectExpression(node) { | |
| return node.properties; | |
| } | |
| }; | |
| exports.list = list; | |
| [["Function", true], ["Class", true], ["Loop", true], ["LabeledStatement", true], ["SwitchStatement", true], ["TryStatement", true]].forEach(function ([type, amounts]) { | |
| if (typeof amounts === "boolean") { | |
| amounts = { | |
| after: amounts, | |
| before: amounts | |
| }; | |
| } | |
| [type].concat(t().FLIPPED_ALIAS_KEYS[type] || []).forEach(function (type) { | |
| nodes[type] = function () { | |
| return amounts; | |
| }; | |
| }); | |
| }); | |
| /***/ }), | |
| /***/ "../babel-generator/lib/printer.js": | |
| /*!*****************************************!*\ | |
| !*** ../babel-generator/lib/printer.js ***! | |
| \*****************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = void 0; | |
| function _isInteger() { | |
| const data = _interopRequireDefault(__webpack_require__(/*! lodash/isInteger */ "../babel-generator/node_modules/lodash/isInteger.js")); | |
| _isInteger = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function _repeat() { | |
| const data = _interopRequireDefault(__webpack_require__(/*! lodash/repeat */ "../babel-generator/node_modules/lodash/repeat.js")); | |
| _repeat = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| var _buffer = _interopRequireDefault(__webpack_require__(/*! ./buffer */ "../babel-generator/lib/buffer.js")); | |
| var n = _interopRequireWildcard(__webpack_require__(/*! ./node */ "../babel-generator/lib/node/index.js")); | |
| function t() { | |
| const data = _interopRequireWildcard(__webpack_require__(/*! @babel/types */ "../babel-generator/node_modules/@babel/types/lib/index.js")); | |
| t = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function getChildren(node) { | |
| switch (node.type) { | |
| case "Program": | |
| case "BlockStatement": | |
| case "ClassBody": | |
| return node.body; | |
| case "ObjectExpression": | |
| return node.properties; | |
| case "TSTypeLiteral": | |
| return node.members; | |
| case "SwitchStatement": | |
| return node.cases; | |
| default: | |
| throw new Error(`cannot computed newlines on ${node.type} node`); | |
| } | |
| } | |
| var generatorFunctions = _interopRequireWildcard(__webpack_require__(/*! ./generators */ "../babel-generator/lib/generators/index.js")); | |
| function _interopRequireWildcard(obj) { | |
| if (obj && obj.__esModule) { | |
| return obj; | |
| } else { | |
| var newObj = {}; | |
| if (obj != null) { | |
| for (var key in obj) { | |
| if (Object.prototype.hasOwnProperty.call(obj, key)) { | |
| var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; | |
| if (desc.get || desc.set) { | |
| Object.defineProperty(newObj, key, desc); | |
| } else { | |
| newObj[key] = obj[key]; | |
| } | |
| } | |
| } | |
| } | |
| newObj.default = obj; | |
| return newObj; | |
| } | |
| } | |
| function _interopRequireDefault(obj) { | |
| return obj && obj.__esModule ? obj : { | |
| default: obj | |
| }; | |
| } | |
| const SCIENTIFIC_NOTATION = /e/i; | |
| const ZERO_DECIMAL_INTEGER = /\.0+$/; | |
| const NON_DECIMAL_LITERAL = /^0[box]/; | |
| class Printer { | |
| constructor(format, map) { | |
| this.inForStatementInitCounter = 0; | |
| this._printStack = []; | |
| this._indent = 0; | |
| this._insideAux = false; | |
| this._printedCommentStarts = {}; | |
| this._parenPushNewlineState = null; | |
| this._noLineTerminator = false; | |
| this._printAuxAfterOnNextUserNode = false; | |
| this._printedComments = new WeakSet(); | |
| this._endsWithInteger = false; | |
| this._endsWithWord = false; | |
| this.format = format || {}; | |
| this._buf = new _buffer.default(map); | |
| } | |
| generate(ast) { | |
| this.print(ast); | |
| this._maybeAddAuxComment(); | |
| return this._buf.get(); | |
| } | |
| indent() { | |
| if (this.format.compact || this.format.concise) return; | |
| this._indent++; | |
| } | |
| dedent() { | |
| if (this.format.compact || this.format.concise) return; | |
| this._indent--; | |
| } | |
| semicolon(force = false) { | |
| this._maybeAddAuxComment(); | |
| this._append(";", !force); | |
| } | |
| rightBrace() { | |
| if (this.format.minified) { | |
| this._buf.removeLastSemicolon(); | |
| } | |
| this.token("}"); | |
| } | |
| space(force = false) { | |
| if (this.format.compact) return; | |
| if (this._buf.hasContent() && !this.endsWith(" ") && !this.endsWith("\n") || force) { | |
| this._space(); | |
| } | |
| } | |
| word(str) { | |
| if (this._endsWithWord || this.endsWith("/") && str.indexOf("/") === 0) { | |
| this._space(); | |
| } | |
| this._maybeAddAuxComment(); | |
| this._append(str); | |
| this._endsWithWord = true; | |
| } | |
| number(str) { | |
| this.word(str); | |
| this._endsWithInteger = (0, _isInteger().default)(+str) && !NON_DECIMAL_LITERAL.test(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str[str.length - 1] !== "."; | |
| } | |
| token(str) { | |
| if (str === "--" && this.endsWith("!") || str[0] === "+" && this.endsWith("+") || str[0] === "-" && this.endsWith("-") || str[0] === "." && this._endsWithInteger) { | |
| this._space(); | |
| } | |
| this._maybeAddAuxComment(); | |
| this._append(str); | |
| } | |
| newline(i) { | |
| if (this.format.retainLines || this.format.compact) return; | |
| if (this.format.concise) { | |
| this.space(); | |
| return; | |
| } | |
| if (this.endsWith("\n\n")) return; | |
| if (typeof i !== "number") i = 1; | |
| i = Math.min(2, i); | |
| if (this.endsWith("{\n") || this.endsWith(":\n")) i--; | |
| if (i <= 0) return; | |
| for (let j = 0; j < i; j++) { | |
| this._newline(); | |
| } | |
| } | |
| endsWith(str) { | |
| return this._buf.endsWith(str); | |
| } | |
| removeTrailingNewline() { | |
| this._buf.removeTrailingNewline(); | |
| } | |
| exactSource(loc, cb) { | |
| this._catchUp("start", loc); | |
| this._buf.exactSource(loc, cb); | |
| } | |
| source(prop, loc) { | |
| this._catchUp(prop, loc); | |
| this._buf.source(prop, loc); | |
| } | |
| withSource(prop, loc, cb) { | |
| this._catchUp(prop, loc); | |
| this._buf.withSource(prop, loc, cb); | |
| } | |
| _space() { | |
| this._append(" ", true); | |
| } | |
| _newline() { | |
| this._append("\n", true); | |
| } | |
| _printNewlines(newlines) { | |
| for (const line of newlines) { | |
| if (line) { | |
| this._printComment(line); | |
| } else { | |
| this._newline(); | |
| } | |
| } | |
| } | |
| _append(str, queue = false) { | |
| this._maybeAddParen(str); | |
| this._maybeIndent(str); | |
| if (queue) this._buf.queue(str);else this._buf.append(str); | |
| this._endsWithWord = false; | |
| this._endsWithInteger = false; | |
| } | |
| _maybeIndent(str) { | |
| if (this._indent && this.endsWith("\n") && str[0] !== "\n") { | |
| this._buf.queue(this._getIndent()); | |
| } | |
| } | |
| _maybeAddParen(str) { | |
| const parenPushNewlineState = this._parenPushNewlineState; | |
| if (!parenPushNewlineState) return; | |
| this._parenPushNewlineState = null; | |
| let i; | |
| for (i = 0; i < str.length && str[i] === " "; i++) continue; | |
| if (i === str.length) return; | |
| const cha = str[i]; | |
| if (cha !== "\n") { | |
| if (cha !== "/") return; | |
| if (i + 1 === str.length) return; | |
| const chaPost = str[i + 1]; | |
| if (chaPost !== "/" && chaPost !== "*") return; | |
| } | |
| this.token("("); | |
| this.indent(); | |
| parenPushNewlineState.printed = true; | |
| } | |
| _catchUp(prop, loc) { | |
| if (!this.format.retainLines) return; | |
| const pos = loc ? loc[prop] : null; | |
| if (pos && pos.line !== null) { | |
| const count = pos.line - this._buf.getCurrentLine(); | |
| for (let i = 0; i < count; i++) { | |
| this._newline(); | |
| } | |
| } | |
| } | |
| _getIndent() { | |
| return (0, _repeat().default)(this.format.indent.style, this._indent); | |
| } | |
| startTerminatorless(isLabel = false) { | |
| if (isLabel) { | |
| this._noLineTerminator = true; | |
| return null; | |
| } else { | |
| return this._parenPushNewlineState = { | |
| printed: false | |
| }; | |
| } | |
| } | |
| endTerminatorless(state) { | |
| this._noLineTerminator = false; | |
| if (state && state.printed) { | |
| this.dedent(); | |
| this.newline(); | |
| this.token(")"); | |
| } | |
| } | |
| print(node, parent) { | |
| if (!node) return; | |
| const oldConcise = this.format.concise; | |
| if (node._compact) { | |
| this.format.concise = true; | |
| } | |
| const printMethod = this[node.type]; | |
| if (!printMethod) { | |
| throw new ReferenceError(`unknown node of type ${JSON.stringify(node.type)} with constructor ${JSON.stringify(node && node.constructor.name)}`); | |
| } | |
| this._printStack.push(node); | |
| const oldInAux = this._insideAux; | |
| this._insideAux = !node.loc; | |
| this._maybeAddAuxComment(this._insideAux && !oldInAux); | |
| let needsParens = n.needsParens(node, parent, this._printStack); | |
| if (this.format.retainFunctionParens && node.type === "FunctionExpression" && node.extra && node.extra.parenthesized) { | |
| needsParens = true; | |
| } | |
| if (needsParens) this.token("("); | |
| if (parent && parent.newlines) { | |
| const children = getChildren(parent); | |
| const index = children.indexOf(node); | |
| const newlines = parent.newlines[index]; | |
| if (newlines) this._printNewlines(newlines); | |
| } else { | |
| this._printLeadingComments(node); | |
| } | |
| const loc = t().isProgram(node) || t().isFile(node) ? null : node.loc; | |
| this.withSource("start", loc, () => { | |
| printMethod.call(this, node, parent); | |
| }); | |
| if (parent && parent.newlines) { | |
| const children = getChildren(parent); // All newlines move trailing comments to be part of the previous | |
| // statement's newlines. The final statement's trailing comments | |
| // are stored in an extra array of newlines which are printed here. | |
| if (children.indexOf(node) === children.length - 1) { | |
| const newlines = parent.newlines[children.length]; | |
| if (newlines) this._printNewlines(newlines); | |
| } | |
| } else { | |
| this._printTrailingComments(node); | |
| } | |
| if (needsParens) this.token(")"); | |
| this._printStack.pop(); | |
| this.format.concise = oldConcise; | |
| this._insideAux = oldInAux; | |
| } | |
| _maybeAddAuxComment(enteredPositionlessNode) { | |
| if (enteredPositionlessNode) this._printAuxBeforeComment(); | |
| if (!this._insideAux) this._printAuxAfterComment(); | |
| } | |
| _printAuxBeforeComment() { | |
| if (this._printAuxAfterOnNextUserNode) return; | |
| this._printAuxAfterOnNextUserNode = true; | |
| const comment = this.format.auxiliaryCommentBefore; | |
| if (comment) { | |
| this._printComment({ | |
| type: "CommentBlock", | |
| value: comment | |
| }); | |
| } | |
| } | |
| _printAuxAfterComment() { | |
| if (!this._printAuxAfterOnNextUserNode) return; | |
| this._printAuxAfterOnNextUserNode = false; | |
| const comment = this.format.auxiliaryCommentAfter; | |
| if (comment) { | |
| this._printComment({ | |
| type: "CommentBlock", | |
| value: comment | |
| }); | |
| } | |
| } | |
| getPossibleRaw(node) { | |
| const extra = node.extra; | |
| if (extra && extra.raw != null && extra.rawValue != null && node.value === extra.rawValue) { | |
| return extra.raw; | |
| } | |
| } | |
| printJoin(nodes, parent, opts = {}) { | |
| if (!nodes || !nodes.length) return; | |
| if (opts.indent) this.indent(); | |
| const newlineOpts = { | |
| addNewlines: opts.addNewlines | |
| }; | |
| for (let i = 0; i < nodes.length; i++) { | |
| const node = nodes[i]; | |
| if (!node) continue; | |
| if (opts.statement) { | |
| const hasNewlines = parent.newlines && parent.newlines[i]; | |
| if (!hasNewlines) { | |
| this._printNewline(true, node, parent, newlineOpts); | |
| } | |
| } | |
| this.print(node, parent); | |
| if (opts.iterator) { | |
| opts.iterator(node, i); | |
| } | |
| if (opts.separator && i < nodes.length - 1) { | |
| opts.separator.call(this); | |
| } | |
| if (opts.statement) { | |
| const hasNewlines = parent.newlines && parent.newlines[i + 1]; | |
| if (!hasNewlines) { | |
| this._printNewline(false, node, parent, newlineOpts); | |
| } | |
| } | |
| } | |
| if (opts.indent) this.dedent(); | |
| } | |
| printAndIndentOnComments(node, parent) { | |
| const indent = node.leadingComments && node.leadingComments.length > 0; | |
| if (indent) this.indent(); | |
| this.print(node, parent); | |
| if (indent) this.dedent(); | |
| } | |
| printBlock(parent) { | |
| const node = parent.body; | |
| if (!t().isEmptyStatement(node)) { | |
| this.space(); | |
| } | |
| this.print(node, parent); | |
| } | |
| _printTrailingComments(node) { | |
| this._printComments(this._getComments(false, node)); | |
| } | |
| _printLeadingComments(node) { | |
| this._printComments(this._getComments(true, node)); | |
| } | |
| printInnerComments(node, indent = true) { | |
| if (!node.innerComments || !node.innerComments.length) return; | |
| if (indent) this.indent(); | |
| this._printComments(node.innerComments); | |
| if (indent) this.dedent(); | |
| } | |
| printSequence(nodes, parent, opts = {}) { | |
| opts.statement = true; | |
| return this.printJoin(nodes, parent, opts); | |
| } | |
| printList(items, parent, opts = {}) { | |
| if (opts.separator == null) { | |
| opts.separator = commaSeparator; | |
| } | |
| return this.printJoin(items, parent, opts); | |
| } | |
| _printNewline(leading, node, parent, opts) { | |
| if (this.format.retainLines || this.format.compact) return; | |
| if (this.format.concise) { | |
| this.space(); | |
| return; | |
| } | |
| let lines = 0; | |
| if (this._buf.hasContent()) { | |
| if (!leading) lines++; | |
| if (opts.addNewlines) lines += opts.addNewlines(leading, node) || 0; | |
| const needs = leading ? n.needsWhitespaceBefore : n.needsWhitespaceAfter; | |
| if (needs(node, parent)) lines++; | |
| } | |
| this.newline(lines); | |
| } | |
| _getComments(leading, node) { | |
| return node && (leading ? node.leadingComments : node.trailingComments) || []; | |
| } | |
| _printComment(comment) { | |
| if (!this.format.shouldPrintComment(comment.value)) return; | |
| if (comment.ignore) return; | |
| if (this._printedComments.has(comment)) return; | |
| this._printedComments.add(comment); | |
| if (comment.start != null) { | |
| if (this._printedCommentStarts[comment.start]) return; | |
| this._printedCommentStarts[comment.start] = true; | |
| } | |
| const isBlockComment = comment.type === "CommentBlock"; | |
| this.newline(this._buf.hasContent() && !this._noLineTerminator && isBlockComment ? 1 : 0); | |
| if (!this.endsWith("[") && !this.endsWith("{")) this.space(); | |
| let val = !isBlockComment && !this._noLineTerminator ? `//${comment.value}\n` : `/*${comment.value}*/`; | |
| if (isBlockComment && this.format.indent.adjustMultilineComment) { | |
| const offset = comment.loc && comment.loc.start.column; | |
| if (offset) { | |
| const newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g"); | |
| val = val.replace(newlineRegex, "\n"); | |
| } | |
| const indentSize = Math.max(this._getIndent().length, this._buf.getCurrentColumn()); | |
| val = val.replace(/\n(?!$)/g, `\n${(0, _repeat().default)(" ", indentSize)}`); | |
| } | |
| if (this.endsWith("/")) this._space(); | |
| this.withSource("start", comment.loc, () => { | |
| this._append(val); | |
| }); | |
| this.newline(isBlockComment && !this._noLineTerminator ? 1 : 0); | |
| } | |
| _printComments(comments) { | |
| if (!comments || !comments.length) return; | |
| for (const comment of comments) { | |
| this._printComment(comment); | |
| } | |
| } | |
| } | |
| exports.default = Printer; | |
| Object.assign(Printer.prototype, generatorFunctions); | |
| function commaSeparator() { | |
| this.token(","); | |
| this.space(); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/lib/source-map.js": | |
| /*!********************************************!*\ | |
| !*** ../babel-generator/lib/source-map.js ***! | |
| \********************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = void 0; | |
| function _sourceMap() { | |
| const data = _interopRequireDefault(__webpack_require__(/*! source-map */ "../babel-generator/node_modules/source-map/source-map.js")); | |
| _sourceMap = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function _interopRequireDefault(obj) { | |
| return obj && obj.__esModule ? obj : { | |
| default: obj | |
| }; | |
| } | |
| class SourceMap { | |
| constructor(opts, code) { | |
| this._cachedMap = null; | |
| this._code = code; | |
| this._opts = opts; | |
| this._rawMappings = []; | |
| } | |
| get() { | |
| if (!this._cachedMap) { | |
| const map = this._cachedMap = new (_sourceMap().default.SourceMapGenerator)({ | |
| sourceRoot: this._opts.sourceRoot | |
| }); | |
| const code = this._code; | |
| if (typeof code === "string") { | |
| map.setSourceContent(this._opts.sourceFileName, code); | |
| } else if (typeof code === "object") { | |
| Object.keys(code).forEach(sourceFileName => { | |
| map.setSourceContent(sourceFileName, code[sourceFileName]); | |
| }); | |
| } | |
| this._rawMappings.forEach(map.addMapping, map); | |
| } | |
| return this._cachedMap.toJSON(); | |
| } | |
| getRawMappings() { | |
| return this._rawMappings.slice(); | |
| } | |
| mark(generatedLine, generatedColumn, line, column, identifierName, filename, force) { | |
| if (this._lastGenLine !== generatedLine && line === null) return; | |
| if (!force && this._lastGenLine === generatedLine && this._lastSourceLine === line && this._lastSourceColumn === column) { | |
| return; | |
| } | |
| this._cachedMap = null; | |
| this._lastGenLine = generatedLine; | |
| this._lastSourceLine = line; | |
| this._lastSourceColumn = column; | |
| this._rawMappings.push({ | |
| name: identifierName || undefined, | |
| generated: { | |
| line: generatedLine, | |
| column: generatedColumn | |
| }, | |
| source: line == null ? undefined : filename || this._opts.sourceFileName, | |
| original: line == null ? undefined : { | |
| line: line, | |
| column: column | |
| } | |
| }); | |
| } | |
| } | |
| exports.default = SourceMap; | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/asserts/assertNode.js": | |
| /*!******************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/asserts/assertNode.js ***! | |
| \******************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = assertNode; | |
| var _isNode = _interopRequireDefault(__webpack_require__(/*! ../validators/isNode */ "../babel-generator/node_modules/@babel/types/lib/validators/isNode.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function assertNode(node) { | |
| if (!(0, _isNode.default)(node)) { | |
| const type = node && node.type || JSON.stringify(node); | |
| throw new TypeError(`Not a valid node of type "${type}"`); | |
| } | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/asserts/generated/index.js": | |
| /*!***********************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/asserts/generated/index.js ***! | |
| \***********************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.assertArrayExpression = assertArrayExpression; | |
| exports.assertAssignmentExpression = assertAssignmentExpression; | |
| exports.assertBinaryExpression = assertBinaryExpression; | |
| exports.assertInterpreterDirective = assertInterpreterDirective; | |
| exports.assertDirective = assertDirective; | |
| exports.assertDirectiveLiteral = assertDirectiveLiteral; | |
| exports.assertBlockStatement = assertBlockStatement; | |
| exports.assertBreakStatement = assertBreakStatement; | |
| exports.assertCallExpression = assertCallExpression; | |
| exports.assertCatchClause = assertCatchClause; | |
| exports.assertConditionalExpression = assertConditionalExpression; | |
| exports.assertContinueStatement = assertContinueStatement; | |
| exports.assertDebuggerStatement = assertDebuggerStatement; | |
| exports.assertDoWhileStatement = assertDoWhileStatement; | |
| exports.assertEmptyStatement = assertEmptyStatement; | |
| exports.assertExpressionStatement = assertExpressionStatement; | |
| exports.assertFile = assertFile; | |
| exports.assertForInStatement = assertForInStatement; | |
| exports.assertForStatement = assertForStatement; | |
| exports.assertFunctionDeclaration = assertFunctionDeclaration; | |
| exports.assertFunctionExpression = assertFunctionExpression; | |
| exports.assertIdentifier = assertIdentifier; | |
| exports.assertIfStatement = assertIfStatement; | |
| exports.assertLabeledStatement = assertLabeledStatement; | |
| exports.assertStringLiteral = assertStringLiteral; | |
| exports.assertNumericLiteral = assertNumericLiteral; | |
| exports.assertNullLiteral = assertNullLiteral; | |
| exports.assertBooleanLiteral = assertBooleanLiteral; | |
| exports.assertRegExpLiteral = assertRegExpLiteral; | |
| exports.assertLogicalExpression = assertLogicalExpression; | |
| exports.assertMemberExpression = assertMemberExpression; | |
| exports.assertNewExpression = assertNewExpression; | |
| exports.assertProgram = assertProgram; | |
| exports.assertObjectExpression = assertObjectExpression; | |
| exports.assertObjectMethod = assertObjectMethod; | |
| exports.assertObjectProperty = assertObjectProperty; | |
| exports.assertRestElement = assertRestElement; | |
| exports.assertReturnStatement = assertReturnStatement; | |
| exports.assertSequenceExpression = assertSequenceExpression; | |
| exports.assertParenthesizedExpression = assertParenthesizedExpression; | |
| exports.assertSwitchCase = assertSwitchCase; | |
| exports.assertSwitchStatement = assertSwitchStatement; | |
| exports.assertThisExpression = assertThisExpression; | |
| exports.assertThrowStatement = assertThrowStatement; | |
| exports.assertTryStatement = assertTryStatement; | |
| exports.assertUnaryExpression = assertUnaryExpression; | |
| exports.assertUpdateExpression = assertUpdateExpression; | |
| exports.assertVariableDeclaration = assertVariableDeclaration; | |
| exports.assertVariableDeclarator = assertVariableDeclarator; | |
| exports.assertWhileStatement = assertWhileStatement; | |
| exports.assertWithStatement = assertWithStatement; | |
| exports.assertAssignmentPattern = assertAssignmentPattern; | |
| exports.assertArrayPattern = assertArrayPattern; | |
| exports.assertArrowFunctionExpression = assertArrowFunctionExpression; | |
| exports.assertClassBody = assertClassBody; | |
| exports.assertClassDeclaration = assertClassDeclaration; | |
| exports.assertClassExpression = assertClassExpression; | |
| exports.assertExportAllDeclaration = assertExportAllDeclaration; | |
| exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration; | |
| exports.assertExportNamedDeclaration = assertExportNamedDeclaration; | |
| exports.assertExportSpecifier = assertExportSpecifier; | |
| exports.assertForOfStatement = assertForOfStatement; | |
| exports.assertImportDeclaration = assertImportDeclaration; | |
| exports.assertImportDefaultSpecifier = assertImportDefaultSpecifier; | |
| exports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier; | |
| exports.assertImportSpecifier = assertImportSpecifier; | |
| exports.assertMetaProperty = assertMetaProperty; | |
| exports.assertClassMethod = assertClassMethod; | |
| exports.assertObjectPattern = assertObjectPattern; | |
| exports.assertSpreadElement = assertSpreadElement; | |
| exports.assertSuper = assertSuper; | |
| exports.assertTaggedTemplateExpression = assertTaggedTemplateExpression; | |
| exports.assertTemplateElement = assertTemplateElement; | |
| exports.assertTemplateLiteral = assertTemplateLiteral; | |
| exports.assertYieldExpression = assertYieldExpression; | |
| exports.assertAnyTypeAnnotation = assertAnyTypeAnnotation; | |
| exports.assertArrayTypeAnnotation = assertArrayTypeAnnotation; | |
| exports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation; | |
| exports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation; | |
| exports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation; | |
| exports.assertClassImplements = assertClassImplements; | |
| exports.assertDeclareClass = assertDeclareClass; | |
| exports.assertDeclareFunction = assertDeclareFunction; | |
| exports.assertDeclareInterface = assertDeclareInterface; | |
| exports.assertDeclareModule = assertDeclareModule; | |
| exports.assertDeclareModuleExports = assertDeclareModuleExports; | |
| exports.assertDeclareTypeAlias = assertDeclareTypeAlias; | |
| exports.assertDeclareOpaqueType = assertDeclareOpaqueType; | |
| exports.assertDeclareVariable = assertDeclareVariable; | |
| exports.assertDeclareExportDeclaration = assertDeclareExportDeclaration; | |
| exports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration; | |
| exports.assertDeclaredPredicate = assertDeclaredPredicate; | |
| exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation; | |
| exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation; | |
| exports.assertFunctionTypeParam = assertFunctionTypeParam; | |
| exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation; | |
| exports.assertInferredPredicate = assertInferredPredicate; | |
| exports.assertInterfaceExtends = assertInterfaceExtends; | |
| exports.assertInterfaceDeclaration = assertInterfaceDeclaration; | |
| exports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation; | |
| exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation; | |
| exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation; | |
| exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation; | |
| exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation; | |
| exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation; | |
| exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation; | |
| exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation; | |
| exports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot; | |
| exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty; | |
| exports.assertObjectTypeIndexer = assertObjectTypeIndexer; | |
| exports.assertObjectTypeProperty = assertObjectTypeProperty; | |
| exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty; | |
| exports.assertOpaqueType = assertOpaqueType; | |
| exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier; | |
| exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation; | |
| exports.assertStringTypeAnnotation = assertStringTypeAnnotation; | |
| exports.assertThisTypeAnnotation = assertThisTypeAnnotation; | |
| exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation; | |
| exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation; | |
| exports.assertTypeAlias = assertTypeAlias; | |
| exports.assertTypeAnnotation = assertTypeAnnotation; | |
| exports.assertTypeCastExpression = assertTypeCastExpression; | |
| exports.assertTypeParameter = assertTypeParameter; | |
| exports.assertTypeParameterDeclaration = assertTypeParameterDeclaration; | |
| exports.assertTypeParameterInstantiation = assertTypeParameterInstantiation; | |
| exports.assertUnionTypeAnnotation = assertUnionTypeAnnotation; | |
| exports.assertVariance = assertVariance; | |
| exports.assertVoidTypeAnnotation = assertVoidTypeAnnotation; | |
| exports.assertJSXAttribute = assertJSXAttribute; | |
| exports.assertJSXClosingElement = assertJSXClosingElement; | |
| exports.assertJSXElement = assertJSXElement; | |
| exports.assertJSXEmptyExpression = assertJSXEmptyExpression; | |
| exports.assertJSXExpressionContainer = assertJSXExpressionContainer; | |
| exports.assertJSXSpreadChild = assertJSXSpreadChild; | |
| exports.assertJSXIdentifier = assertJSXIdentifier; | |
| exports.assertJSXMemberExpression = assertJSXMemberExpression; | |
| exports.assertJSXNamespacedName = assertJSXNamespacedName; | |
| exports.assertJSXOpeningElement = assertJSXOpeningElement; | |
| exports.assertJSXSpreadAttribute = assertJSXSpreadAttribute; | |
| exports.assertJSXText = assertJSXText; | |
| exports.assertJSXFragment = assertJSXFragment; | |
| exports.assertJSXOpeningFragment = assertJSXOpeningFragment; | |
| exports.assertJSXClosingFragment = assertJSXClosingFragment; | |
| exports.assertNoop = assertNoop; | |
| exports.assertPlaceholder = assertPlaceholder; | |
| exports.assertArgumentPlaceholder = assertArgumentPlaceholder; | |
| exports.assertAwaitExpression = assertAwaitExpression; | |
| exports.assertBindExpression = assertBindExpression; | |
| exports.assertClassProperty = assertClassProperty; | |
| exports.assertOptionalMemberExpression = assertOptionalMemberExpression; | |
| exports.assertPipelineTopicExpression = assertPipelineTopicExpression; | |
| exports.assertPipelineBareFunction = assertPipelineBareFunction; | |
| exports.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference; | |
| exports.assertOptionalCallExpression = assertOptionalCallExpression; | |
| exports.assertClassPrivateProperty = assertClassPrivateProperty; | |
| exports.assertClassPrivateMethod = assertClassPrivateMethod; | |
| exports.assertImport = assertImport; | |
| exports.assertDecorator = assertDecorator; | |
| exports.assertDoExpression = assertDoExpression; | |
| exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier; | |
| exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier; | |
| exports.assertPrivateName = assertPrivateName; | |
| exports.assertBigIntLiteral = assertBigIntLiteral; | |
| exports.assertTSParameterProperty = assertTSParameterProperty; | |
| exports.assertTSDeclareFunction = assertTSDeclareFunction; | |
| exports.assertTSDeclareMethod = assertTSDeclareMethod; | |
| exports.assertTSQualifiedName = assertTSQualifiedName; | |
| exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration; | |
| exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration; | |
| exports.assertTSPropertySignature = assertTSPropertySignature; | |
| exports.assertTSMethodSignature = assertTSMethodSignature; | |
| exports.assertTSIndexSignature = assertTSIndexSignature; | |
| exports.assertTSAnyKeyword = assertTSAnyKeyword; | |
| exports.assertTSUnknownKeyword = assertTSUnknownKeyword; | |
| exports.assertTSNumberKeyword = assertTSNumberKeyword; | |
| exports.assertTSObjectKeyword = assertTSObjectKeyword; | |
| exports.assertTSBooleanKeyword = assertTSBooleanKeyword; | |
| exports.assertTSStringKeyword = assertTSStringKeyword; | |
| exports.assertTSSymbolKeyword = assertTSSymbolKeyword; | |
| exports.assertTSVoidKeyword = assertTSVoidKeyword; | |
| exports.assertTSUndefinedKeyword = assertTSUndefinedKeyword; | |
| exports.assertTSNullKeyword = assertTSNullKeyword; | |
| exports.assertTSNeverKeyword = assertTSNeverKeyword; | |
| exports.assertTSThisType = assertTSThisType; | |
| exports.assertTSFunctionType = assertTSFunctionType; | |
| exports.assertTSConstructorType = assertTSConstructorType; | |
| exports.assertTSTypeReference = assertTSTypeReference; | |
| exports.assertTSTypePredicate = assertTSTypePredicate; | |
| exports.assertTSTypeQuery = assertTSTypeQuery; | |
| exports.assertTSTypeLiteral = assertTSTypeLiteral; | |
| exports.assertTSArrayType = assertTSArrayType; | |
| exports.assertTSTupleType = assertTSTupleType; | |
| exports.assertTSOptionalType = assertTSOptionalType; | |
| exports.assertTSRestType = assertTSRestType; | |
| exports.assertTSUnionType = assertTSUnionType; | |
| exports.assertTSIntersectionType = assertTSIntersectionType; | |
| exports.assertTSConditionalType = assertTSConditionalType; | |
| exports.assertTSInferType = assertTSInferType; | |
| exports.assertTSParenthesizedType = assertTSParenthesizedType; | |
| exports.assertTSTypeOperator = assertTSTypeOperator; | |
| exports.assertTSIndexedAccessType = assertTSIndexedAccessType; | |
| exports.assertTSMappedType = assertTSMappedType; | |
| exports.assertTSLiteralType = assertTSLiteralType; | |
| exports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments; | |
| exports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration; | |
| exports.assertTSInterfaceBody = assertTSInterfaceBody; | |
| exports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration; | |
| exports.assertTSAsExpression = assertTSAsExpression; | |
| exports.assertTSTypeAssertion = assertTSTypeAssertion; | |
| exports.assertTSEnumDeclaration = assertTSEnumDeclaration; | |
| exports.assertTSEnumMember = assertTSEnumMember; | |
| exports.assertTSModuleDeclaration = assertTSModuleDeclaration; | |
| exports.assertTSModuleBlock = assertTSModuleBlock; | |
| exports.assertTSImportType = assertTSImportType; | |
| exports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration; | |
| exports.assertTSExternalModuleReference = assertTSExternalModuleReference; | |
| exports.assertTSNonNullExpression = assertTSNonNullExpression; | |
| exports.assertTSExportAssignment = assertTSExportAssignment; | |
| exports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration; | |
| exports.assertTSTypeAnnotation = assertTSTypeAnnotation; | |
| exports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation; | |
| exports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration; | |
| exports.assertTSTypeParameter = assertTSTypeParameter; | |
| exports.assertExpression = assertExpression; | |
| exports.assertBinary = assertBinary; | |
| exports.assertScopable = assertScopable; | |
| exports.assertBlockParent = assertBlockParent; | |
| exports.assertBlock = assertBlock; | |
| exports.assertStatement = assertStatement; | |
| exports.assertTerminatorless = assertTerminatorless; | |
| exports.assertCompletionStatement = assertCompletionStatement; | |
| exports.assertConditional = assertConditional; | |
| exports.assertLoop = assertLoop; | |
| exports.assertWhile = assertWhile; | |
| exports.assertExpressionWrapper = assertExpressionWrapper; | |
| exports.assertFor = assertFor; | |
| exports.assertForXStatement = assertForXStatement; | |
| exports.assertFunction = assertFunction; | |
| exports.assertFunctionParent = assertFunctionParent; | |
| exports.assertPureish = assertPureish; | |
| exports.assertDeclaration = assertDeclaration; | |
| exports.assertPatternLike = assertPatternLike; | |
| exports.assertLVal = assertLVal; | |
| exports.assertTSEntityName = assertTSEntityName; | |
| exports.assertLiteral = assertLiteral; | |
| exports.assertImmutable = assertImmutable; | |
| exports.assertUserWhitespacable = assertUserWhitespacable; | |
| exports.assertMethod = assertMethod; | |
| exports.assertObjectMember = assertObjectMember; | |
| exports.assertProperty = assertProperty; | |
| exports.assertUnaryLike = assertUnaryLike; | |
| exports.assertPattern = assertPattern; | |
| exports.assertClass = assertClass; | |
| exports.assertModuleDeclaration = assertModuleDeclaration; | |
| exports.assertExportDeclaration = assertExportDeclaration; | |
| exports.assertModuleSpecifier = assertModuleSpecifier; | |
| exports.assertFlow = assertFlow; | |
| exports.assertFlowType = assertFlowType; | |
| exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation; | |
| exports.assertFlowDeclaration = assertFlowDeclaration; | |
| exports.assertFlowPredicate = assertFlowPredicate; | |
| exports.assertJSX = assertJSX; | |
| exports.assertPrivate = assertPrivate; | |
| exports.assertTSTypeElement = assertTSTypeElement; | |
| exports.assertTSType = assertTSType; | |
| exports.assertNumberLiteral = assertNumberLiteral; | |
| exports.assertRegexLiteral = assertRegexLiteral; | |
| exports.assertRestProperty = assertRestProperty; | |
| exports.assertSpreadProperty = assertSpreadProperty; | |
| var _is = _interopRequireDefault(__webpack_require__(/*! ../../validators/is */ "../babel-generator/node_modules/@babel/types/lib/validators/is.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function assert(type, node, opts) { | |
| if (!(0, _is.default)(type, node, opts)) { | |
| throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, but instead got "${node.type}".`); | |
| } | |
| } | |
| function assertArrayExpression(node, opts = {}) { | |
| assert("ArrayExpression", node, opts); | |
| } | |
| function assertAssignmentExpression(node, opts = {}) { | |
| assert("AssignmentExpression", node, opts); | |
| } | |
| function assertBinaryExpression(node, opts = {}) { | |
| assert("BinaryExpression", node, opts); | |
| } | |
| function assertInterpreterDirective(node, opts = {}) { | |
| assert("InterpreterDirective", node, opts); | |
| } | |
| function assertDirective(node, opts = {}) { | |
| assert("Directive", node, opts); | |
| } | |
| function assertDirectiveLiteral(node, opts = {}) { | |
| assert("DirectiveLiteral", node, opts); | |
| } | |
| function assertBlockStatement(node, opts = {}) { | |
| assert("BlockStatement", node, opts); | |
| } | |
| function assertBreakStatement(node, opts = {}) { | |
| assert("BreakStatement", node, opts); | |
| } | |
| function assertCallExpression(node, opts = {}) { | |
| assert("CallExpression", node, opts); | |
| } | |
| function assertCatchClause(node, opts = {}) { | |
| assert("CatchClause", node, opts); | |
| } | |
| function assertConditionalExpression(node, opts = {}) { | |
| assert("ConditionalExpression", node, opts); | |
| } | |
| function assertContinueStatement(node, opts = {}) { | |
| assert("ContinueStatement", node, opts); | |
| } | |
| function assertDebuggerStatement(node, opts = {}) { | |
| assert("DebuggerStatement", node, opts); | |
| } | |
| function assertDoWhileStatement(node, opts = {}) { | |
| assert("DoWhileStatement", node, opts); | |
| } | |
| function assertEmptyStatement(node, opts = {}) { | |
| assert("EmptyStatement", node, opts); | |
| } | |
| function assertExpressionStatement(node, opts = {}) { | |
| assert("ExpressionStatement", node, opts); | |
| } | |
| function assertFile(node, opts = {}) { | |
| assert("File", node, opts); | |
| } | |
| function assertForInStatement(node, opts = {}) { | |
| assert("ForInStatement", node, opts); | |
| } | |
| function assertForStatement(node, opts = {}) { | |
| assert("ForStatement", node, opts); | |
| } | |
| function assertFunctionDeclaration(node, opts = {}) { | |
| assert("FunctionDeclaration", node, opts); | |
| } | |
| function assertFunctionExpression(node, opts = {}) { | |
| assert("FunctionExpression", node, opts); | |
| } | |
| function assertIdentifier(node, opts = {}) { | |
| assert("Identifier", node, opts); | |
| } | |
| function assertIfStatement(node, opts = {}) { | |
| assert("IfStatement", node, opts); | |
| } | |
| function assertLabeledStatement(node, opts = {}) { | |
| assert("LabeledStatement", node, opts); | |
| } | |
| function assertStringLiteral(node, opts = {}) { | |
| assert("StringLiteral", node, opts); | |
| } | |
| function assertNumericLiteral(node, opts = {}) { | |
| assert("NumericLiteral", node, opts); | |
| } | |
| function assertNullLiteral(node, opts = {}) { | |
| assert("NullLiteral", node, opts); | |
| } | |
| function assertBooleanLiteral(node, opts = {}) { | |
| assert("BooleanLiteral", node, opts); | |
| } | |
| function assertRegExpLiteral(node, opts = {}) { | |
| assert("RegExpLiteral", node, opts); | |
| } | |
| function assertLogicalExpression(node, opts = {}) { | |
| assert("LogicalExpression", node, opts); | |
| } | |
| function assertMemberExpression(node, opts = {}) { | |
| assert("MemberExpression", node, opts); | |
| } | |
| function assertNewExpression(node, opts = {}) { | |
| assert("NewExpression", node, opts); | |
| } | |
| function assertProgram(node, opts = {}) { | |
| assert("Program", node, opts); | |
| } | |
| function assertObjectExpression(node, opts = {}) { | |
| assert("ObjectExpression", node, opts); | |
| } | |
| function assertObjectMethod(node, opts = {}) { | |
| assert("ObjectMethod", node, opts); | |
| } | |
| function assertObjectProperty(node, opts = {}) { | |
| assert("ObjectProperty", node, opts); | |
| } | |
| function assertRestElement(node, opts = {}) { | |
| assert("RestElement", node, opts); | |
| } | |
| function assertReturnStatement(node, opts = {}) { | |
| assert("ReturnStatement", node, opts); | |
| } | |
| function assertSequenceExpression(node, opts = {}) { | |
| assert("SequenceExpression", node, opts); | |
| } | |
| function assertParenthesizedExpression(node, opts = {}) { | |
| assert("ParenthesizedExpression", node, opts); | |
| } | |
| function assertSwitchCase(node, opts = {}) { | |
| assert("SwitchCase", node, opts); | |
| } | |
| function assertSwitchStatement(node, opts = {}) { | |
| assert("SwitchStatement", node, opts); | |
| } | |
| function assertThisExpression(node, opts = {}) { | |
| assert("ThisExpression", node, opts); | |
| } | |
| function assertThrowStatement(node, opts = {}) { | |
| assert("ThrowStatement", node, opts); | |
| } | |
| function assertTryStatement(node, opts = {}) { | |
| assert("TryStatement", node, opts); | |
| } | |
| function assertUnaryExpression(node, opts = {}) { | |
| assert("UnaryExpression", node, opts); | |
| } | |
| function assertUpdateExpression(node, opts = {}) { | |
| assert("UpdateExpression", node, opts); | |
| } | |
| function assertVariableDeclaration(node, opts = {}) { | |
| assert("VariableDeclaration", node, opts); | |
| } | |
| function assertVariableDeclarator(node, opts = {}) { | |
| assert("VariableDeclarator", node, opts); | |
| } | |
| function assertWhileStatement(node, opts = {}) { | |
| assert("WhileStatement", node, opts); | |
| } | |
| function assertWithStatement(node, opts = {}) { | |
| assert("WithStatement", node, opts); | |
| } | |
| function assertAssignmentPattern(node, opts = {}) { | |
| assert("AssignmentPattern", node, opts); | |
| } | |
| function assertArrayPattern(node, opts = {}) { | |
| assert("ArrayPattern", node, opts); | |
| } | |
| function assertArrowFunctionExpression(node, opts = {}) { | |
| assert("ArrowFunctionExpression", node, opts); | |
| } | |
| function assertClassBody(node, opts = {}) { | |
| assert("ClassBody", node, opts); | |
| } | |
| function assertClassDeclaration(node, opts = {}) { | |
| assert("ClassDeclaration", node, opts); | |
| } | |
| function assertClassExpression(node, opts = {}) { | |
| assert("ClassExpression", node, opts); | |
| } | |
| function assertExportAllDeclaration(node, opts = {}) { | |
| assert("ExportAllDeclaration", node, opts); | |
| } | |
| function assertExportDefaultDeclaration(node, opts = {}) { | |
| assert("ExportDefaultDeclaration", node, opts); | |
| } | |
| function assertExportNamedDeclaration(node, opts = {}) { | |
| assert("ExportNamedDeclaration", node, opts); | |
| } | |
| function assertExportSpecifier(node, opts = {}) { | |
| assert("ExportSpecifier", node, opts); | |
| } | |
| function assertForOfStatement(node, opts = {}) { | |
| assert("ForOfStatement", node, opts); | |
| } | |
| function assertImportDeclaration(node, opts = {}) { | |
| assert("ImportDeclaration", node, opts); | |
| } | |
| function assertImportDefaultSpecifier(node, opts = {}) { | |
| assert("ImportDefaultSpecifier", node, opts); | |
| } | |
| function assertImportNamespaceSpecifier(node, opts = {}) { | |
| assert("ImportNamespaceSpecifier", node, opts); | |
| } | |
| function assertImportSpecifier(node, opts = {}) { | |
| assert("ImportSpecifier", node, opts); | |
| } | |
| function assertMetaProperty(node, opts = {}) { | |
| assert("MetaProperty", node, opts); | |
| } | |
| function assertClassMethod(node, opts = {}) { | |
| assert("ClassMethod", node, opts); | |
| } | |
| function assertObjectPattern(node, opts = {}) { | |
| assert("ObjectPattern", node, opts); | |
| } | |
| function assertSpreadElement(node, opts = {}) { | |
| assert("SpreadElement", node, opts); | |
| } | |
| function assertSuper(node, opts = {}) { | |
| assert("Super", node, opts); | |
| } | |
| function assertTaggedTemplateExpression(node, opts = {}) { | |
| assert("TaggedTemplateExpression", node, opts); | |
| } | |
| function assertTemplateElement(node, opts = {}) { | |
| assert("TemplateElement", node, opts); | |
| } | |
| function assertTemplateLiteral(node, opts = {}) { | |
| assert("TemplateLiteral", node, opts); | |
| } | |
| function assertYieldExpression(node, opts = {}) { | |
| assert("YieldExpression", node, opts); | |
| } | |
| function assertAnyTypeAnnotation(node, opts = {}) { | |
| assert("AnyTypeAnnotation", node, opts); | |
| } | |
| function assertArrayTypeAnnotation(node, opts = {}) { | |
| assert("ArrayTypeAnnotation", node, opts); | |
| } | |
| function assertBooleanTypeAnnotation(node, opts = {}) { | |
| assert("BooleanTypeAnnotation", node, opts); | |
| } | |
| function assertBooleanLiteralTypeAnnotation(node, opts = {}) { | |
| assert("BooleanLiteralTypeAnnotation", node, opts); | |
| } | |
| function assertNullLiteralTypeAnnotation(node, opts = {}) { | |
| assert("NullLiteralTypeAnnotation", node, opts); | |
| } | |
| function assertClassImplements(node, opts = {}) { | |
| assert("ClassImplements", node, opts); | |
| } | |
| function assertDeclareClass(node, opts = {}) { | |
| assert("DeclareClass", node, opts); | |
| } | |
| function assertDeclareFunction(node, opts = {}) { | |
| assert("DeclareFunction", node, opts); | |
| } | |
| function assertDeclareInterface(node, opts = {}) { | |
| assert("DeclareInterface", node, opts); | |
| } | |
| function assertDeclareModule(node, opts = {}) { | |
| assert("DeclareModule", node, opts); | |
| } | |
| function assertDeclareModuleExports(node, opts = {}) { | |
| assert("DeclareModuleExports", node, opts); | |
| } | |
| function assertDeclareTypeAlias(node, opts = {}) { | |
| assert("DeclareTypeAlias", node, opts); | |
| } | |
| function assertDeclareOpaqueType(node, opts = {}) { | |
| assert("DeclareOpaqueType", node, opts); | |
| } | |
| function assertDeclareVariable(node, opts = {}) { | |
| assert("DeclareVariable", node, opts); | |
| } | |
| function assertDeclareExportDeclaration(node, opts = {}) { | |
| assert("DeclareExportDeclaration", node, opts); | |
| } | |
| function assertDeclareExportAllDeclaration(node, opts = {}) { | |
| assert("DeclareExportAllDeclaration", node, opts); | |
| } | |
| function assertDeclaredPredicate(node, opts = {}) { | |
| assert("DeclaredPredicate", node, opts); | |
| } | |
| function assertExistsTypeAnnotation(node, opts = {}) { | |
| assert("ExistsTypeAnnotation", node, opts); | |
| } | |
| function assertFunctionTypeAnnotation(node, opts = {}) { | |
| assert("FunctionTypeAnnotation", node, opts); | |
| } | |
| function assertFunctionTypeParam(node, opts = {}) { | |
| assert("FunctionTypeParam", node, opts); | |
| } | |
| function assertGenericTypeAnnotation(node, opts = {}) { | |
| assert("GenericTypeAnnotation", node, opts); | |
| } | |
| function assertInferredPredicate(node, opts = {}) { | |
| assert("InferredPredicate", node, opts); | |
| } | |
| function assertInterfaceExtends(node, opts = {}) { | |
| assert("InterfaceExtends", node, opts); | |
| } | |
| function assertInterfaceDeclaration(node, opts = {}) { | |
| assert("InterfaceDeclaration", node, opts); | |
| } | |
| function assertInterfaceTypeAnnotation(node, opts = {}) { | |
| assert("InterfaceTypeAnnotation", node, opts); | |
| } | |
| function assertIntersectionTypeAnnotation(node, opts = {}) { | |
| assert("IntersectionTypeAnnotation", node, opts); | |
| } | |
| function assertMixedTypeAnnotation(node, opts = {}) { | |
| assert("MixedTypeAnnotation", node, opts); | |
| } | |
| function assertEmptyTypeAnnotation(node, opts = {}) { | |
| assert("EmptyTypeAnnotation", node, opts); | |
| } | |
| function assertNullableTypeAnnotation(node, opts = {}) { | |
| assert("NullableTypeAnnotation", node, opts); | |
| } | |
| function assertNumberLiteralTypeAnnotation(node, opts = {}) { | |
| assert("NumberLiteralTypeAnnotation", node, opts); | |
| } | |
| function assertNumberTypeAnnotation(node, opts = {}) { | |
| assert("NumberTypeAnnotation", node, opts); | |
| } | |
| function assertObjectTypeAnnotation(node, opts = {}) { | |
| assert("ObjectTypeAnnotation", node, opts); | |
| } | |
| function assertObjectTypeInternalSlot(node, opts = {}) { | |
| assert("ObjectTypeInternalSlot", node, opts); | |
| } | |
| function assertObjectTypeCallProperty(node, opts = {}) { | |
| assert("ObjectTypeCallProperty", node, opts); | |
| } | |
| function assertObjectTypeIndexer(node, opts = {}) { | |
| assert("ObjectTypeIndexer", node, opts); | |
| } | |
| function assertObjectTypeProperty(node, opts = {}) { | |
| assert("ObjectTypeProperty", node, opts); | |
| } | |
| function assertObjectTypeSpreadProperty(node, opts = {}) { | |
| assert("ObjectTypeSpreadProperty", node, opts); | |
| } | |
| function assertOpaqueType(node, opts = {}) { | |
| assert("OpaqueType", node, opts); | |
| } | |
| function assertQualifiedTypeIdentifier(node, opts = {}) { | |
| assert("QualifiedTypeIdentifier", node, opts); | |
| } | |
| function assertStringLiteralTypeAnnotation(node, opts = {}) { | |
| assert("StringLiteralTypeAnnotation", node, opts); | |
| } | |
| function assertStringTypeAnnotation(node, opts = {}) { | |
| assert("StringTypeAnnotation", node, opts); | |
| } | |
| function assertThisTypeAnnotation(node, opts = {}) { | |
| assert("ThisTypeAnnotation", node, opts); | |
| } | |
| function assertTupleTypeAnnotation(node, opts = {}) { | |
| assert("TupleTypeAnnotation", node, opts); | |
| } | |
| function assertTypeofTypeAnnotation(node, opts = {}) { | |
| assert("TypeofTypeAnnotation", node, opts); | |
| } | |
| function assertTypeAlias(node, opts = {}) { | |
| assert("TypeAlias", node, opts); | |
| } | |
| function assertTypeAnnotation(node, opts = {}) { | |
| assert("TypeAnnotation", node, opts); | |
| } | |
| function assertTypeCastExpression(node, opts = {}) { | |
| assert("TypeCastExpression", node, opts); | |
| } | |
| function assertTypeParameter(node, opts = {}) { | |
| assert("TypeParameter", node, opts); | |
| } | |
| function assertTypeParameterDeclaration(node, opts = {}) { | |
| assert("TypeParameterDeclaration", node, opts); | |
| } | |
| function assertTypeParameterInstantiation(node, opts = {}) { | |
| assert("TypeParameterInstantiation", node, opts); | |
| } | |
| function assertUnionTypeAnnotation(node, opts = {}) { | |
| assert("UnionTypeAnnotation", node, opts); | |
| } | |
| function assertVariance(node, opts = {}) { | |
| assert("Variance", node, opts); | |
| } | |
| function assertVoidTypeAnnotation(node, opts = {}) { | |
| assert("VoidTypeAnnotation", node, opts); | |
| } | |
| function assertJSXAttribute(node, opts = {}) { | |
| assert("JSXAttribute", node, opts); | |
| } | |
| function assertJSXClosingElement(node, opts = {}) { | |
| assert("JSXClosingElement", node, opts); | |
| } | |
| function assertJSXElement(node, opts = {}) { | |
| assert("JSXElement", node, opts); | |
| } | |
| function assertJSXEmptyExpression(node, opts = {}) { | |
| assert("JSXEmptyExpression", node, opts); | |
| } | |
| function assertJSXExpressionContainer(node, opts = {}) { | |
| assert("JSXExpressionContainer", node, opts); | |
| } | |
| function assertJSXSpreadChild(node, opts = {}) { | |
| assert("JSXSpreadChild", node, opts); | |
| } | |
| function assertJSXIdentifier(node, opts = {}) { | |
| assert("JSXIdentifier", node, opts); | |
| } | |
| function assertJSXMemberExpression(node, opts = {}) { | |
| assert("JSXMemberExpression", node, opts); | |
| } | |
| function assertJSXNamespacedName(node, opts = {}) { | |
| assert("JSXNamespacedName", node, opts); | |
| } | |
| function assertJSXOpeningElement(node, opts = {}) { | |
| assert("JSXOpeningElement", node, opts); | |
| } | |
| function assertJSXSpreadAttribute(node, opts = {}) { | |
| assert("JSXSpreadAttribute", node, opts); | |
| } | |
| function assertJSXText(node, opts = {}) { | |
| assert("JSXText", node, opts); | |
| } | |
| function assertJSXFragment(node, opts = {}) { | |
| assert("JSXFragment", node, opts); | |
| } | |
| function assertJSXOpeningFragment(node, opts = {}) { | |
| assert("JSXOpeningFragment", node, opts); | |
| } | |
| function assertJSXClosingFragment(node, opts = {}) { | |
| assert("JSXClosingFragment", node, opts); | |
| } | |
| function assertNoop(node, opts = {}) { | |
| assert("Noop", node, opts); | |
| } | |
| function assertPlaceholder(node, opts = {}) { | |
| assert("Placeholder", node, opts); | |
| } | |
| function assertArgumentPlaceholder(node, opts = {}) { | |
| assert("ArgumentPlaceholder", node, opts); | |
| } | |
| function assertAwaitExpression(node, opts = {}) { | |
| assert("AwaitExpression", node, opts); | |
| } | |
| function assertBindExpression(node, opts = {}) { | |
| assert("BindExpression", node, opts); | |
| } | |
| function assertClassProperty(node, opts = {}) { | |
| assert("ClassProperty", node, opts); | |
| } | |
| function assertOptionalMemberExpression(node, opts = {}) { | |
| assert("OptionalMemberExpression", node, opts); | |
| } | |
| function assertPipelineTopicExpression(node, opts = {}) { | |
| assert("PipelineTopicExpression", node, opts); | |
| } | |
| function assertPipelineBareFunction(node, opts = {}) { | |
| assert("PipelineBareFunction", node, opts); | |
| } | |
| function assertPipelinePrimaryTopicReference(node, opts = {}) { | |
| assert("PipelinePrimaryTopicReference", node, opts); | |
| } | |
| function assertOptionalCallExpression(node, opts = {}) { | |
| assert("OptionalCallExpression", node, opts); | |
| } | |
| function assertClassPrivateProperty(node, opts = {}) { | |
| assert("ClassPrivateProperty", node, opts); | |
| } | |
| function assertClassPrivateMethod(node, opts = {}) { | |
| assert("ClassPrivateMethod", node, opts); | |
| } | |
| function assertImport(node, opts = {}) { | |
| assert("Import", node, opts); | |
| } | |
| function assertDecorator(node, opts = {}) { | |
| assert("Decorator", node, opts); | |
| } | |
| function assertDoExpression(node, opts = {}) { | |
| assert("DoExpression", node, opts); | |
| } | |
| function assertExportDefaultSpecifier(node, opts = {}) { | |
| assert("ExportDefaultSpecifier", node, opts); | |
| } | |
| function assertExportNamespaceSpecifier(node, opts = {}) { | |
| assert("ExportNamespaceSpecifier", node, opts); | |
| } | |
| function assertPrivateName(node, opts = {}) { | |
| assert("PrivateName", node, opts); | |
| } | |
| function assertBigIntLiteral(node, opts = {}) { | |
| assert("BigIntLiteral", node, opts); | |
| } | |
| function assertTSParameterProperty(node, opts = {}) { | |
| assert("TSParameterProperty", node, opts); | |
| } | |
| function assertTSDeclareFunction(node, opts = {}) { | |
| assert("TSDeclareFunction", node, opts); | |
| } | |
| function assertTSDeclareMethod(node, opts = {}) { | |
| assert("TSDeclareMethod", node, opts); | |
| } | |
| function assertTSQualifiedName(node, opts = {}) { | |
| assert("TSQualifiedName", node, opts); | |
| } | |
| function assertTSCallSignatureDeclaration(node, opts = {}) { | |
| assert("TSCallSignatureDeclaration", node, opts); | |
| } | |
| function assertTSConstructSignatureDeclaration(node, opts = {}) { | |
| assert("TSConstructSignatureDeclaration", node, opts); | |
| } | |
| function assertTSPropertySignature(node, opts = {}) { | |
| assert("TSPropertySignature", node, opts); | |
| } | |
| function assertTSMethodSignature(node, opts = {}) { | |
| assert("TSMethodSignature", node, opts); | |
| } | |
| function assertTSIndexSignature(node, opts = {}) { | |
| assert("TSIndexSignature", node, opts); | |
| } | |
| function assertTSAnyKeyword(node, opts = {}) { | |
| assert("TSAnyKeyword", node, opts); | |
| } | |
| function assertTSUnknownKeyword(node, opts = {}) { | |
| assert("TSUnknownKeyword", node, opts); | |
| } | |
| function assertTSNumberKeyword(node, opts = {}) { | |
| assert("TSNumberKeyword", node, opts); | |
| } | |
| function assertTSObjectKeyword(node, opts = {}) { | |
| assert("TSObjectKeyword", node, opts); | |
| } | |
| function assertTSBooleanKeyword(node, opts = {}) { | |
| assert("TSBooleanKeyword", node, opts); | |
| } | |
| function assertTSStringKeyword(node, opts = {}) { | |
| assert("TSStringKeyword", node, opts); | |
| } | |
| function assertTSSymbolKeyword(node, opts = {}) { | |
| assert("TSSymbolKeyword", node, opts); | |
| } | |
| function assertTSVoidKeyword(node, opts = {}) { | |
| assert("TSVoidKeyword", node, opts); | |
| } | |
| function assertTSUndefinedKeyword(node, opts = {}) { | |
| assert("TSUndefinedKeyword", node, opts); | |
| } | |
| function assertTSNullKeyword(node, opts = {}) { | |
| assert("TSNullKeyword", node, opts); | |
| } | |
| function assertTSNeverKeyword(node, opts = {}) { | |
| assert("TSNeverKeyword", node, opts); | |
| } | |
| function assertTSThisType(node, opts = {}) { | |
| assert("TSThisType", node, opts); | |
| } | |
| function assertTSFunctionType(node, opts = {}) { | |
| assert("TSFunctionType", node, opts); | |
| } | |
| function assertTSConstructorType(node, opts = {}) { | |
| assert("TSConstructorType", node, opts); | |
| } | |
| function assertTSTypeReference(node, opts = {}) { | |
| assert("TSTypeReference", node, opts); | |
| } | |
| function assertTSTypePredicate(node, opts = {}) { | |
| assert("TSTypePredicate", node, opts); | |
| } | |
| function assertTSTypeQuery(node, opts = {}) { | |
| assert("TSTypeQuery", node, opts); | |
| } | |
| function assertTSTypeLiteral(node, opts = {}) { | |
| assert("TSTypeLiteral", node, opts); | |
| } | |
| function assertTSArrayType(node, opts = {}) { | |
| assert("TSArrayType", node, opts); | |
| } | |
| function assertTSTupleType(node, opts = {}) { | |
| assert("TSTupleType", node, opts); | |
| } | |
| function assertTSOptionalType(node, opts = {}) { | |
| assert("TSOptionalType", node, opts); | |
| } | |
| function assertTSRestType(node, opts = {}) { | |
| assert("TSRestType", node, opts); | |
| } | |
| function assertTSUnionType(node, opts = {}) { | |
| assert("TSUnionType", node, opts); | |
| } | |
| function assertTSIntersectionType(node, opts = {}) { | |
| assert("TSIntersectionType", node, opts); | |
| } | |
| function assertTSConditionalType(node, opts = {}) { | |
| assert("TSConditionalType", node, opts); | |
| } | |
| function assertTSInferType(node, opts = {}) { | |
| assert("TSInferType", node, opts); | |
| } | |
| function assertTSParenthesizedType(node, opts = {}) { | |
| assert("TSParenthesizedType", node, opts); | |
| } | |
| function assertTSTypeOperator(node, opts = {}) { | |
| assert("TSTypeOperator", node, opts); | |
| } | |
| function assertTSIndexedAccessType(node, opts = {}) { | |
| assert("TSIndexedAccessType", node, opts); | |
| } | |
| function assertTSMappedType(node, opts = {}) { | |
| assert("TSMappedType", node, opts); | |
| } | |
| function assertTSLiteralType(node, opts = {}) { | |
| assert("TSLiteralType", node, opts); | |
| } | |
| function assertTSExpressionWithTypeArguments(node, opts = {}) { | |
| assert("TSExpressionWithTypeArguments", node, opts); | |
| } | |
| function assertTSInterfaceDeclaration(node, opts = {}) { | |
| assert("TSInterfaceDeclaration", node, opts); | |
| } | |
| function assertTSInterfaceBody(node, opts = {}) { | |
| assert("TSInterfaceBody", node, opts); | |
| } | |
| function assertTSTypeAliasDeclaration(node, opts = {}) { | |
| assert("TSTypeAliasDeclaration", node, opts); | |
| } | |
| function assertTSAsExpression(node, opts = {}) { | |
| assert("TSAsExpression", node, opts); | |
| } | |
| function assertTSTypeAssertion(node, opts = {}) { | |
| assert("TSTypeAssertion", node, opts); | |
| } | |
| function assertTSEnumDeclaration(node, opts = {}) { | |
| assert("TSEnumDeclaration", node, opts); | |
| } | |
| function assertTSEnumMember(node, opts = {}) { | |
| assert("TSEnumMember", node, opts); | |
| } | |
| function assertTSModuleDeclaration(node, opts = {}) { | |
| assert("TSModuleDeclaration", node, opts); | |
| } | |
| function assertTSModuleBlock(node, opts = {}) { | |
| assert("TSModuleBlock", node, opts); | |
| } | |
| function assertTSImportType(node, opts = {}) { | |
| assert("TSImportType", node, opts); | |
| } | |
| function assertTSImportEqualsDeclaration(node, opts = {}) { | |
| assert("TSImportEqualsDeclaration", node, opts); | |
| } | |
| function assertTSExternalModuleReference(node, opts = {}) { | |
| assert("TSExternalModuleReference", node, opts); | |
| } | |
| function assertTSNonNullExpression(node, opts = {}) { | |
| assert("TSNonNullExpression", node, opts); | |
| } | |
| function assertTSExportAssignment(node, opts = {}) { | |
| assert("TSExportAssignment", node, opts); | |
| } | |
| function assertTSNamespaceExportDeclaration(node, opts = {}) { | |
| assert("TSNamespaceExportDeclaration", node, opts); | |
| } | |
| function assertTSTypeAnnotation(node, opts = {}) { | |
| assert("TSTypeAnnotation", node, opts); | |
| } | |
| function assertTSTypeParameterInstantiation(node, opts = {}) { | |
| assert("TSTypeParameterInstantiation", node, opts); | |
| } | |
| function assertTSTypeParameterDeclaration(node, opts = {}) { | |
| assert("TSTypeParameterDeclaration", node, opts); | |
| } | |
| function assertTSTypeParameter(node, opts = {}) { | |
| assert("TSTypeParameter", node, opts); | |
| } | |
| function assertExpression(node, opts = {}) { | |
| assert("Expression", node, opts); | |
| } | |
| function assertBinary(node, opts = {}) { | |
| assert("Binary", node, opts); | |
| } | |
| function assertScopable(node, opts = {}) { | |
| assert("Scopable", node, opts); | |
| } | |
| function assertBlockParent(node, opts = {}) { | |
| assert("BlockParent", node, opts); | |
| } | |
| function assertBlock(node, opts = {}) { | |
| assert("Block", node, opts); | |
| } | |
| function assertStatement(node, opts = {}) { | |
| assert("Statement", node, opts); | |
| } | |
| function assertTerminatorless(node, opts = {}) { | |
| assert("Terminatorless", node, opts); | |
| } | |
| function assertCompletionStatement(node, opts = {}) { | |
| assert("CompletionStatement", node, opts); | |
| } | |
| function assertConditional(node, opts = {}) { | |
| assert("Conditional", node, opts); | |
| } | |
| function assertLoop(node, opts = {}) { | |
| assert("Loop", node, opts); | |
| } | |
| function assertWhile(node, opts = {}) { | |
| assert("While", node, opts); | |
| } | |
| function assertExpressionWrapper(node, opts = {}) { | |
| assert("ExpressionWrapper", node, opts); | |
| } | |
| function assertFor(node, opts = {}) { | |
| assert("For", node, opts); | |
| } | |
| function assertForXStatement(node, opts = {}) { | |
| assert("ForXStatement", node, opts); | |
| } | |
| function assertFunction(node, opts = {}) { | |
| assert("Function", node, opts); | |
| } | |
| function assertFunctionParent(node, opts = {}) { | |
| assert("FunctionParent", node, opts); | |
| } | |
| function assertPureish(node, opts = {}) { | |
| assert("Pureish", node, opts); | |
| } | |
| function assertDeclaration(node, opts = {}) { | |
| assert("Declaration", node, opts); | |
| } | |
| function assertPatternLike(node, opts = {}) { | |
| assert("PatternLike", node, opts); | |
| } | |
| function assertLVal(node, opts = {}) { | |
| assert("LVal", node, opts); | |
| } | |
| function assertTSEntityName(node, opts = {}) { | |
| assert("TSEntityName", node, opts); | |
| } | |
| function assertLiteral(node, opts = {}) { | |
| assert("Literal", node, opts); | |
| } | |
| function assertImmutable(node, opts = {}) { | |
| assert("Immutable", node, opts); | |
| } | |
| function assertUserWhitespacable(node, opts = {}) { | |
| assert("UserWhitespacable", node, opts); | |
| } | |
| function assertMethod(node, opts = {}) { | |
| assert("Method", node, opts); | |
| } | |
| function assertObjectMember(node, opts = {}) { | |
| assert("ObjectMember", node, opts); | |
| } | |
| function assertProperty(node, opts = {}) { | |
| assert("Property", node, opts); | |
| } | |
| function assertUnaryLike(node, opts = {}) { | |
| assert("UnaryLike", node, opts); | |
| } | |
| function assertPattern(node, opts = {}) { | |
| assert("Pattern", node, opts); | |
| } | |
| function assertClass(node, opts = {}) { | |
| assert("Class", node, opts); | |
| } | |
| function assertModuleDeclaration(node, opts = {}) { | |
| assert("ModuleDeclaration", node, opts); | |
| } | |
| function assertExportDeclaration(node, opts = {}) { | |
| assert("ExportDeclaration", node, opts); | |
| } | |
| function assertModuleSpecifier(node, opts = {}) { | |
| assert("ModuleSpecifier", node, opts); | |
| } | |
| function assertFlow(node, opts = {}) { | |
| assert("Flow", node, opts); | |
| } | |
| function assertFlowType(node, opts = {}) { | |
| assert("FlowType", node, opts); | |
| } | |
| function assertFlowBaseAnnotation(node, opts = {}) { | |
| assert("FlowBaseAnnotation", node, opts); | |
| } | |
| function assertFlowDeclaration(node, opts = {}) { | |
| assert("FlowDeclaration", node, opts); | |
| } | |
| function assertFlowPredicate(node, opts = {}) { | |
| assert("FlowPredicate", node, opts); | |
| } | |
| function assertJSX(node, opts = {}) { | |
| assert("JSX", node, opts); | |
| } | |
| function assertPrivate(node, opts = {}) { | |
| assert("Private", node, opts); | |
| } | |
| function assertTSTypeElement(node, opts = {}) { | |
| assert("TSTypeElement", node, opts); | |
| } | |
| function assertTSType(node, opts = {}) { | |
| assert("TSType", node, opts); | |
| } | |
| function assertNumberLiteral(node, opts) { | |
| console.trace("The node type NumberLiteral has been renamed to NumericLiteral"); | |
| assert("NumberLiteral", node, opts); | |
| } | |
| function assertRegexLiteral(node, opts) { | |
| console.trace("The node type RegexLiteral has been renamed to RegExpLiteral"); | |
| assert("RegexLiteral", node, opts); | |
| } | |
| function assertRestProperty(node, opts) { | |
| console.trace("The node type RestProperty has been renamed to RestElement"); | |
| assert("RestProperty", node, opts); | |
| } | |
| function assertSpreadProperty(node, opts) { | |
| console.trace("The node type SpreadProperty has been renamed to SpreadElement"); | |
| assert("SpreadProperty", node, opts); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/builders/builder.js": | |
| /*!****************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/builders/builder.js ***! | |
| \****************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = builder; | |
| function _clone() { | |
| const data = _interopRequireDefault(__webpack_require__(/*! lodash/clone */ "../babel-generator/node_modules/lodash/clone.js")); | |
| _clone = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| var _definitions = __webpack_require__(/*! ../definitions */ "../babel-generator/node_modules/@babel/types/lib/definitions/index.js"); | |
| var _validate = _interopRequireDefault(__webpack_require__(/*! ../validators/validate */ "../babel-generator/node_modules/@babel/types/lib/validators/validate.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function builder(type, ...args) { | |
| const keys = _definitions.BUILDER_KEYS[type]; | |
| const countArgs = args.length; | |
| if (countArgs > keys.length) { | |
| throw new Error(`${type}: Too many arguments passed. Received ${countArgs} but can receive no more than ${keys.length}`); | |
| } | |
| const node = { | |
| type | |
| }; | |
| let i = 0; | |
| keys.forEach(key => { | |
| const field = _definitions.NODE_FIELDS[type][key]; | |
| let arg; | |
| if (i < countArgs) arg = args[i]; | |
| if (arg === undefined) arg = (0, _clone().default)(field.default); | |
| node[key] = arg; | |
| i++; | |
| }); | |
| for (const key of Object.keys(node)) { | |
| (0, _validate.default)(node, key, node[key]); | |
| } | |
| return node; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js": | |
| /*!***********************************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js ***! | |
| \***********************************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = createTypeAnnotationBasedOnTypeof; | |
| var _generated = __webpack_require__(/*! ../generated */ "../babel-generator/node_modules/@babel/types/lib/builders/generated/index.js"); | |
| function createTypeAnnotationBasedOnTypeof(type) { | |
| if (type === "string") { | |
| return (0, _generated.stringTypeAnnotation)(); | |
| } else if (type === "number") { | |
| return (0, _generated.numberTypeAnnotation)(); | |
| } else if (type === "undefined") { | |
| return (0, _generated.voidTypeAnnotation)(); | |
| } else if (type === "boolean") { | |
| return (0, _generated.booleanTypeAnnotation)(); | |
| } else if (type === "function") { | |
| return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Function")); | |
| } else if (type === "object") { | |
| return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Object")); | |
| } else if (type === "symbol") { | |
| return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Symbol")); | |
| } else { | |
| throw new Error("Invalid typeof value"); | |
| } | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/builders/flow/createUnionTypeAnnotation.js": | |
| /*!***************************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/builders/flow/createUnionTypeAnnotation.js ***! | |
| \***************************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = createUnionTypeAnnotation; | |
| var _generated = __webpack_require__(/*! ../generated */ "../babel-generator/node_modules/@babel/types/lib/builders/generated/index.js"); | |
| var _removeTypeDuplicates = _interopRequireDefault(__webpack_require__(/*! ../../modifications/flow/removeTypeDuplicates */ "../babel-generator/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function createUnionTypeAnnotation(types) { | |
| const flattened = (0, _removeTypeDuplicates.default)(types); | |
| if (flattened.length === 1) { | |
| return flattened[0]; | |
| } else { | |
| return (0, _generated.unionTypeAnnotation)(flattened); | |
| } | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/builders/generated/index.js": | |
| /*!************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/builders/generated/index.js ***! | |
| \************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.arrayExpression = exports.ArrayExpression = ArrayExpression; | |
| exports.assignmentExpression = exports.AssignmentExpression = AssignmentExpression; | |
| exports.binaryExpression = exports.BinaryExpression = BinaryExpression; | |
| exports.interpreterDirective = exports.InterpreterDirective = InterpreterDirective; | |
| exports.directive = exports.Directive = Directive; | |
| exports.directiveLiteral = exports.DirectiveLiteral = DirectiveLiteral; | |
| exports.blockStatement = exports.BlockStatement = BlockStatement; | |
| exports.breakStatement = exports.BreakStatement = BreakStatement; | |
| exports.callExpression = exports.CallExpression = CallExpression; | |
| exports.catchClause = exports.CatchClause = CatchClause; | |
| exports.conditionalExpression = exports.ConditionalExpression = ConditionalExpression; | |
| exports.continueStatement = exports.ContinueStatement = ContinueStatement; | |
| exports.debuggerStatement = exports.DebuggerStatement = DebuggerStatement; | |
| exports.doWhileStatement = exports.DoWhileStatement = DoWhileStatement; | |
| exports.emptyStatement = exports.EmptyStatement = EmptyStatement; | |
| exports.expressionStatement = exports.ExpressionStatement = ExpressionStatement; | |
| exports.file = exports.File = File; | |
| exports.forInStatement = exports.ForInStatement = ForInStatement; | |
| exports.forStatement = exports.ForStatement = ForStatement; | |
| exports.functionDeclaration = exports.FunctionDeclaration = FunctionDeclaration; | |
| exports.functionExpression = exports.FunctionExpression = FunctionExpression; | |
| exports.identifier = exports.Identifier = Identifier; | |
| exports.ifStatement = exports.IfStatement = IfStatement; | |
| exports.labeledStatement = exports.LabeledStatement = LabeledStatement; | |
| exports.stringLiteral = exports.StringLiteral = StringLiteral; | |
| exports.numericLiteral = exports.NumericLiteral = NumericLiteral; | |
| exports.nullLiteral = exports.NullLiteral = NullLiteral; | |
| exports.booleanLiteral = exports.BooleanLiteral = BooleanLiteral; | |
| exports.regExpLiteral = exports.RegExpLiteral = RegExpLiteral; | |
| exports.logicalExpression = exports.LogicalExpression = LogicalExpression; | |
| exports.memberExpression = exports.MemberExpression = MemberExpression; | |
| exports.newExpression = exports.NewExpression = NewExpression; | |
| exports.program = exports.Program = Program; | |
| exports.objectExpression = exports.ObjectExpression = ObjectExpression; | |
| exports.objectMethod = exports.ObjectMethod = ObjectMethod; | |
| exports.objectProperty = exports.ObjectProperty = ObjectProperty; | |
| exports.restElement = exports.RestElement = RestElement; | |
| exports.returnStatement = exports.ReturnStatement = ReturnStatement; | |
| exports.sequenceExpression = exports.SequenceExpression = SequenceExpression; | |
| exports.parenthesizedExpression = exports.ParenthesizedExpression = ParenthesizedExpression; | |
| exports.switchCase = exports.SwitchCase = SwitchCase; | |
| exports.switchStatement = exports.SwitchStatement = SwitchStatement; | |
| exports.thisExpression = exports.ThisExpression = ThisExpression; | |
| exports.throwStatement = exports.ThrowStatement = ThrowStatement; | |
| exports.tryStatement = exports.TryStatement = TryStatement; | |
| exports.unaryExpression = exports.UnaryExpression = UnaryExpression; | |
| exports.updateExpression = exports.UpdateExpression = UpdateExpression; | |
| exports.variableDeclaration = exports.VariableDeclaration = VariableDeclaration; | |
| exports.variableDeclarator = exports.VariableDeclarator = VariableDeclarator; | |
| exports.whileStatement = exports.WhileStatement = WhileStatement; | |
| exports.withStatement = exports.WithStatement = WithStatement; | |
| exports.assignmentPattern = exports.AssignmentPattern = AssignmentPattern; | |
| exports.arrayPattern = exports.ArrayPattern = ArrayPattern; | |
| exports.arrowFunctionExpression = exports.ArrowFunctionExpression = ArrowFunctionExpression; | |
| exports.classBody = exports.ClassBody = ClassBody; | |
| exports.classDeclaration = exports.ClassDeclaration = ClassDeclaration; | |
| exports.classExpression = exports.ClassExpression = ClassExpression; | |
| exports.exportAllDeclaration = exports.ExportAllDeclaration = ExportAllDeclaration; | |
| exports.exportDefaultDeclaration = exports.ExportDefaultDeclaration = ExportDefaultDeclaration; | |
| exports.exportNamedDeclaration = exports.ExportNamedDeclaration = ExportNamedDeclaration; | |
| exports.exportSpecifier = exports.ExportSpecifier = ExportSpecifier; | |
| exports.forOfStatement = exports.ForOfStatement = ForOfStatement; | |
| exports.importDeclaration = exports.ImportDeclaration = ImportDeclaration; | |
| exports.importDefaultSpecifier = exports.ImportDefaultSpecifier = ImportDefaultSpecifier; | |
| exports.importNamespaceSpecifier = exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier; | |
| exports.importSpecifier = exports.ImportSpecifier = ImportSpecifier; | |
| exports.metaProperty = exports.MetaProperty = MetaProperty; | |
| exports.classMethod = exports.ClassMethod = ClassMethod; | |
| exports.objectPattern = exports.ObjectPattern = ObjectPattern; | |
| exports.spreadElement = exports.SpreadElement = SpreadElement; | |
| exports.super = exports.Super = Super; | |
| exports.taggedTemplateExpression = exports.TaggedTemplateExpression = TaggedTemplateExpression; | |
| exports.templateElement = exports.TemplateElement = TemplateElement; | |
| exports.templateLiteral = exports.TemplateLiteral = TemplateLiteral; | |
| exports.yieldExpression = exports.YieldExpression = YieldExpression; | |
| exports.anyTypeAnnotation = exports.AnyTypeAnnotation = AnyTypeAnnotation; | |
| exports.arrayTypeAnnotation = exports.ArrayTypeAnnotation = ArrayTypeAnnotation; | |
| exports.booleanTypeAnnotation = exports.BooleanTypeAnnotation = BooleanTypeAnnotation; | |
| exports.booleanLiteralTypeAnnotation = exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation; | |
| exports.nullLiteralTypeAnnotation = exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation; | |
| exports.classImplements = exports.ClassImplements = ClassImplements; | |
| exports.declareClass = exports.DeclareClass = DeclareClass; | |
| exports.declareFunction = exports.DeclareFunction = DeclareFunction; | |
| exports.declareInterface = exports.DeclareInterface = DeclareInterface; | |
| exports.declareModule = exports.DeclareModule = DeclareModule; | |
| exports.declareModuleExports = exports.DeclareModuleExports = DeclareModuleExports; | |
| exports.declareTypeAlias = exports.DeclareTypeAlias = DeclareTypeAlias; | |
| exports.declareOpaqueType = exports.DeclareOpaqueType = DeclareOpaqueType; | |
| exports.declareVariable = exports.DeclareVariable = DeclareVariable; | |
| exports.declareExportDeclaration = exports.DeclareExportDeclaration = DeclareExportDeclaration; | |
| exports.declareExportAllDeclaration = exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration; | |
| exports.declaredPredicate = exports.DeclaredPredicate = DeclaredPredicate; | |
| exports.existsTypeAnnotation = exports.ExistsTypeAnnotation = ExistsTypeAnnotation; | |
| exports.functionTypeAnnotation = exports.FunctionTypeAnnotation = FunctionTypeAnnotation; | |
| exports.functionTypeParam = exports.FunctionTypeParam = FunctionTypeParam; | |
| exports.genericTypeAnnotation = exports.GenericTypeAnnotation = GenericTypeAnnotation; | |
| exports.inferredPredicate = exports.InferredPredicate = InferredPredicate; | |
| exports.interfaceExtends = exports.InterfaceExtends = InterfaceExtends; | |
| exports.interfaceDeclaration = exports.InterfaceDeclaration = InterfaceDeclaration; | |
| exports.interfaceTypeAnnotation = exports.InterfaceTypeAnnotation = InterfaceTypeAnnotation; | |
| exports.intersectionTypeAnnotation = exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation; | |
| exports.mixedTypeAnnotation = exports.MixedTypeAnnotation = MixedTypeAnnotation; | |
| exports.emptyTypeAnnotation = exports.EmptyTypeAnnotation = EmptyTypeAnnotation; | |
| exports.nullableTypeAnnotation = exports.NullableTypeAnnotation = NullableTypeAnnotation; | |
| exports.numberLiteralTypeAnnotation = exports.NumberLiteralTypeAnnotation = NumberLiteralTypeAnnotation; | |
| exports.numberTypeAnnotation = exports.NumberTypeAnnotation = NumberTypeAnnotation; | |
| exports.objectTypeAnnotation = exports.ObjectTypeAnnotation = ObjectTypeAnnotation; | |
| exports.objectTypeInternalSlot = exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot; | |
| exports.objectTypeCallProperty = exports.ObjectTypeCallProperty = ObjectTypeCallProperty; | |
| exports.objectTypeIndexer = exports.ObjectTypeIndexer = ObjectTypeIndexer; | |
| exports.objectTypeProperty = exports.ObjectTypeProperty = ObjectTypeProperty; | |
| exports.objectTypeSpreadProperty = exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty; | |
| exports.opaqueType = exports.OpaqueType = OpaqueType; | |
| exports.qualifiedTypeIdentifier = exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier; | |
| exports.stringLiteralTypeAnnotation = exports.StringLiteralTypeAnnotation = StringLiteralTypeAnnotation; | |
| exports.stringTypeAnnotation = exports.StringTypeAnnotation = StringTypeAnnotation; | |
| exports.thisTypeAnnotation = exports.ThisTypeAnnotation = ThisTypeAnnotation; | |
| exports.tupleTypeAnnotation = exports.TupleTypeAnnotation = TupleTypeAnnotation; | |
| exports.typeofTypeAnnotation = exports.TypeofTypeAnnotation = TypeofTypeAnnotation; | |
| exports.typeAlias = exports.TypeAlias = TypeAlias; | |
| exports.typeAnnotation = exports.TypeAnnotation = TypeAnnotation; | |
| exports.typeCastExpression = exports.TypeCastExpression = TypeCastExpression; | |
| exports.typeParameter = exports.TypeParameter = TypeParameter; | |
| exports.typeParameterDeclaration = exports.TypeParameterDeclaration = TypeParameterDeclaration; | |
| exports.typeParameterInstantiation = exports.TypeParameterInstantiation = TypeParameterInstantiation; | |
| exports.unionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation; | |
| exports.variance = exports.Variance = Variance; | |
| exports.voidTypeAnnotation = exports.VoidTypeAnnotation = VoidTypeAnnotation; | |
| exports.jSXAttribute = exports.jsxAttribute = exports.JSXAttribute = JSXAttribute; | |
| exports.jSXClosingElement = exports.jsxClosingElement = exports.JSXClosingElement = JSXClosingElement; | |
| exports.jSXElement = exports.jsxElement = exports.JSXElement = JSXElement; | |
| exports.jSXEmptyExpression = exports.jsxEmptyExpression = exports.JSXEmptyExpression = JSXEmptyExpression; | |
| exports.jSXExpressionContainer = exports.jsxExpressionContainer = exports.JSXExpressionContainer = JSXExpressionContainer; | |
| exports.jSXSpreadChild = exports.jsxSpreadChild = exports.JSXSpreadChild = JSXSpreadChild; | |
| exports.jSXIdentifier = exports.jsxIdentifier = exports.JSXIdentifier = JSXIdentifier; | |
| exports.jSXMemberExpression = exports.jsxMemberExpression = exports.JSXMemberExpression = JSXMemberExpression; | |
| exports.jSXNamespacedName = exports.jsxNamespacedName = exports.JSXNamespacedName = JSXNamespacedName; | |
| exports.jSXOpeningElement = exports.jsxOpeningElement = exports.JSXOpeningElement = JSXOpeningElement; | |
| exports.jSXSpreadAttribute = exports.jsxSpreadAttribute = exports.JSXSpreadAttribute = JSXSpreadAttribute; | |
| exports.jSXText = exports.jsxText = exports.JSXText = JSXText; | |
| exports.jSXFragment = exports.jsxFragment = exports.JSXFragment = JSXFragment; | |
| exports.jSXOpeningFragment = exports.jsxOpeningFragment = exports.JSXOpeningFragment = JSXOpeningFragment; | |
| exports.jSXClosingFragment = exports.jsxClosingFragment = exports.JSXClosingFragment = JSXClosingFragment; | |
| exports.noop = exports.Noop = Noop; | |
| exports.placeholder = exports.Placeholder = Placeholder; | |
| exports.argumentPlaceholder = exports.ArgumentPlaceholder = ArgumentPlaceholder; | |
| exports.awaitExpression = exports.AwaitExpression = AwaitExpression; | |
| exports.bindExpression = exports.BindExpression = BindExpression; | |
| exports.classProperty = exports.ClassProperty = ClassProperty; | |
| exports.optionalMemberExpression = exports.OptionalMemberExpression = OptionalMemberExpression; | |
| exports.pipelineTopicExpression = exports.PipelineTopicExpression = PipelineTopicExpression; | |
| exports.pipelineBareFunction = exports.PipelineBareFunction = PipelineBareFunction; | |
| exports.pipelinePrimaryTopicReference = exports.PipelinePrimaryTopicReference = PipelinePrimaryTopicReference; | |
| exports.optionalCallExpression = exports.OptionalCallExpression = OptionalCallExpression; | |
| exports.classPrivateProperty = exports.ClassPrivateProperty = ClassPrivateProperty; | |
| exports.classPrivateMethod = exports.ClassPrivateMethod = ClassPrivateMethod; | |
| exports.import = exports.Import = Import; | |
| exports.decorator = exports.Decorator = Decorator; | |
| exports.doExpression = exports.DoExpression = DoExpression; | |
| exports.exportDefaultSpecifier = exports.ExportDefaultSpecifier = ExportDefaultSpecifier; | |
| exports.exportNamespaceSpecifier = exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier; | |
| exports.privateName = exports.PrivateName = PrivateName; | |
| exports.bigIntLiteral = exports.BigIntLiteral = BigIntLiteral; | |
| exports.tSParameterProperty = exports.tsParameterProperty = exports.TSParameterProperty = TSParameterProperty; | |
| exports.tSDeclareFunction = exports.tsDeclareFunction = exports.TSDeclareFunction = TSDeclareFunction; | |
| exports.tSDeclareMethod = exports.tsDeclareMethod = exports.TSDeclareMethod = TSDeclareMethod; | |
| exports.tSQualifiedName = exports.tsQualifiedName = exports.TSQualifiedName = TSQualifiedName; | |
| exports.tSCallSignatureDeclaration = exports.tsCallSignatureDeclaration = exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration; | |
| exports.tSConstructSignatureDeclaration = exports.tsConstructSignatureDeclaration = exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration; | |
| exports.tSPropertySignature = exports.tsPropertySignature = exports.TSPropertySignature = TSPropertySignature; | |
| exports.tSMethodSignature = exports.tsMethodSignature = exports.TSMethodSignature = TSMethodSignature; | |
| exports.tSIndexSignature = exports.tsIndexSignature = exports.TSIndexSignature = TSIndexSignature; | |
| exports.tSAnyKeyword = exports.tsAnyKeyword = exports.TSAnyKeyword = TSAnyKeyword; | |
| exports.tSUnknownKeyword = exports.tsUnknownKeyword = exports.TSUnknownKeyword = TSUnknownKeyword; | |
| exports.tSNumberKeyword = exports.tsNumberKeyword = exports.TSNumberKeyword = TSNumberKeyword; | |
| exports.tSObjectKeyword = exports.tsObjectKeyword = exports.TSObjectKeyword = TSObjectKeyword; | |
| exports.tSBooleanKeyword = exports.tsBooleanKeyword = exports.TSBooleanKeyword = TSBooleanKeyword; | |
| exports.tSStringKeyword = exports.tsStringKeyword = exports.TSStringKeyword = TSStringKeyword; | |
| exports.tSSymbolKeyword = exports.tsSymbolKeyword = exports.TSSymbolKeyword = TSSymbolKeyword; | |
| exports.tSVoidKeyword = exports.tsVoidKeyword = exports.TSVoidKeyword = TSVoidKeyword; | |
| exports.tSUndefinedKeyword = exports.tsUndefinedKeyword = exports.TSUndefinedKeyword = TSUndefinedKeyword; | |
| exports.tSNullKeyword = exports.tsNullKeyword = exports.TSNullKeyword = TSNullKeyword; | |
| exports.tSNeverKeyword = exports.tsNeverKeyword = exports.TSNeverKeyword = TSNeverKeyword; | |
| exports.tSThisType = exports.tsThisType = exports.TSThisType = TSThisType; | |
| exports.tSFunctionType = exports.tsFunctionType = exports.TSFunctionType = TSFunctionType; | |
| exports.tSConstructorType = exports.tsConstructorType = exports.TSConstructorType = TSConstructorType; | |
| exports.tSTypeReference = exports.tsTypeReference = exports.TSTypeReference = TSTypeReference; | |
| exports.tSTypePredicate = exports.tsTypePredicate = exports.TSTypePredicate = TSTypePredicate; | |
| exports.tSTypeQuery = exports.tsTypeQuery = exports.TSTypeQuery = TSTypeQuery; | |
| exports.tSTypeLiteral = exports.tsTypeLiteral = exports.TSTypeLiteral = TSTypeLiteral; | |
| exports.tSArrayType = exports.tsArrayType = exports.TSArrayType = TSArrayType; | |
| exports.tSTupleType = exports.tsTupleType = exports.TSTupleType = TSTupleType; | |
| exports.tSOptionalType = exports.tsOptionalType = exports.TSOptionalType = TSOptionalType; | |
| exports.tSRestType = exports.tsRestType = exports.TSRestType = TSRestType; | |
| exports.tSUnionType = exports.tsUnionType = exports.TSUnionType = TSUnionType; | |
| exports.tSIntersectionType = exports.tsIntersectionType = exports.TSIntersectionType = TSIntersectionType; | |
| exports.tSConditionalType = exports.tsConditionalType = exports.TSConditionalType = TSConditionalType; | |
| exports.tSInferType = exports.tsInferType = exports.TSInferType = TSInferType; | |
| exports.tSParenthesizedType = exports.tsParenthesizedType = exports.TSParenthesizedType = TSParenthesizedType; | |
| exports.tSTypeOperator = exports.tsTypeOperator = exports.TSTypeOperator = TSTypeOperator; | |
| exports.tSIndexedAccessType = exports.tsIndexedAccessType = exports.TSIndexedAccessType = TSIndexedAccessType; | |
| exports.tSMappedType = exports.tsMappedType = exports.TSMappedType = TSMappedType; | |
| exports.tSLiteralType = exports.tsLiteralType = exports.TSLiteralType = TSLiteralType; | |
| exports.tSExpressionWithTypeArguments = exports.tsExpressionWithTypeArguments = exports.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments; | |
| exports.tSInterfaceDeclaration = exports.tsInterfaceDeclaration = exports.TSInterfaceDeclaration = TSInterfaceDeclaration; | |
| exports.tSInterfaceBody = exports.tsInterfaceBody = exports.TSInterfaceBody = TSInterfaceBody; | |
| exports.tSTypeAliasDeclaration = exports.tsTypeAliasDeclaration = exports.TSTypeAliasDeclaration = TSTypeAliasDeclaration; | |
| exports.tSAsExpression = exports.tsAsExpression = exports.TSAsExpression = TSAsExpression; | |
| exports.tSTypeAssertion = exports.tsTypeAssertion = exports.TSTypeAssertion = TSTypeAssertion; | |
| exports.tSEnumDeclaration = exports.tsEnumDeclaration = exports.TSEnumDeclaration = TSEnumDeclaration; | |
| exports.tSEnumMember = exports.tsEnumMember = exports.TSEnumMember = TSEnumMember; | |
| exports.tSModuleDeclaration = exports.tsModuleDeclaration = exports.TSModuleDeclaration = TSModuleDeclaration; | |
| exports.tSModuleBlock = exports.tsModuleBlock = exports.TSModuleBlock = TSModuleBlock; | |
| exports.tSImportType = exports.tsImportType = exports.TSImportType = TSImportType; | |
| exports.tSImportEqualsDeclaration = exports.tsImportEqualsDeclaration = exports.TSImportEqualsDeclaration = TSImportEqualsDeclaration; | |
| exports.tSExternalModuleReference = exports.tsExternalModuleReference = exports.TSExternalModuleReference = TSExternalModuleReference; | |
| exports.tSNonNullExpression = exports.tsNonNullExpression = exports.TSNonNullExpression = TSNonNullExpression; | |
| exports.tSExportAssignment = exports.tsExportAssignment = exports.TSExportAssignment = TSExportAssignment; | |
| exports.tSNamespaceExportDeclaration = exports.tsNamespaceExportDeclaration = exports.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration; | |
| exports.tSTypeAnnotation = exports.tsTypeAnnotation = exports.TSTypeAnnotation = TSTypeAnnotation; | |
| exports.tSTypeParameterInstantiation = exports.tsTypeParameterInstantiation = exports.TSTypeParameterInstantiation = TSTypeParameterInstantiation; | |
| exports.tSTypeParameterDeclaration = exports.tsTypeParameterDeclaration = exports.TSTypeParameterDeclaration = TSTypeParameterDeclaration; | |
| exports.tSTypeParameter = exports.tsTypeParameter = exports.TSTypeParameter = TSTypeParameter; | |
| exports.numberLiteral = exports.NumberLiteral = NumberLiteral; | |
| exports.regexLiteral = exports.RegexLiteral = RegexLiteral; | |
| exports.restProperty = exports.RestProperty = RestProperty; | |
| exports.spreadProperty = exports.SpreadProperty = SpreadProperty; | |
| var _builder = _interopRequireDefault(__webpack_require__(/*! ../builder */ "../babel-generator/node_modules/@babel/types/lib/builders/builder.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function ArrayExpression(...args) { | |
| return (0, _builder.default)("ArrayExpression", ...args); | |
| } | |
| function AssignmentExpression(...args) { | |
| return (0, _builder.default)("AssignmentExpression", ...args); | |
| } | |
| function BinaryExpression(...args) { | |
| return (0, _builder.default)("BinaryExpression", ...args); | |
| } | |
| function InterpreterDirective(...args) { | |
| return (0, _builder.default)("InterpreterDirective", ...args); | |
| } | |
| function Directive(...args) { | |
| return (0, _builder.default)("Directive", ...args); | |
| } | |
| function DirectiveLiteral(...args) { | |
| return (0, _builder.default)("DirectiveLiteral", ...args); | |
| } | |
| function BlockStatement(...args) { | |
| return (0, _builder.default)("BlockStatement", ...args); | |
| } | |
| function BreakStatement(...args) { | |
| return (0, _builder.default)("BreakStatement", ...args); | |
| } | |
| function CallExpression(...args) { | |
| return (0, _builder.default)("CallExpression", ...args); | |
| } | |
| function CatchClause(...args) { | |
| return (0, _builder.default)("CatchClause", ...args); | |
| } | |
| function ConditionalExpression(...args) { | |
| return (0, _builder.default)("ConditionalExpression", ...args); | |
| } | |
| function ContinueStatement(...args) { | |
| return (0, _builder.default)("ContinueStatement", ...args); | |
| } | |
| function DebuggerStatement(...args) { | |
| return (0, _builder.default)("DebuggerStatement", ...args); | |
| } | |
| function DoWhileStatement(...args) { | |
| return (0, _builder.default)("DoWhileStatement", ...args); | |
| } | |
| function EmptyStatement(...args) { | |
| return (0, _builder.default)("EmptyStatement", ...args); | |
| } | |
| function ExpressionStatement(...args) { | |
| return (0, _builder.default)("ExpressionStatement", ...args); | |
| } | |
| function File(...args) { | |
| return (0, _builder.default)("File", ...args); | |
| } | |
| function ForInStatement(...args) { | |
| return (0, _builder.default)("ForInStatement", ...args); | |
| } | |
| function ForStatement(...args) { | |
| return (0, _builder.default)("ForStatement", ...args); | |
| } | |
| function FunctionDeclaration(...args) { | |
| return (0, _builder.default)("FunctionDeclaration", ...args); | |
| } | |
| function FunctionExpression(...args) { | |
| return (0, _builder.default)("FunctionExpression", ...args); | |
| } | |
| function Identifier(...args) { | |
| return (0, _builder.default)("Identifier", ...args); | |
| } | |
| function IfStatement(...args) { | |
| return (0, _builder.default)("IfStatement", ...args); | |
| } | |
| function LabeledStatement(...args) { | |
| return (0, _builder.default)("LabeledStatement", ...args); | |
| } | |
| function StringLiteral(...args) { | |
| return (0, _builder.default)("StringLiteral", ...args); | |
| } | |
| function NumericLiteral(...args) { | |
| return (0, _builder.default)("NumericLiteral", ...args); | |
| } | |
| function NullLiteral(...args) { | |
| return (0, _builder.default)("NullLiteral", ...args); | |
| } | |
| function BooleanLiteral(...args) { | |
| return (0, _builder.default)("BooleanLiteral", ...args); | |
| } | |
| function RegExpLiteral(...args) { | |
| return (0, _builder.default)("RegExpLiteral", ...args); | |
| } | |
| function LogicalExpression(...args) { | |
| return (0, _builder.default)("LogicalExpression", ...args); | |
| } | |
| function MemberExpression(...args) { | |
| return (0, _builder.default)("MemberExpression", ...args); | |
| } | |
| function NewExpression(...args) { | |
| return (0, _builder.default)("NewExpression", ...args); | |
| } | |
| function Program(...args) { | |
| return (0, _builder.default)("Program", ...args); | |
| } | |
| function ObjectExpression(...args) { | |
| return (0, _builder.default)("ObjectExpression", ...args); | |
| } | |
| function ObjectMethod(...args) { | |
| return (0, _builder.default)("ObjectMethod", ...args); | |
| } | |
| function ObjectProperty(...args) { | |
| return (0, _builder.default)("ObjectProperty", ...args); | |
| } | |
| function RestElement(...args) { | |
| return (0, _builder.default)("RestElement", ...args); | |
| } | |
| function ReturnStatement(...args) { | |
| return (0, _builder.default)("ReturnStatement", ...args); | |
| } | |
| function SequenceExpression(...args) { | |
| return (0, _builder.default)("SequenceExpression", ...args); | |
| } | |
| function ParenthesizedExpression(...args) { | |
| return (0, _builder.default)("ParenthesizedExpression", ...args); | |
| } | |
| function SwitchCase(...args) { | |
| return (0, _builder.default)("SwitchCase", ...args); | |
| } | |
| function SwitchStatement(...args) { | |
| return (0, _builder.default)("SwitchStatement", ...args); | |
| } | |
| function ThisExpression(...args) { | |
| return (0, _builder.default)("ThisExpression", ...args); | |
| } | |
| function ThrowStatement(...args) { | |
| return (0, _builder.default)("ThrowStatement", ...args); | |
| } | |
| function TryStatement(...args) { | |
| return (0, _builder.default)("TryStatement", ...args); | |
| } | |
| function UnaryExpression(...args) { | |
| return (0, _builder.default)("UnaryExpression", ...args); | |
| } | |
| function UpdateExpression(...args) { | |
| return (0, _builder.default)("UpdateExpression", ...args); | |
| } | |
| function VariableDeclaration(...args) { | |
| return (0, _builder.default)("VariableDeclaration", ...args); | |
| } | |
| function VariableDeclarator(...args) { | |
| return (0, _builder.default)("VariableDeclarator", ...args); | |
| } | |
| function WhileStatement(...args) { | |
| return (0, _builder.default)("WhileStatement", ...args); | |
| } | |
| function WithStatement(...args) { | |
| return (0, _builder.default)("WithStatement", ...args); | |
| } | |
| function AssignmentPattern(...args) { | |
| return (0, _builder.default)("AssignmentPattern", ...args); | |
| } | |
| function ArrayPattern(...args) { | |
| return (0, _builder.default)("ArrayPattern", ...args); | |
| } | |
| function ArrowFunctionExpression(...args) { | |
| return (0, _builder.default)("ArrowFunctionExpression", ...args); | |
| } | |
| function ClassBody(...args) { | |
| return (0, _builder.default)("ClassBody", ...args); | |
| } | |
| function ClassDeclaration(...args) { | |
| return (0, _builder.default)("ClassDeclaration", ...args); | |
| } | |
| function ClassExpression(...args) { | |
| return (0, _builder.default)("ClassExpression", ...args); | |
| } | |
| function ExportAllDeclaration(...args) { | |
| return (0, _builder.default)("ExportAllDeclaration", ...args); | |
| } | |
| function ExportDefaultDeclaration(...args) { | |
| return (0, _builder.default)("ExportDefaultDeclaration", ...args); | |
| } | |
| function ExportNamedDeclaration(...args) { | |
| return (0, _builder.default)("ExportNamedDeclaration", ...args); | |
| } | |
| function ExportSpecifier(...args) { | |
| return (0, _builder.default)("ExportSpecifier", ...args); | |
| } | |
| function ForOfStatement(...args) { | |
| return (0, _builder.default)("ForOfStatement", ...args); | |
| } | |
| function ImportDeclaration(...args) { | |
| return (0, _builder.default)("ImportDeclaration", ...args); | |
| } | |
| function ImportDefaultSpecifier(...args) { | |
| return (0, _builder.default)("ImportDefaultSpecifier", ...args); | |
| } | |
| function ImportNamespaceSpecifier(...args) { | |
| return (0, _builder.default)("ImportNamespaceSpecifier", ...args); | |
| } | |
| function ImportSpecifier(...args) { | |
| return (0, _builder.default)("ImportSpecifier", ...args); | |
| } | |
| function MetaProperty(...args) { | |
| return (0, _builder.default)("MetaProperty", ...args); | |
| } | |
| function ClassMethod(...args) { | |
| return (0, _builder.default)("ClassMethod", ...args); | |
| } | |
| function ObjectPattern(...args) { | |
| return (0, _builder.default)("ObjectPattern", ...args); | |
| } | |
| function SpreadElement(...args) { | |
| return (0, _builder.default)("SpreadElement", ...args); | |
| } | |
| function Super(...args) { | |
| return (0, _builder.default)("Super", ...args); | |
| } | |
| function TaggedTemplateExpression(...args) { | |
| return (0, _builder.default)("TaggedTemplateExpression", ...args); | |
| } | |
| function TemplateElement(...args) { | |
| return (0, _builder.default)("TemplateElement", ...args); | |
| } | |
| function TemplateLiteral(...args) { | |
| return (0, _builder.default)("TemplateLiteral", ...args); | |
| } | |
| function YieldExpression(...args) { | |
| return (0, _builder.default)("YieldExpression", ...args); | |
| } | |
| function AnyTypeAnnotation(...args) { | |
| return (0, _builder.default)("AnyTypeAnnotation", ...args); | |
| } | |
| function ArrayTypeAnnotation(...args) { | |
| return (0, _builder.default)("ArrayTypeAnnotation", ...args); | |
| } | |
| function BooleanTypeAnnotation(...args) { | |
| return (0, _builder.default)("BooleanTypeAnnotation", ...args); | |
| } | |
| function BooleanLiteralTypeAnnotation(...args) { | |
| return (0, _builder.default)("BooleanLiteralTypeAnnotation", ...args); | |
| } | |
| function NullLiteralTypeAnnotation(...args) { | |
| return (0, _builder.default)("NullLiteralTypeAnnotation", ...args); | |
| } | |
| function ClassImplements(...args) { | |
| return (0, _builder.default)("ClassImplements", ...args); | |
| } | |
| function DeclareClass(...args) { | |
| return (0, _builder.default)("DeclareClass", ...args); | |
| } | |
| function DeclareFunction(...args) { | |
| return (0, _builder.default)("DeclareFunction", ...args); | |
| } | |
| function DeclareInterface(...args) { | |
| return (0, _builder.default)("DeclareInterface", ...args); | |
| } | |
| function DeclareModule(...args) { | |
| return (0, _builder.default)("DeclareModule", ...args); | |
| } | |
| function DeclareModuleExports(...args) { | |
| return (0, _builder.default)("DeclareModuleExports", ...args); | |
| } | |
| function DeclareTypeAlias(...args) { | |
| return (0, _builder.default)("DeclareTypeAlias", ...args); | |
| } | |
| function DeclareOpaqueType(...args) { | |
| return (0, _builder.default)("DeclareOpaqueType", ...args); | |
| } | |
| function DeclareVariable(...args) { | |
| return (0, _builder.default)("DeclareVariable", ...args); | |
| } | |
| function DeclareExportDeclaration(...args) { | |
| return (0, _builder.default)("DeclareExportDeclaration", ...args); | |
| } | |
| function DeclareExportAllDeclaration(...args) { | |
| return (0, _builder.default)("DeclareExportAllDeclaration", ...args); | |
| } | |
| function DeclaredPredicate(...args) { | |
| return (0, _builder.default)("DeclaredPredicate", ...args); | |
| } | |
| function ExistsTypeAnnotation(...args) { | |
| return (0, _builder.default)("ExistsTypeAnnotation", ...args); | |
| } | |
| function FunctionTypeAnnotation(...args) { | |
| return (0, _builder.default)("FunctionTypeAnnotation", ...args); | |
| } | |
| function FunctionTypeParam(...args) { | |
| return (0, _builder.default)("FunctionTypeParam", ...args); | |
| } | |
| function GenericTypeAnnotation(...args) { | |
| return (0, _builder.default)("GenericTypeAnnotation", ...args); | |
| } | |
| function InferredPredicate(...args) { | |
| return (0, _builder.default)("InferredPredicate", ...args); | |
| } | |
| function InterfaceExtends(...args) { | |
| return (0, _builder.default)("InterfaceExtends", ...args); | |
| } | |
| function InterfaceDeclaration(...args) { | |
| return (0, _builder.default)("InterfaceDeclaration", ...args); | |
| } | |
| function InterfaceTypeAnnotation(...args) { | |
| return (0, _builder.default)("InterfaceTypeAnnotation", ...args); | |
| } | |
| function IntersectionTypeAnnotation(...args) { | |
| return (0, _builder.default)("IntersectionTypeAnnotation", ...args); | |
| } | |
| function MixedTypeAnnotation(...args) { | |
| return (0, _builder.default)("MixedTypeAnnotation", ...args); | |
| } | |
| function EmptyTypeAnnotation(...args) { | |
| return (0, _builder.default)("EmptyTypeAnnotation", ...args); | |
| } | |
| function NullableTypeAnnotation(...args) { | |
| return (0, _builder.default)("NullableTypeAnnotation", ...args); | |
| } | |
| function NumberLiteralTypeAnnotation(...args) { | |
| return (0, _builder.default)("NumberLiteralTypeAnnotation", ...args); | |
| } | |
| function NumberTypeAnnotation(...args) { | |
| return (0, _builder.default)("NumberTypeAnnotation", ...args); | |
| } | |
| function ObjectTypeAnnotation(...args) { | |
| return (0, _builder.default)("ObjectTypeAnnotation", ...args); | |
| } | |
| function ObjectTypeInternalSlot(...args) { | |
| return (0, _builder.default)("ObjectTypeInternalSlot", ...args); | |
| } | |
| function ObjectTypeCallProperty(...args) { | |
| return (0, _builder.default)("ObjectTypeCallProperty", ...args); | |
| } | |
| function ObjectTypeIndexer(...args) { | |
| return (0, _builder.default)("ObjectTypeIndexer", ...args); | |
| } | |
| function ObjectTypeProperty(...args) { | |
| return (0, _builder.default)("ObjectTypeProperty", ...args); | |
| } | |
| function ObjectTypeSpreadProperty(...args) { | |
| return (0, _builder.default)("ObjectTypeSpreadProperty", ...args); | |
| } | |
| function OpaqueType(...args) { | |
| return (0, _builder.default)("OpaqueType", ...args); | |
| } | |
| function QualifiedTypeIdentifier(...args) { | |
| return (0, _builder.default)("QualifiedTypeIdentifier", ...args); | |
| } | |
| function StringLiteralTypeAnnotation(...args) { | |
| return (0, _builder.default)("StringLiteralTypeAnnotation", ...args); | |
| } | |
| function StringTypeAnnotation(...args) { | |
| return (0, _builder.default)("StringTypeAnnotation", ...args); | |
| } | |
| function ThisTypeAnnotation(...args) { | |
| return (0, _builder.default)("ThisTypeAnnotation", ...args); | |
| } | |
| function TupleTypeAnnotation(...args) { | |
| return (0, _builder.default)("TupleTypeAnnotation", ...args); | |
| } | |
| function TypeofTypeAnnotation(...args) { | |
| return (0, _builder.default)("TypeofTypeAnnotation", ...args); | |
| } | |
| function TypeAlias(...args) { | |
| return (0, _builder.default)("TypeAlias", ...args); | |
| } | |
| function TypeAnnotation(...args) { | |
| return (0, _builder.default)("TypeAnnotation", ...args); | |
| } | |
| function TypeCastExpression(...args) { | |
| return (0, _builder.default)("TypeCastExpression", ...args); | |
| } | |
| function TypeParameter(...args) { | |
| return (0, _builder.default)("TypeParameter", ...args); | |
| } | |
| function TypeParameterDeclaration(...args) { | |
| return (0, _builder.default)("TypeParameterDeclaration", ...args); | |
| } | |
| function TypeParameterInstantiation(...args) { | |
| return (0, _builder.default)("TypeParameterInstantiation", ...args); | |
| } | |
| function UnionTypeAnnotation(...args) { | |
| return (0, _builder.default)("UnionTypeAnnotation", ...args); | |
| } | |
| function Variance(...args) { | |
| return (0, _builder.default)("Variance", ...args); | |
| } | |
| function VoidTypeAnnotation(...args) { | |
| return (0, _builder.default)("VoidTypeAnnotation", ...args); | |
| } | |
| function JSXAttribute(...args) { | |
| return (0, _builder.default)("JSXAttribute", ...args); | |
| } | |
| function JSXClosingElement(...args) { | |
| return (0, _builder.default)("JSXClosingElement", ...args); | |
| } | |
| function JSXElement(...args) { | |
| return (0, _builder.default)("JSXElement", ...args); | |
| } | |
| function JSXEmptyExpression(...args) { | |
| return (0, _builder.default)("JSXEmptyExpression", ...args); | |
| } | |
| function JSXExpressionContainer(...args) { | |
| return (0, _builder.default)("JSXExpressionContainer", ...args); | |
| } | |
| function JSXSpreadChild(...args) { | |
| return (0, _builder.default)("JSXSpreadChild", ...args); | |
| } | |
| function JSXIdentifier(...args) { | |
| return (0, _builder.default)("JSXIdentifier", ...args); | |
| } | |
| function JSXMemberExpression(...args) { | |
| return (0, _builder.default)("JSXMemberExpression", ...args); | |
| } | |
| function JSXNamespacedName(...args) { | |
| return (0, _builder.default)("JSXNamespacedName", ...args); | |
| } | |
| function JSXOpeningElement(...args) { | |
| return (0, _builder.default)("JSXOpeningElement", ...args); | |
| } | |
| function JSXSpreadAttribute(...args) { | |
| return (0, _builder.default)("JSXSpreadAttribute", ...args); | |
| } | |
| function JSXText(...args) { | |
| return (0, _builder.default)("JSXText", ...args); | |
| } | |
| function JSXFragment(...args) { | |
| return (0, _builder.default)("JSXFragment", ...args); | |
| } | |
| function JSXOpeningFragment(...args) { | |
| return (0, _builder.default)("JSXOpeningFragment", ...args); | |
| } | |
| function JSXClosingFragment(...args) { | |
| return (0, _builder.default)("JSXClosingFragment", ...args); | |
| } | |
| function Noop(...args) { | |
| return (0, _builder.default)("Noop", ...args); | |
| } | |
| function Placeholder(...args) { | |
| return (0, _builder.default)("Placeholder", ...args); | |
| } | |
| function ArgumentPlaceholder(...args) { | |
| return (0, _builder.default)("ArgumentPlaceholder", ...args); | |
| } | |
| function AwaitExpression(...args) { | |
| return (0, _builder.default)("AwaitExpression", ...args); | |
| } | |
| function BindExpression(...args) { | |
| return (0, _builder.default)("BindExpression", ...args); | |
| } | |
| function ClassProperty(...args) { | |
| return (0, _builder.default)("ClassProperty", ...args); | |
| } | |
| function OptionalMemberExpression(...args) { | |
| return (0, _builder.default)("OptionalMemberExpression", ...args); | |
| } | |
| function PipelineTopicExpression(...args) { | |
| return (0, _builder.default)("PipelineTopicExpression", ...args); | |
| } | |
| function PipelineBareFunction(...args) { | |
| return (0, _builder.default)("PipelineBareFunction", ...args); | |
| } | |
| function PipelinePrimaryTopicReference(...args) { | |
| return (0, _builder.default)("PipelinePrimaryTopicReference", ...args); | |
| } | |
| function OptionalCallExpression(...args) { | |
| return (0, _builder.default)("OptionalCallExpression", ...args); | |
| } | |
| function ClassPrivateProperty(...args) { | |
| return (0, _builder.default)("ClassPrivateProperty", ...args); | |
| } | |
| function ClassPrivateMethod(...args) { | |
| return (0, _builder.default)("ClassPrivateMethod", ...args); | |
| } | |
| function Import(...args) { | |
| return (0, _builder.default)("Import", ...args); | |
| } | |
| function Decorator(...args) { | |
| return (0, _builder.default)("Decorator", ...args); | |
| } | |
| function DoExpression(...args) { | |
| return (0, _builder.default)("DoExpression", ...args); | |
| } | |
| function ExportDefaultSpecifier(...args) { | |
| return (0, _builder.default)("ExportDefaultSpecifier", ...args); | |
| } | |
| function ExportNamespaceSpecifier(...args) { | |
| return (0, _builder.default)("ExportNamespaceSpecifier", ...args); | |
| } | |
| function PrivateName(...args) { | |
| return (0, _builder.default)("PrivateName", ...args); | |
| } | |
| function BigIntLiteral(...args) { | |
| return (0, _builder.default)("BigIntLiteral", ...args); | |
| } | |
| function TSParameterProperty(...args) { | |
| return (0, _builder.default)("TSParameterProperty", ...args); | |
| } | |
| function TSDeclareFunction(...args) { | |
| return (0, _builder.default)("TSDeclareFunction", ...args); | |
| } | |
| function TSDeclareMethod(...args) { | |
| return (0, _builder.default)("TSDeclareMethod", ...args); | |
| } | |
| function TSQualifiedName(...args) { | |
| return (0, _builder.default)("TSQualifiedName", ...args); | |
| } | |
| function TSCallSignatureDeclaration(...args) { | |
| return (0, _builder.default)("TSCallSignatureDeclaration", ...args); | |
| } | |
| function TSConstructSignatureDeclaration(...args) { | |
| return (0, _builder.default)("TSConstructSignatureDeclaration", ...args); | |
| } | |
| function TSPropertySignature(...args) { | |
| return (0, _builder.default)("TSPropertySignature", ...args); | |
| } | |
| function TSMethodSignature(...args) { | |
| return (0, _builder.default)("TSMethodSignature", ...args); | |
| } | |
| function TSIndexSignature(...args) { | |
| return (0, _builder.default)("TSIndexSignature", ...args); | |
| } | |
| function TSAnyKeyword(...args) { | |
| return (0, _builder.default)("TSAnyKeyword", ...args); | |
| } | |
| function TSUnknownKeyword(...args) { | |
| return (0, _builder.default)("TSUnknownKeyword", ...args); | |
| } | |
| function TSNumberKeyword(...args) { | |
| return (0, _builder.default)("TSNumberKeyword", ...args); | |
| } | |
| function TSObjectKeyword(...args) { | |
| return (0, _builder.default)("TSObjectKeyword", ...args); | |
| } | |
| function TSBooleanKeyword(...args) { | |
| return (0, _builder.default)("TSBooleanKeyword", ...args); | |
| } | |
| function TSStringKeyword(...args) { | |
| return (0, _builder.default)("TSStringKeyword", ...args); | |
| } | |
| function TSSymbolKeyword(...args) { | |
| return (0, _builder.default)("TSSymbolKeyword", ...args); | |
| } | |
| function TSVoidKeyword(...args) { | |
| return (0, _builder.default)("TSVoidKeyword", ...args); | |
| } | |
| function TSUndefinedKeyword(...args) { | |
| return (0, _builder.default)("TSUndefinedKeyword", ...args); | |
| } | |
| function TSNullKeyword(...args) { | |
| return (0, _builder.default)("TSNullKeyword", ...args); | |
| } | |
| function TSNeverKeyword(...args) { | |
| return (0, _builder.default)("TSNeverKeyword", ...args); | |
| } | |
| function TSThisType(...args) { | |
| return (0, _builder.default)("TSThisType", ...args); | |
| } | |
| function TSFunctionType(...args) { | |
| return (0, _builder.default)("TSFunctionType", ...args); | |
| } | |
| function TSConstructorType(...args) { | |
| return (0, _builder.default)("TSConstructorType", ...args); | |
| } | |
| function TSTypeReference(...args) { | |
| return (0, _builder.default)("TSTypeReference", ...args); | |
| } | |
| function TSTypePredicate(...args) { | |
| return (0, _builder.default)("TSTypePredicate", ...args); | |
| } | |
| function TSTypeQuery(...args) { | |
| return (0, _builder.default)("TSTypeQuery", ...args); | |
| } | |
| function TSTypeLiteral(...args) { | |
| return (0, _builder.default)("TSTypeLiteral", ...args); | |
| } | |
| function TSArrayType(...args) { | |
| return (0, _builder.default)("TSArrayType", ...args); | |
| } | |
| function TSTupleType(...args) { | |
| return (0, _builder.default)("TSTupleType", ...args); | |
| } | |
| function TSOptionalType(...args) { | |
| return (0, _builder.default)("TSOptionalType", ...args); | |
| } | |
| function TSRestType(...args) { | |
| return (0, _builder.default)("TSRestType", ...args); | |
| } | |
| function TSUnionType(...args) { | |
| return (0, _builder.default)("TSUnionType", ...args); | |
| } | |
| function TSIntersectionType(...args) { | |
| return (0, _builder.default)("TSIntersectionType", ...args); | |
| } | |
| function TSConditionalType(...args) { | |
| return (0, _builder.default)("TSConditionalType", ...args); | |
| } | |
| function TSInferType(...args) { | |
| return (0, _builder.default)("TSInferType", ...args); | |
| } | |
| function TSParenthesizedType(...args) { | |
| return (0, _builder.default)("TSParenthesizedType", ...args); | |
| } | |
| function TSTypeOperator(...args) { | |
| return (0, _builder.default)("TSTypeOperator", ...args); | |
| } | |
| function TSIndexedAccessType(...args) { | |
| return (0, _builder.default)("TSIndexedAccessType", ...args); | |
| } | |
| function TSMappedType(...args) { | |
| return (0, _builder.default)("TSMappedType", ...args); | |
| } | |
| function TSLiteralType(...args) { | |
| return (0, _builder.default)("TSLiteralType", ...args); | |
| } | |
| function TSExpressionWithTypeArguments(...args) { | |
| return (0, _builder.default)("TSExpressionWithTypeArguments", ...args); | |
| } | |
| function TSInterfaceDeclaration(...args) { | |
| return (0, _builder.default)("TSInterfaceDeclaration", ...args); | |
| } | |
| function TSInterfaceBody(...args) { | |
| return (0, _builder.default)("TSInterfaceBody", ...args); | |
| } | |
| function TSTypeAliasDeclaration(...args) { | |
| return (0, _builder.default)("TSTypeAliasDeclaration", ...args); | |
| } | |
| function TSAsExpression(...args) { | |
| return (0, _builder.default)("TSAsExpression", ...args); | |
| } | |
| function TSTypeAssertion(...args) { | |
| return (0, _builder.default)("TSTypeAssertion", ...args); | |
| } | |
| function TSEnumDeclaration(...args) { | |
| return (0, _builder.default)("TSEnumDeclaration", ...args); | |
| } | |
| function TSEnumMember(...args) { | |
| return (0, _builder.default)("TSEnumMember", ...args); | |
| } | |
| function TSModuleDeclaration(...args) { | |
| return (0, _builder.default)("TSModuleDeclaration", ...args); | |
| } | |
| function TSModuleBlock(...args) { | |
| return (0, _builder.default)("TSModuleBlock", ...args); | |
| } | |
| function TSImportType(...args) { | |
| return (0, _builder.default)("TSImportType", ...args); | |
| } | |
| function TSImportEqualsDeclaration(...args) { | |
| return (0, _builder.default)("TSImportEqualsDeclaration", ...args); | |
| } | |
| function TSExternalModuleReference(...args) { | |
| return (0, _builder.default)("TSExternalModuleReference", ...args); | |
| } | |
| function TSNonNullExpression(...args) { | |
| return (0, _builder.default)("TSNonNullExpression", ...args); | |
| } | |
| function TSExportAssignment(...args) { | |
| return (0, _builder.default)("TSExportAssignment", ...args); | |
| } | |
| function TSNamespaceExportDeclaration(...args) { | |
| return (0, _builder.default)("TSNamespaceExportDeclaration", ...args); | |
| } | |
| function TSTypeAnnotation(...args) { | |
| return (0, _builder.default)("TSTypeAnnotation", ...args); | |
| } | |
| function TSTypeParameterInstantiation(...args) { | |
| return (0, _builder.default)("TSTypeParameterInstantiation", ...args); | |
| } | |
| function TSTypeParameterDeclaration(...args) { | |
| return (0, _builder.default)("TSTypeParameterDeclaration", ...args); | |
| } | |
| function TSTypeParameter(...args) { | |
| return (0, _builder.default)("TSTypeParameter", ...args); | |
| } | |
| function NumberLiteral(...args) { | |
| console.trace("The node type NumberLiteral has been renamed to NumericLiteral"); | |
| return NumberLiteral("NumberLiteral", ...args); | |
| } | |
| function RegexLiteral(...args) { | |
| console.trace("The node type RegexLiteral has been renamed to RegExpLiteral"); | |
| return RegexLiteral("RegexLiteral", ...args); | |
| } | |
| function RestProperty(...args) { | |
| console.trace("The node type RestProperty has been renamed to RestElement"); | |
| return RestProperty("RestProperty", ...args); | |
| } | |
| function SpreadProperty(...args) { | |
| console.trace("The node type SpreadProperty has been renamed to SpreadElement"); | |
| return SpreadProperty("SpreadProperty", ...args); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/builders/react/buildChildren.js": | |
| /*!****************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/builders/react/buildChildren.js ***! | |
| \****************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = buildChildren; | |
| var _generated = __webpack_require__(/*! ../../validators/generated */ "../babel-generator/node_modules/@babel/types/lib/validators/generated/index.js"); | |
| var _cleanJSXElementLiteralChild = _interopRequireDefault(__webpack_require__(/*! ../../utils/react/cleanJSXElementLiteralChild */ "../babel-generator/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function buildChildren(node) { | |
| const elements = []; | |
| for (let i = 0; i < node.children.length; i++) { | |
| let child = node.children[i]; | |
| if ((0, _generated.isJSXText)(child)) { | |
| (0, _cleanJSXElementLiteralChild.default)(child, elements); | |
| continue; | |
| } | |
| if ((0, _generated.isJSXExpressionContainer)(child)) child = child.expression; | |
| if ((0, _generated.isJSXEmptyExpression)(child)) continue; | |
| elements.push(child); | |
| } | |
| return elements; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/clone/clone.js": | |
| /*!***********************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/clone/clone.js ***! | |
| \***********************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = clone; | |
| var _cloneNode = _interopRequireDefault(__webpack_require__(/*! ./cloneNode */ "../babel-generator/node_modules/@babel/types/lib/clone/cloneNode.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function clone(node) { | |
| return (0, _cloneNode.default)(node, false); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/clone/cloneDeep.js": | |
| /*!***************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/clone/cloneDeep.js ***! | |
| \***************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = cloneDeep; | |
| var _cloneNode = _interopRequireDefault(__webpack_require__(/*! ./cloneNode */ "../babel-generator/node_modules/@babel/types/lib/clone/cloneNode.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function cloneDeep(node) { | |
| return (0, _cloneNode.default)(node); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/clone/cloneNode.js": | |
| /*!***************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/clone/cloneNode.js ***! | |
| \***************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = cloneNode; | |
| var _definitions = __webpack_require__(/*! ../definitions */ "../babel-generator/node_modules/@babel/types/lib/definitions/index.js"); | |
| const has = Function.call.bind(Object.prototype.hasOwnProperty); | |
| function cloneIfNode(obj, deep) { | |
| if (obj && typeof obj.type === "string" && obj.type !== "CommentLine" && obj.type !== "CommentBlock") { | |
| return cloneNode(obj, deep); | |
| } | |
| return obj; | |
| } | |
| function cloneIfNodeOrArray(obj, deep) { | |
| if (Array.isArray(obj)) { | |
| return obj.map(node => cloneIfNode(node, deep)); | |
| } | |
| return cloneIfNode(obj, deep); | |
| } | |
| function cloneNode(node, deep = true) { | |
| if (!node) return node; | |
| const { | |
| type | |
| } = node; | |
| const newNode = { | |
| type | |
| }; | |
| if (type === "Identifier") { | |
| newNode.name = node.name; | |
| if (has(node, "optional") && typeof node.optional === "boolean") { | |
| newNode.optional = node.optional; | |
| } | |
| if (has(node, "typeAnnotation")) { | |
| newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true) : node.typeAnnotation; | |
| } | |
| } else if (!has(_definitions.NODE_FIELDS, type)) { | |
| throw new Error(`Unknown node type: "${type}"`); | |
| } else { | |
| for (const field of Object.keys(_definitions.NODE_FIELDS[type])) { | |
| if (has(node, field)) { | |
| newNode[field] = deep ? cloneIfNodeOrArray(node[field], true) : node[field]; | |
| } | |
| } | |
| } | |
| if (has(node, "loc")) { | |
| newNode.loc = node.loc; | |
| } | |
| if (has(node, "leadingComments")) { | |
| newNode.leadingComments = node.leadingComments; | |
| } | |
| if (has(node, "innerComments")) { | |
| newNode.innerComments = node.innerComments; | |
| } | |
| if (has(node, "trailingComments")) { | |
| newNode.trailingComments = node.trailingComments; | |
| } | |
| if (has(node, "extra")) { | |
| newNode.extra = Object.assign({}, node.extra); | |
| } | |
| return newNode; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js": | |
| /*!*********************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js ***! | |
| \*********************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = cloneWithoutLoc; | |
| var _clone = _interopRequireDefault(__webpack_require__(/*! ./clone */ "../babel-generator/node_modules/@babel/types/lib/clone/clone.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function cloneWithoutLoc(node) { | |
| const newNode = (0, _clone.default)(node); | |
| newNode.loc = null; | |
| return newNode; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/comments/addComment.js": | |
| /*!*******************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/comments/addComment.js ***! | |
| \*******************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = addComment; | |
| var _addComments = _interopRequireDefault(__webpack_require__(/*! ./addComments */ "../babel-generator/node_modules/@babel/types/lib/comments/addComments.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function addComment(node, type, content, line) { | |
| return (0, _addComments.default)(node, type, [{ | |
| type: line ? "CommentLine" : "CommentBlock", | |
| value: content | |
| }]); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/comments/addComments.js": | |
| /*!********************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/comments/addComments.js ***! | |
| \********************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = addComments; | |
| function addComments(node, type, comments) { | |
| if (!comments || !node) return node; | |
| const key = `${type}Comments`; | |
| if (node[key]) { | |
| if (type === "leading") { | |
| node[key] = comments.concat(node[key]); | |
| } else { | |
| node[key] = node[key].concat(comments); | |
| } | |
| } else { | |
| node[key] = comments; | |
| } | |
| return node; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/comments/inheritInnerComments.js": | |
| /*!*****************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/comments/inheritInnerComments.js ***! | |
| \*****************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = inheritInnerComments; | |
| var _inherit = _interopRequireDefault(__webpack_require__(/*! ../utils/inherit */ "../babel-generator/node_modules/@babel/types/lib/utils/inherit.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function inheritInnerComments(child, parent) { | |
| (0, _inherit.default)("innerComments", child, parent); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/comments/inheritLeadingComments.js": | |
| /*!*******************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/comments/inheritLeadingComments.js ***! | |
| \*******************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = inheritLeadingComments; | |
| var _inherit = _interopRequireDefault(__webpack_require__(/*! ../utils/inherit */ "../babel-generator/node_modules/@babel/types/lib/utils/inherit.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function inheritLeadingComments(child, parent) { | |
| (0, _inherit.default)("leadingComments", child, parent); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/comments/inheritTrailingComments.js": | |
| /*!********************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/comments/inheritTrailingComments.js ***! | |
| \********************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = inheritTrailingComments; | |
| var _inherit = _interopRequireDefault(__webpack_require__(/*! ../utils/inherit */ "../babel-generator/node_modules/@babel/types/lib/utils/inherit.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function inheritTrailingComments(child, parent) { | |
| (0, _inherit.default)("trailingComments", child, parent); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/comments/inheritsComments.js": | |
| /*!*************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/comments/inheritsComments.js ***! | |
| \*************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = inheritsComments; | |
| var _inheritTrailingComments = _interopRequireDefault(__webpack_require__(/*! ./inheritTrailingComments */ "../babel-generator/node_modules/@babel/types/lib/comments/inheritTrailingComments.js")); | |
| var _inheritLeadingComments = _interopRequireDefault(__webpack_require__(/*! ./inheritLeadingComments */ "../babel-generator/node_modules/@babel/types/lib/comments/inheritLeadingComments.js")); | |
| var _inheritInnerComments = _interopRequireDefault(__webpack_require__(/*! ./inheritInnerComments */ "../babel-generator/node_modules/@babel/types/lib/comments/inheritInnerComments.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function inheritsComments(child, parent) { | |
| (0, _inheritTrailingComments.default)(child, parent); | |
| (0, _inheritLeadingComments.default)(child, parent); | |
| (0, _inheritInnerComments.default)(child, parent); | |
| return child; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/comments/removeComments.js": | |
| /*!***********************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/comments/removeComments.js ***! | |
| \***********************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = removeComments; | |
| var _constants = __webpack_require__(/*! ../constants */ "../babel-generator/node_modules/@babel/types/lib/constants/index.js"); | |
| function removeComments(node) { | |
| _constants.COMMENT_KEYS.forEach(key => { | |
| node[key] = null; | |
| }); | |
| return node; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/constants/generated/index.js": | |
| /*!*************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/constants/generated/index.js ***! | |
| \*************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.PRIVATE_TYPES = exports.JSX_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.FLOWTYPE_TYPES = exports.FLOW_TYPES = exports.MODULESPECIFIER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.MODULEDECLARATION_TYPES = exports.CLASS_TYPES = exports.PATTERN_TYPES = exports.UNARYLIKE_TYPES = exports.PROPERTY_TYPES = exports.OBJECTMEMBER_TYPES = exports.METHOD_TYPES = exports.USERWHITESPACABLE_TYPES = exports.IMMUTABLE_TYPES = exports.LITERAL_TYPES = exports.TSENTITYNAME_TYPES = exports.LVAL_TYPES = exports.PATTERNLIKE_TYPES = exports.DECLARATION_TYPES = exports.PUREISH_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FUNCTION_TYPES = exports.FORXSTATEMENT_TYPES = exports.FOR_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.WHILE_TYPES = exports.LOOP_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.SCOPABLE_TYPES = exports.BINARY_TYPES = exports.EXPRESSION_TYPES = void 0; | |
| var _definitions = __webpack_require__(/*! ../../definitions */ "../babel-generator/node_modules/@babel/types/lib/definitions/index.js"); | |
| const EXPRESSION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Expression"]; | |
| exports.EXPRESSION_TYPES = EXPRESSION_TYPES; | |
| const BINARY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Binary"]; | |
| exports.BINARY_TYPES = BINARY_TYPES; | |
| const SCOPABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Scopable"]; | |
| exports.SCOPABLE_TYPES = SCOPABLE_TYPES; | |
| const BLOCKPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["BlockParent"]; | |
| exports.BLOCKPARENT_TYPES = BLOCKPARENT_TYPES; | |
| const BLOCK_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Block"]; | |
| exports.BLOCK_TYPES = BLOCK_TYPES; | |
| const STATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Statement"]; | |
| exports.STATEMENT_TYPES = STATEMENT_TYPES; | |
| const TERMINATORLESS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Terminatorless"]; | |
| exports.TERMINATORLESS_TYPES = TERMINATORLESS_TYPES; | |
| const COMPLETIONSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["CompletionStatement"]; | |
| exports.COMPLETIONSTATEMENT_TYPES = COMPLETIONSTATEMENT_TYPES; | |
| const CONDITIONAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Conditional"]; | |
| exports.CONDITIONAL_TYPES = CONDITIONAL_TYPES; | |
| const LOOP_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Loop"]; | |
| exports.LOOP_TYPES = LOOP_TYPES; | |
| const WHILE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["While"]; | |
| exports.WHILE_TYPES = WHILE_TYPES; | |
| const EXPRESSIONWRAPPER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExpressionWrapper"]; | |
| exports.EXPRESSIONWRAPPER_TYPES = EXPRESSIONWRAPPER_TYPES; | |
| const FOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["For"]; | |
| exports.FOR_TYPES = FOR_TYPES; | |
| const FORXSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ForXStatement"]; | |
| exports.FORXSTATEMENT_TYPES = FORXSTATEMENT_TYPES; | |
| const FUNCTION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Function"]; | |
| exports.FUNCTION_TYPES = FUNCTION_TYPES; | |
| const FUNCTIONPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FunctionParent"]; | |
| exports.FUNCTIONPARENT_TYPES = FUNCTIONPARENT_TYPES; | |
| const PUREISH_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pureish"]; | |
| exports.PUREISH_TYPES = PUREISH_TYPES; | |
| const DECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Declaration"]; | |
| exports.DECLARATION_TYPES = DECLARATION_TYPES; | |
| const PATTERNLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["PatternLike"]; | |
| exports.PATTERNLIKE_TYPES = PATTERNLIKE_TYPES; | |
| const LVAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["LVal"]; | |
| exports.LVAL_TYPES = LVAL_TYPES; | |
| const TSENTITYNAME_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSEntityName"]; | |
| exports.TSENTITYNAME_TYPES = TSENTITYNAME_TYPES; | |
| const LITERAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Literal"]; | |
| exports.LITERAL_TYPES = LITERAL_TYPES; | |
| const IMMUTABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Immutable"]; | |
| exports.IMMUTABLE_TYPES = IMMUTABLE_TYPES; | |
| const USERWHITESPACABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UserWhitespacable"]; | |
| exports.USERWHITESPACABLE_TYPES = USERWHITESPACABLE_TYPES; | |
| const METHOD_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Method"]; | |
| exports.METHOD_TYPES = METHOD_TYPES; | |
| const OBJECTMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ObjectMember"]; | |
| exports.OBJECTMEMBER_TYPES = OBJECTMEMBER_TYPES; | |
| const PROPERTY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Property"]; | |
| exports.PROPERTY_TYPES = PROPERTY_TYPES; | |
| const UNARYLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UnaryLike"]; | |
| exports.UNARYLIKE_TYPES = UNARYLIKE_TYPES; | |
| const PATTERN_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pattern"]; | |
| exports.PATTERN_TYPES = PATTERN_TYPES; | |
| const CLASS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Class"]; | |
| exports.CLASS_TYPES = CLASS_TYPES; | |
| const MODULEDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleDeclaration"]; | |
| exports.MODULEDECLARATION_TYPES = MODULEDECLARATION_TYPES; | |
| const EXPORTDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExportDeclaration"]; | |
| exports.EXPORTDECLARATION_TYPES = EXPORTDECLARATION_TYPES; | |
| const MODULESPECIFIER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleSpecifier"]; | |
| exports.MODULESPECIFIER_TYPES = MODULESPECIFIER_TYPES; | |
| const FLOW_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Flow"]; | |
| exports.FLOW_TYPES = FLOW_TYPES; | |
| const FLOWTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowType"]; | |
| exports.FLOWTYPE_TYPES = FLOWTYPE_TYPES; | |
| const FLOWBASEANNOTATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"]; | |
| exports.FLOWBASEANNOTATION_TYPES = FLOWBASEANNOTATION_TYPES; | |
| const FLOWDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowDeclaration"]; | |
| exports.FLOWDECLARATION_TYPES = FLOWDECLARATION_TYPES; | |
| const FLOWPREDICATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowPredicate"]; | |
| exports.FLOWPREDICATE_TYPES = FLOWPREDICATE_TYPES; | |
| const JSX_TYPES = _definitions.FLIPPED_ALIAS_KEYS["JSX"]; | |
| exports.JSX_TYPES = JSX_TYPES; | |
| const PRIVATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Private"]; | |
| exports.PRIVATE_TYPES = PRIVATE_TYPES; | |
| const TSTYPEELEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSTypeElement"]; | |
| exports.TSTYPEELEMENT_TYPES = TSTYPEELEMENT_TYPES; | |
| const TSTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSType"]; | |
| exports.TSTYPE_TYPES = TSTYPE_TYPES; | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/constants/index.js": | |
| /*!***************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/constants/index.js ***! | |
| \***************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.NOT_LOCAL_BINDING = exports.BLOCK_SCOPED_SYMBOL = exports.INHERIT_KEYS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = exports.BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.UPDATE_OPERATORS = exports.LOGICAL_OPERATORS = exports.COMMENT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = void 0; | |
| const STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"]; | |
| exports.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS; | |
| const FLATTENABLE_KEYS = ["body", "expressions"]; | |
| exports.FLATTENABLE_KEYS = FLATTENABLE_KEYS; | |
| const FOR_INIT_KEYS = ["left", "init"]; | |
| exports.FOR_INIT_KEYS = FOR_INIT_KEYS; | |
| const COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"]; | |
| exports.COMMENT_KEYS = COMMENT_KEYS; | |
| const LOGICAL_OPERATORS = ["||", "&&", "??"]; | |
| exports.LOGICAL_OPERATORS = LOGICAL_OPERATORS; | |
| const UPDATE_OPERATORS = ["++", "--"]; | |
| exports.UPDATE_OPERATORS = UPDATE_OPERATORS; | |
| const BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="]; | |
| exports.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS; | |
| const EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="]; | |
| exports.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS; | |
| const COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"]; | |
| exports.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS; | |
| const BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS]; | |
| exports.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS; | |
| const NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"]; | |
| exports.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS; | |
| const BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS]; | |
| exports.BINARY_OPERATORS = BINARY_OPERATORS; | |
| const BOOLEAN_UNARY_OPERATORS = ["delete", "!"]; | |
| exports.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS; | |
| const NUMBER_UNARY_OPERATORS = ["+", "-", "~"]; | |
| exports.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS; | |
| const STRING_UNARY_OPERATORS = ["typeof"]; | |
| exports.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS; | |
| const UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS]; | |
| exports.UNARY_OPERATORS = UNARY_OPERATORS; | |
| const INHERIT_KEYS = { | |
| optional: ["typeAnnotation", "typeParameters", "returnType"], | |
| force: ["start", "loc", "end"] | |
| }; | |
| exports.INHERIT_KEYS = INHERIT_KEYS; | |
| const BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped"); | |
| exports.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL; | |
| const NOT_LOCAL_BINDING = Symbol.for("should not be considered a local binding"); | |
| exports.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING; | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/converters/ensureBlock.js": | |
| /*!**********************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/converters/ensureBlock.js ***! | |
| \**********************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = ensureBlock; | |
| var _toBlock = _interopRequireDefault(__webpack_require__(/*! ./toBlock */ "../babel-generator/node_modules/@babel/types/lib/converters/toBlock.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function ensureBlock(node, key = "body") { | |
| return node[key] = (0, _toBlock.default)(node[key], node); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js": | |
| /*!************************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js ***! | |
| \************************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = gatherSequenceExpressions; | |
| var _getBindingIdentifiers = _interopRequireDefault(__webpack_require__(/*! ../retrievers/getBindingIdentifiers */ "../babel-generator/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js")); | |
| var _generated = __webpack_require__(/*! ../validators/generated */ "../babel-generator/node_modules/@babel/types/lib/validators/generated/index.js"); | |
| var _generated2 = __webpack_require__(/*! ../builders/generated */ "../babel-generator/node_modules/@babel/types/lib/builders/generated/index.js"); | |
| var _cloneNode = _interopRequireDefault(__webpack_require__(/*! ../clone/cloneNode */ "../babel-generator/node_modules/@babel/types/lib/clone/cloneNode.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function gatherSequenceExpressions(nodes, scope, declars) { | |
| const exprs = []; | |
| let ensureLastUndefined = true; | |
| for (const node of nodes) { | |
| ensureLastUndefined = false; | |
| if ((0, _generated.isExpression)(node)) { | |
| exprs.push(node); | |
| } else if ((0, _generated.isExpressionStatement)(node)) { | |
| exprs.push(node.expression); | |
| } else if ((0, _generated.isVariableDeclaration)(node)) { | |
| if (node.kind !== "var") return; | |
| for (const declar of node.declarations) { | |
| const bindings = (0, _getBindingIdentifiers.default)(declar); | |
| for (const key of Object.keys(bindings)) { | |
| declars.push({ | |
| kind: node.kind, | |
| id: (0, _cloneNode.default)(bindings[key]) | |
| }); | |
| } | |
| if (declar.init) { | |
| exprs.push((0, _generated2.assignmentExpression)("=", declar.id, declar.init)); | |
| } | |
| } | |
| ensureLastUndefined = true; | |
| } else if ((0, _generated.isIfStatement)(node)) { | |
| const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope, declars) : scope.buildUndefinedNode(); | |
| const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode(); | |
| if (!consequent || !alternate) return; | |
| exprs.push((0, _generated2.conditionalExpression)(node.test, consequent, alternate)); | |
| } else if ((0, _generated.isBlockStatement)(node)) { | |
| const body = gatherSequenceExpressions(node.body, scope, declars); | |
| if (!body) return; | |
| exprs.push(body); | |
| } else if ((0, _generated.isEmptyStatement)(node)) { | |
| ensureLastUndefined = true; | |
| } else { | |
| return; | |
| } | |
| } | |
| if (ensureLastUndefined) { | |
| exprs.push(scope.buildUndefinedNode()); | |
| } | |
| if (exprs.length === 1) { | |
| return exprs[0]; | |
| } else { | |
| return (0, _generated2.sequenceExpression)(exprs); | |
| } | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/converters/toBindingIdentifierName.js": | |
| /*!**********************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/converters/toBindingIdentifierName.js ***! | |
| \**********************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = toBindingIdentifierName; | |
| var _toIdentifier = _interopRequireDefault(__webpack_require__(/*! ./toIdentifier */ "../babel-generator/node_modules/@babel/types/lib/converters/toIdentifier.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function toBindingIdentifierName(name) { | |
| name = (0, _toIdentifier.default)(name); | |
| if (name === "eval" || name === "arguments") name = "_" + name; | |
| return name; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/converters/toBlock.js": | |
| /*!******************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/converters/toBlock.js ***! | |
| \******************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = toBlock; | |
| var _generated = __webpack_require__(/*! ../validators/generated */ "../babel-generator/node_modules/@babel/types/lib/validators/generated/index.js"); | |
| var _generated2 = __webpack_require__(/*! ../builders/generated */ "../babel-generator/node_modules/@babel/types/lib/builders/generated/index.js"); | |
| function toBlock(node, parent) { | |
| if ((0, _generated.isBlockStatement)(node)) { | |
| return node; | |
| } | |
| let blockNodes = []; | |
| if ((0, _generated.isEmptyStatement)(node)) { | |
| blockNodes = []; | |
| } else { | |
| if (!(0, _generated.isStatement)(node)) { | |
| if ((0, _generated.isFunction)(parent)) { | |
| node = (0, _generated2.returnStatement)(node); | |
| } else { | |
| node = (0, _generated2.expressionStatement)(node); | |
| } | |
| } | |
| blockNodes = [node]; | |
| } | |
| return (0, _generated2.blockStatement)(blockNodes); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/converters/toComputedKey.js": | |
| /*!************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/converters/toComputedKey.js ***! | |
| \************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = toComputedKey; | |
| var _generated = __webpack_require__(/*! ../validators/generated */ "../babel-generator/node_modules/@babel/types/lib/validators/generated/index.js"); | |
| var _generated2 = __webpack_require__(/*! ../builders/generated */ "../babel-generator/node_modules/@babel/types/lib/builders/generated/index.js"); | |
| function toComputedKey(node, key = node.key || node.property) { | |
| if (!node.computed && (0, _generated.isIdentifier)(key)) key = (0, _generated2.stringLiteral)(key.name); | |
| return key; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/converters/toExpression.js": | |
| /*!***********************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/converters/toExpression.js ***! | |
| \***********************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = toExpression; | |
| var _generated = __webpack_require__(/*! ../validators/generated */ "../babel-generator/node_modules/@babel/types/lib/validators/generated/index.js"); | |
| function toExpression(node) { | |
| if ((0, _generated.isExpressionStatement)(node)) { | |
| node = node.expression; | |
| } | |
| if ((0, _generated.isExpression)(node)) { | |
| return node; | |
| } | |
| if ((0, _generated.isClass)(node)) { | |
| node.type = "ClassExpression"; | |
| } else if ((0, _generated.isFunction)(node)) { | |
| node.type = "FunctionExpression"; | |
| } | |
| if (!(0, _generated.isExpression)(node)) { | |
| throw new Error(`cannot turn ${node.type} to an expression`); | |
| } | |
| return node; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/converters/toIdentifier.js": | |
| /*!***********************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/converters/toIdentifier.js ***! | |
| \***********************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = toIdentifier; | |
| var _isValidIdentifier = _interopRequireDefault(__webpack_require__(/*! ../validators/isValidIdentifier */ "../babel-generator/node_modules/@babel/types/lib/validators/isValidIdentifier.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function toIdentifier(name) { | |
| name = name + ""; | |
| name = name.replace(/[^a-zA-Z0-9$_]/g, "-"); | |
| name = name.replace(/^[-0-9]+/, ""); | |
| name = name.replace(/[-\s]+(.)?/g, function (match, c) { | |
| return c ? c.toUpperCase() : ""; | |
| }); | |
| if (!(0, _isValidIdentifier.default)(name)) { | |
| name = `_${name}`; | |
| } | |
| return name || "_"; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/converters/toKeyAlias.js": | |
| /*!*********************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/converters/toKeyAlias.js ***! | |
| \*********************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = toKeyAlias; | |
| var _generated = __webpack_require__(/*! ../validators/generated */ "../babel-generator/node_modules/@babel/types/lib/validators/generated/index.js"); | |
| var _cloneNode = _interopRequireDefault(__webpack_require__(/*! ../clone/cloneNode */ "../babel-generator/node_modules/@babel/types/lib/clone/cloneNode.js")); | |
| var _removePropertiesDeep = _interopRequireDefault(__webpack_require__(/*! ../modifications/removePropertiesDeep */ "../babel-generator/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function toKeyAlias(node, key = node.key) { | |
| let alias; | |
| if (node.kind === "method") { | |
| return toKeyAlias.increment() + ""; | |
| } else if ((0, _generated.isIdentifier)(key)) { | |
| alias = key.name; | |
| } else if ((0, _generated.isStringLiteral)(key)) { | |
| alias = JSON.stringify(key.value); | |
| } else { | |
| alias = JSON.stringify((0, _removePropertiesDeep.default)((0, _cloneNode.default)(key))); | |
| } | |
| if (node.computed) { | |
| alias = `[${alias}]`; | |
| } | |
| if (node.static) { | |
| alias = `static:${alias}`; | |
| } | |
| return alias; | |
| } | |
| toKeyAlias.uid = 0; | |
| toKeyAlias.increment = function () { | |
| if (toKeyAlias.uid >= Number.MAX_SAFE_INTEGER) { | |
| return toKeyAlias.uid = 0; | |
| } else { | |
| return toKeyAlias.uid++; | |
| } | |
| }; | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/converters/toSequenceExpression.js": | |
| /*!*******************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/converters/toSequenceExpression.js ***! | |
| \*******************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = toSequenceExpression; | |
| var _gatherSequenceExpressions = _interopRequireDefault(__webpack_require__(/*! ./gatherSequenceExpressions */ "../babel-generator/node_modules/@babel/types/lib/converters/gatherSequenceExpressions.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function toSequenceExpression(nodes, scope) { | |
| if (!nodes || !nodes.length) return; | |
| const declars = []; | |
| const result = (0, _gatherSequenceExpressions.default)(nodes, scope, declars); | |
| if (!result) return; | |
| for (const declar of declars) { | |
| scope.push(declar); | |
| } | |
| return result; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/converters/toStatement.js": | |
| /*!**********************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/converters/toStatement.js ***! | |
| \**********************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = toStatement; | |
| var _generated = __webpack_require__(/*! ../validators/generated */ "../babel-generator/node_modules/@babel/types/lib/validators/generated/index.js"); | |
| var _generated2 = __webpack_require__(/*! ../builders/generated */ "../babel-generator/node_modules/@babel/types/lib/builders/generated/index.js"); | |
| function toStatement(node, ignore) { | |
| if ((0, _generated.isStatement)(node)) { | |
| return node; | |
| } | |
| let mustHaveId = false; | |
| let newType; | |
| if ((0, _generated.isClass)(node)) { | |
| mustHaveId = true; | |
| newType = "ClassDeclaration"; | |
| } else if ((0, _generated.isFunction)(node)) { | |
| mustHaveId = true; | |
| newType = "FunctionDeclaration"; | |
| } else if ((0, _generated.isAssignmentExpression)(node)) { | |
| return (0, _generated2.expressionStatement)(node); | |
| } | |
| if (mustHaveId && !node.id) { | |
| newType = false; | |
| } | |
| if (!newType) { | |
| if (ignore) { | |
| return false; | |
| } else { | |
| throw new Error(`cannot turn ${node.type} to a statement`); | |
| } | |
| } | |
| node.type = newType; | |
| return node; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/converters/valueToNode.js": | |
| /*!**********************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/converters/valueToNode.js ***! | |
| \**********************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = valueToNode; | |
| function _isPlainObject() { | |
| const data = _interopRequireDefault(__webpack_require__(/*! lodash/isPlainObject */ "../babel-generator/node_modules/lodash/isPlainObject.js")); | |
| _isPlainObject = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function _isRegExp() { | |
| const data = _interopRequireDefault(__webpack_require__(/*! lodash/isRegExp */ "../babel-generator/node_modules/lodash/isRegExp.js")); | |
| _isRegExp = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| var _isValidIdentifier = _interopRequireDefault(__webpack_require__(/*! ../validators/isValidIdentifier */ "../babel-generator/node_modules/@babel/types/lib/validators/isValidIdentifier.js")); | |
| var _generated = __webpack_require__(/*! ../builders/generated */ "../babel-generator/node_modules/@babel/types/lib/builders/generated/index.js"); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function valueToNode(value) { | |
| if (value === undefined) { | |
| return (0, _generated.identifier)("undefined"); | |
| } | |
| if (value === true || value === false) { | |
| return (0, _generated.booleanLiteral)(value); | |
| } | |
| if (value === null) { | |
| return (0, _generated.nullLiteral)(); | |
| } | |
| if (typeof value === "string") { | |
| return (0, _generated.stringLiteral)(value); | |
| } | |
| if (typeof value === "number") { | |
| let result; | |
| if (Number.isFinite(value)) { | |
| result = (0, _generated.numericLiteral)(Math.abs(value)); | |
| } else { | |
| let numerator; | |
| if (Number.isNaN(value)) { | |
| numerator = (0, _generated.numericLiteral)(0); | |
| } else { | |
| numerator = (0, _generated.numericLiteral)(1); | |
| } | |
| result = (0, _generated.binaryExpression)("/", numerator, (0, _generated.numericLiteral)(0)); | |
| } | |
| if (value < 0 || Object.is(value, -0)) { | |
| result = (0, _generated.unaryExpression)("-", result); | |
| } | |
| return result; | |
| } | |
| if ((0, _isRegExp().default)(value)) { | |
| const pattern = value.source; | |
| const flags = value.toString().match(/\/([a-z]+|)$/)[1]; | |
| return (0, _generated.regExpLiteral)(pattern, flags); | |
| } | |
| if (Array.isArray(value)) { | |
| return (0, _generated.arrayExpression)(value.map(valueToNode)); | |
| } | |
| if ((0, _isPlainObject().default)(value)) { | |
| const props = []; | |
| for (const key of Object.keys(value)) { | |
| let nodeKey; | |
| if ((0, _isValidIdentifier.default)(key)) { | |
| nodeKey = (0, _generated.identifier)(key); | |
| } else { | |
| nodeKey = (0, _generated.stringLiteral)(key); | |
| } | |
| props.push((0, _generated.objectProperty)(nodeKey, valueToNode(value[key]))); | |
| } | |
| return (0, _generated.objectExpression)(props); | |
| } | |
| throw new Error("don't know how to turn this value into a node"); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/definitions/core.js": | |
| /*!****************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/definitions/core.js ***! | |
| \****************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.patternLikeCommon = exports.functionDeclarationCommon = exports.functionTypeAnnotationCommon = exports.functionCommon = void 0; | |
| var _isValidIdentifier = _interopRequireDefault(__webpack_require__(/*! ../validators/isValidIdentifier */ "../babel-generator/node_modules/@babel/types/lib/validators/isValidIdentifier.js")); | |
| var _constants = __webpack_require__(/*! ../constants */ "../babel-generator/node_modules/@babel/types/lib/constants/index.js"); | |
| var _utils = _interopRequireWildcard(__webpack_require__(/*! ./utils */ "../babel-generator/node_modules/@babel/types/lib/definitions/utils.js")); | |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| (0, _utils.default)("ArrayExpression", { | |
| fields: { | |
| elements: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))), | |
| default: [] | |
| } | |
| }, | |
| visitor: ["elements"], | |
| aliases: ["Expression"] | |
| }); | |
| (0, _utils.default)("AssignmentExpression", { | |
| fields: { | |
| operator: { | |
| validate: (0, _utils.assertValueType)("string") | |
| }, | |
| left: { | |
| validate: (0, _utils.assertNodeType)("LVal") | |
| }, | |
| right: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| }, | |
| builder: ["operator", "left", "right"], | |
| visitor: ["left", "right"], | |
| aliases: ["Expression"] | |
| }); | |
| (0, _utils.default)("BinaryExpression", { | |
| builder: ["operator", "left", "right"], | |
| fields: { | |
| operator: { | |
| validate: (0, _utils.assertOneOf)(..._constants.BINARY_OPERATORS) | |
| }, | |
| left: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| right: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| }, | |
| visitor: ["left", "right"], | |
| aliases: ["Binary", "Expression"] | |
| }); | |
| (0, _utils.default)("InterpreterDirective", { | |
| builder: ["value"], | |
| fields: { | |
| value: { | |
| validate: (0, _utils.assertValueType)("string") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("Directive", { | |
| visitor: ["value"], | |
| fields: { | |
| value: { | |
| validate: (0, _utils.assertNodeType)("DirectiveLiteral") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("DirectiveLiteral", { | |
| builder: ["value"], | |
| fields: { | |
| value: { | |
| validate: (0, _utils.assertValueType)("string") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("BlockStatement", { | |
| builder: ["body", "directives"], | |
| visitor: ["directives", "body"], | |
| fields: { | |
| directives: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))), | |
| default: [] | |
| }, | |
| body: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) | |
| } | |
| }, | |
| aliases: ["Scopable", "BlockParent", "Block", "Statement"] | |
| }); | |
| (0, _utils.default)("BreakStatement", { | |
| visitor: ["label"], | |
| fields: { | |
| label: { | |
| validate: (0, _utils.assertNodeType)("Identifier"), | |
| optional: true | |
| } | |
| }, | |
| aliases: ["Statement", "Terminatorless", "CompletionStatement"] | |
| }); | |
| (0, _utils.default)("CallExpression", { | |
| visitor: ["callee", "arguments", "typeParameters", "typeArguments"], | |
| builder: ["callee", "arguments"], | |
| aliases: ["Expression"], | |
| fields: { | |
| callee: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| arguments: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder"))) | |
| }, | |
| optional: { | |
| validate: (0, _utils.assertOneOf)(true, false), | |
| optional: true | |
| }, | |
| typeArguments: { | |
| validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"), | |
| optional: true | |
| }, | |
| typeParameters: { | |
| validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"), | |
| optional: true | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("CatchClause", { | |
| visitor: ["param", "body"], | |
| fields: { | |
| param: { | |
| validate: (0, _utils.assertNodeType)("Identifier"), | |
| optional: true | |
| }, | |
| body: { | |
| validate: (0, _utils.assertNodeType)("BlockStatement") | |
| } | |
| }, | |
| aliases: ["Scopable", "BlockParent"] | |
| }); | |
| (0, _utils.default)("ConditionalExpression", { | |
| visitor: ["test", "consequent", "alternate"], | |
| fields: { | |
| test: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| consequent: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| alternate: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| }, | |
| aliases: ["Expression", "Conditional"] | |
| }); | |
| (0, _utils.default)("ContinueStatement", { | |
| visitor: ["label"], | |
| fields: { | |
| label: { | |
| validate: (0, _utils.assertNodeType)("Identifier"), | |
| optional: true | |
| } | |
| }, | |
| aliases: ["Statement", "Terminatorless", "CompletionStatement"] | |
| }); | |
| (0, _utils.default)("DebuggerStatement", { | |
| aliases: ["Statement"] | |
| }); | |
| (0, _utils.default)("DoWhileStatement", { | |
| visitor: ["test", "body"], | |
| fields: { | |
| test: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| body: { | |
| validate: (0, _utils.assertNodeType)("Statement") | |
| } | |
| }, | |
| aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"] | |
| }); | |
| (0, _utils.default)("EmptyStatement", { | |
| aliases: ["Statement"] | |
| }); | |
| (0, _utils.default)("ExpressionStatement", { | |
| visitor: ["expression"], | |
| fields: { | |
| expression: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| }, | |
| aliases: ["Statement", "ExpressionWrapper"] | |
| }); | |
| (0, _utils.default)("File", { | |
| builder: ["program", "comments", "tokens"], | |
| visitor: ["program"], | |
| fields: { | |
| program: { | |
| validate: (0, _utils.assertNodeType)("Program") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ForInStatement", { | |
| visitor: ["left", "right", "body"], | |
| aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"], | |
| fields: { | |
| left: { | |
| validate: (0, _utils.assertNodeType)("VariableDeclaration", "LVal") | |
| }, | |
| right: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| body: { | |
| validate: (0, _utils.assertNodeType)("Statement") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ForStatement", { | |
| visitor: ["init", "test", "update", "body"], | |
| aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"], | |
| fields: { | |
| init: { | |
| validate: (0, _utils.assertNodeType)("VariableDeclaration", "Expression"), | |
| optional: true | |
| }, | |
| test: { | |
| validate: (0, _utils.assertNodeType)("Expression"), | |
| optional: true | |
| }, | |
| update: { | |
| validate: (0, _utils.assertNodeType)("Expression"), | |
| optional: true | |
| }, | |
| body: { | |
| validate: (0, _utils.assertNodeType)("Statement") | |
| } | |
| } | |
| }); | |
| const functionCommon = { | |
| params: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty"))) | |
| }, | |
| generator: { | |
| default: false, | |
| validate: (0, _utils.assertValueType)("boolean") | |
| }, | |
| async: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| default: false | |
| } | |
| }; | |
| exports.functionCommon = functionCommon; | |
| const functionTypeAnnotationCommon = { | |
| returnType: { | |
| validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), | |
| optional: true | |
| }, | |
| typeParameters: { | |
| validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), | |
| optional: true | |
| } | |
| }; | |
| exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon; | |
| const functionDeclarationCommon = Object.assign({}, functionCommon, { | |
| declare: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| optional: true | |
| }, | |
| id: { | |
| validate: (0, _utils.assertNodeType)("Identifier"), | |
| optional: true | |
| } | |
| }); | |
| exports.functionDeclarationCommon = functionDeclarationCommon; | |
| (0, _utils.default)("FunctionDeclaration", { | |
| builder: ["id", "params", "body", "generator", "async"], | |
| visitor: ["id", "params", "body", "returnType", "typeParameters"], | |
| fields: Object.assign({}, functionDeclarationCommon, functionTypeAnnotationCommon, { | |
| body: { | |
| validate: (0, _utils.assertNodeType)("BlockStatement") | |
| } | |
| }), | |
| aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"] | |
| }); | |
| (0, _utils.default)("FunctionExpression", { | |
| inherits: "FunctionDeclaration", | |
| aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"], | |
| fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, { | |
| id: { | |
| validate: (0, _utils.assertNodeType)("Identifier"), | |
| optional: true | |
| }, | |
| body: { | |
| validate: (0, _utils.assertNodeType)("BlockStatement") | |
| } | |
| }) | |
| }); | |
| const patternLikeCommon = { | |
| typeAnnotation: { | |
| validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), | |
| optional: true | |
| }, | |
| decorators: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))) | |
| } | |
| }; | |
| exports.patternLikeCommon = patternLikeCommon; | |
| (0, _utils.default)("Identifier", { | |
| builder: ["name"], | |
| visitor: ["typeAnnotation", "decorators"], | |
| aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"], | |
| fields: Object.assign({}, patternLikeCommon, { | |
| name: { | |
| validate: (0, _utils.chain)(function (node, key, val) { | |
| if (!(0, _isValidIdentifier.default)(val)) {} | |
| }, (0, _utils.assertValueType)("string")) | |
| }, | |
| optional: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| optional: true | |
| } | |
| }) | |
| }); | |
| (0, _utils.default)("IfStatement", { | |
| visitor: ["test", "consequent", "alternate"], | |
| aliases: ["Statement", "Conditional"], | |
| fields: { | |
| test: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| consequent: { | |
| validate: (0, _utils.assertNodeType)("Statement") | |
| }, | |
| alternate: { | |
| optional: true, | |
| validate: (0, _utils.assertNodeType)("Statement") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("LabeledStatement", { | |
| visitor: ["label", "body"], | |
| aliases: ["Statement"], | |
| fields: { | |
| label: { | |
| validate: (0, _utils.assertNodeType)("Identifier") | |
| }, | |
| body: { | |
| validate: (0, _utils.assertNodeType)("Statement") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("StringLiteral", { | |
| builder: ["value"], | |
| fields: { | |
| value: { | |
| validate: (0, _utils.assertValueType)("string") | |
| } | |
| }, | |
| aliases: ["Expression", "Pureish", "Literal", "Immutable"] | |
| }); | |
| (0, _utils.default)("NumericLiteral", { | |
| builder: ["value"], | |
| deprecatedAlias: "NumberLiteral", | |
| fields: { | |
| value: { | |
| validate: (0, _utils.assertValueType)("number") | |
| } | |
| }, | |
| aliases: ["Expression", "Pureish", "Literal", "Immutable"] | |
| }); | |
| (0, _utils.default)("NullLiteral", { | |
| aliases: ["Expression", "Pureish", "Literal", "Immutable"] | |
| }); | |
| (0, _utils.default)("BooleanLiteral", { | |
| builder: ["value"], | |
| fields: { | |
| value: { | |
| validate: (0, _utils.assertValueType)("boolean") | |
| } | |
| }, | |
| aliases: ["Expression", "Pureish", "Literal", "Immutable"] | |
| }); | |
| (0, _utils.default)("RegExpLiteral", { | |
| builder: ["pattern", "flags"], | |
| deprecatedAlias: "RegexLiteral", | |
| aliases: ["Expression", "Literal"], | |
| fields: { | |
| pattern: { | |
| validate: (0, _utils.assertValueType)("string") | |
| }, | |
| flags: { | |
| validate: (0, _utils.assertValueType)("string"), | |
| default: "" | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("LogicalExpression", { | |
| builder: ["operator", "left", "right"], | |
| visitor: ["left", "right"], | |
| aliases: ["Binary", "Expression"], | |
| fields: { | |
| operator: { | |
| validate: (0, _utils.assertOneOf)(..._constants.LOGICAL_OPERATORS) | |
| }, | |
| left: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| right: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("MemberExpression", { | |
| builder: ["object", "property", "computed", "optional"], | |
| visitor: ["object", "property"], | |
| aliases: ["Expression", "LVal"], | |
| fields: { | |
| object: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| property: { | |
| validate: function () { | |
| const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName"); | |
| const computed = (0, _utils.assertNodeType)("Expression"); | |
| return function (node, key, val) { | |
| const validator = node.computed ? computed : normal; | |
| validator(node, key, val); | |
| }; | |
| }() | |
| }, | |
| computed: { | |
| default: false | |
| }, | |
| optional: { | |
| validate: (0, _utils.assertOneOf)(true, false), | |
| optional: true | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("NewExpression", { | |
| inherits: "CallExpression" | |
| }); | |
| (0, _utils.default)("Program", { | |
| visitor: ["directives", "body"], | |
| builder: ["body", "directives", "sourceType", "interpreter"], | |
| fields: { | |
| sourceFile: { | |
| validate: (0, _utils.assertValueType)("string") | |
| }, | |
| sourceType: { | |
| validate: (0, _utils.assertOneOf)("script", "module"), | |
| default: "script" | |
| }, | |
| interpreter: { | |
| validate: (0, _utils.assertNodeType)("InterpreterDirective"), | |
| default: null, | |
| optional: true | |
| }, | |
| directives: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))), | |
| default: [] | |
| }, | |
| body: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) | |
| } | |
| }, | |
| aliases: ["Scopable", "BlockParent", "Block"] | |
| }); | |
| (0, _utils.default)("ObjectExpression", { | |
| visitor: ["properties"], | |
| aliases: ["Expression"], | |
| fields: { | |
| properties: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement"))) | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ObjectMethod", { | |
| builder: ["kind", "key", "params", "body", "computed"], | |
| fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, { | |
| kind: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("method", "get", "set")), | |
| default: "method" | |
| }, | |
| computed: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| default: false | |
| }, | |
| key: { | |
| validate: function () { | |
| const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral"); | |
| const computed = (0, _utils.assertNodeType)("Expression"); | |
| return function (node, key, val) { | |
| const validator = node.computed ? computed : normal; | |
| validator(node, key, val); | |
| }; | |
| }() | |
| }, | |
| decorators: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))) | |
| }, | |
| body: { | |
| validate: (0, _utils.assertNodeType)("BlockStatement") | |
| } | |
| }), | |
| visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"], | |
| aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"] | |
| }); | |
| (0, _utils.default)("ObjectProperty", { | |
| builder: ["key", "value", "computed", "shorthand", "decorators"], | |
| fields: { | |
| computed: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| default: false | |
| }, | |
| key: { | |
| validate: function () { | |
| const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral"); | |
| const computed = (0, _utils.assertNodeType)("Expression"); | |
| return function (node, key, val) { | |
| const validator = node.computed ? computed : normal; | |
| validator(node, key, val); | |
| }; | |
| }() | |
| }, | |
| value: { | |
| validate: (0, _utils.assertNodeType)("Expression", "PatternLike") | |
| }, | |
| shorthand: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| default: false | |
| }, | |
| decorators: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), | |
| optional: true | |
| } | |
| }, | |
| visitor: ["key", "value", "decorators"], | |
| aliases: ["UserWhitespacable", "Property", "ObjectMember"] | |
| }); | |
| (0, _utils.default)("RestElement", { | |
| visitor: ["argument", "typeAnnotation"], | |
| builder: ["argument"], | |
| aliases: ["LVal", "PatternLike"], | |
| deprecatedAlias: "RestProperty", | |
| fields: Object.assign({}, patternLikeCommon, { | |
| argument: { | |
| validate: (0, _utils.assertNodeType)("LVal") | |
| } | |
| }) | |
| }); | |
| (0, _utils.default)("ReturnStatement", { | |
| visitor: ["argument"], | |
| aliases: ["Statement", "Terminatorless", "CompletionStatement"], | |
| fields: { | |
| argument: { | |
| validate: (0, _utils.assertNodeType)("Expression"), | |
| optional: true | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("SequenceExpression", { | |
| visitor: ["expressions"], | |
| fields: { | |
| expressions: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression"))) | |
| } | |
| }, | |
| aliases: ["Expression"] | |
| }); | |
| (0, _utils.default)("ParenthesizedExpression", { | |
| visitor: ["expression"], | |
| aliases: ["Expression", "ExpressionWrapper"], | |
| fields: { | |
| expression: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("SwitchCase", { | |
| visitor: ["test", "consequent"], | |
| fields: { | |
| test: { | |
| validate: (0, _utils.assertNodeType)("Expression"), | |
| optional: true | |
| }, | |
| consequent: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement"))) | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("SwitchStatement", { | |
| visitor: ["discriminant", "cases"], | |
| aliases: ["Statement", "BlockParent", "Scopable"], | |
| fields: { | |
| discriminant: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| cases: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("SwitchCase"))) | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ThisExpression", { | |
| aliases: ["Expression"] | |
| }); | |
| (0, _utils.default)("ThrowStatement", { | |
| visitor: ["argument"], | |
| aliases: ["Statement", "Terminatorless", "CompletionStatement"], | |
| fields: { | |
| argument: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("TryStatement", { | |
| visitor: ["block", "handler", "finalizer"], | |
| aliases: ["Statement"], | |
| fields: { | |
| block: { | |
| validate: (0, _utils.assertNodeType)("BlockStatement") | |
| }, | |
| handler: { | |
| optional: true, | |
| validate: (0, _utils.assertNodeType)("CatchClause") | |
| }, | |
| finalizer: { | |
| optional: true, | |
| validate: (0, _utils.assertNodeType)("BlockStatement") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("UnaryExpression", { | |
| builder: ["operator", "argument", "prefix"], | |
| fields: { | |
| prefix: { | |
| default: true | |
| }, | |
| argument: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| operator: { | |
| validate: (0, _utils.assertOneOf)(..._constants.UNARY_OPERATORS) | |
| } | |
| }, | |
| visitor: ["argument"], | |
| aliases: ["UnaryLike", "Expression"] | |
| }); | |
| (0, _utils.default)("UpdateExpression", { | |
| builder: ["operator", "argument", "prefix"], | |
| fields: { | |
| prefix: { | |
| default: false | |
| }, | |
| argument: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| operator: { | |
| validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS) | |
| } | |
| }, | |
| visitor: ["argument"], | |
| aliases: ["Expression"] | |
| }); | |
| (0, _utils.default)("VariableDeclaration", { | |
| builder: ["kind", "declarations"], | |
| visitor: ["declarations"], | |
| aliases: ["Statement", "Declaration"], | |
| fields: { | |
| declare: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| optional: true | |
| }, | |
| kind: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("var", "let", "const")) | |
| }, | |
| declarations: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator"))) | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("VariableDeclarator", { | |
| visitor: ["id", "init"], | |
| fields: { | |
| id: { | |
| validate: (0, _utils.assertNodeType)("LVal") | |
| }, | |
| definite: { | |
| optional: true, | |
| validate: (0, _utils.assertValueType)("boolean") | |
| }, | |
| init: { | |
| optional: true, | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("WhileStatement", { | |
| visitor: ["test", "body"], | |
| aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"], | |
| fields: { | |
| test: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| body: { | |
| validate: (0, _utils.assertNodeType)("BlockStatement", "Statement") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("WithStatement", { | |
| visitor: ["object", "body"], | |
| aliases: ["Statement"], | |
| fields: { | |
| object: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| body: { | |
| validate: (0, _utils.assertNodeType)("BlockStatement", "Statement") | |
| } | |
| } | |
| }); | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/definitions/es2015.js": | |
| /*!******************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/definitions/es2015.js ***! | |
| \******************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.classMethodOrDeclareMethodCommon = exports.classMethodOrPropertyCommon = void 0; | |
| var _utils = _interopRequireWildcard(__webpack_require__(/*! ./utils */ "../babel-generator/node_modules/@babel/types/lib/definitions/utils.js")); | |
| var _core = __webpack_require__(/*! ./core */ "../babel-generator/node_modules/@babel/types/lib/definitions/core.js"); | |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } | |
| (0, _utils.default)("AssignmentPattern", { | |
| visitor: ["left", "right", "decorators"], | |
| builder: ["left", "right"], | |
| aliases: ["Pattern", "PatternLike", "LVal"], | |
| fields: Object.assign({}, _core.patternLikeCommon, { | |
| left: { | |
| validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression") | |
| }, | |
| right: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| decorators: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))) | |
| } | |
| }) | |
| }); | |
| (0, _utils.default)("ArrayPattern", { | |
| visitor: ["elements", "typeAnnotation"], | |
| builder: ["elements"], | |
| aliases: ["Pattern", "PatternLike", "LVal"], | |
| fields: Object.assign({}, _core.patternLikeCommon, { | |
| elements: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("PatternLike"))) | |
| }, | |
| decorators: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))) | |
| } | |
| }) | |
| }); | |
| (0, _utils.default)("ArrowFunctionExpression", { | |
| builder: ["params", "body", "async"], | |
| visitor: ["params", "body", "returnType", "typeParameters"], | |
| aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"], | |
| fields: Object.assign({}, _core.functionCommon, _core.functionTypeAnnotationCommon, { | |
| expression: { | |
| validate: (0, _utils.assertValueType)("boolean") | |
| }, | |
| body: { | |
| validate: (0, _utils.assertNodeType)("BlockStatement", "Expression") | |
| } | |
| }) | |
| }); | |
| (0, _utils.default)("ClassBody", { | |
| visitor: ["body"], | |
| fields: { | |
| body: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "TSDeclareMethod", "TSIndexSignature"))) | |
| } | |
| } | |
| }); | |
| const classCommon = { | |
| typeParameters: { | |
| validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), | |
| optional: true | |
| }, | |
| body: { | |
| validate: (0, _utils.assertNodeType)("ClassBody") | |
| }, | |
| superClass: { | |
| optional: true, | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| superTypeParameters: { | |
| validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), | |
| optional: true | |
| }, | |
| implements: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))), | |
| optional: true | |
| } | |
| }; | |
| (0, _utils.default)("ClassDeclaration", { | |
| builder: ["id", "superClass", "body", "decorators"], | |
| visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"], | |
| aliases: ["Scopable", "Class", "Statement", "Declaration", "Pureish"], | |
| fields: Object.assign({}, classCommon, { | |
| declare: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| optional: true | |
| }, | |
| abstract: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| optional: true | |
| }, | |
| id: { | |
| validate: (0, _utils.assertNodeType)("Identifier"), | |
| optional: true | |
| }, | |
| decorators: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), | |
| optional: true | |
| } | |
| }) | |
| }); | |
| (0, _utils.default)("ClassExpression", { | |
| inherits: "ClassDeclaration", | |
| aliases: ["Scopable", "Class", "Expression", "Pureish"], | |
| fields: Object.assign({}, classCommon, { | |
| id: { | |
| optional: true, | |
| validate: (0, _utils.assertNodeType)("Identifier") | |
| }, | |
| body: { | |
| validate: (0, _utils.assertNodeType)("ClassBody") | |
| }, | |
| superClass: { | |
| optional: true, | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| decorators: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), | |
| optional: true | |
| } | |
| }) | |
| }); | |
| (0, _utils.default)("ExportAllDeclaration", { | |
| visitor: ["source"], | |
| aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], | |
| fields: { | |
| source: { | |
| validate: (0, _utils.assertNodeType)("StringLiteral") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ExportDefaultDeclaration", { | |
| visitor: ["declaration"], | |
| aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], | |
| fields: { | |
| declaration: { | |
| validate: (0, _utils.assertNodeType)("FunctionDeclaration", "TSDeclareFunction", "ClassDeclaration", "Expression") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ExportNamedDeclaration", { | |
| visitor: ["declaration", "specifiers", "source"], | |
| aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], | |
| fields: { | |
| declaration: { | |
| validate: (0, _utils.assertNodeType)("Declaration"), | |
| optional: true | |
| }, | |
| specifiers: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier"))) | |
| }, | |
| source: { | |
| validate: (0, _utils.assertNodeType)("StringLiteral"), | |
| optional: true | |
| }, | |
| exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")) | |
| } | |
| }); | |
| (0, _utils.default)("ExportSpecifier", { | |
| visitor: ["local", "exported"], | |
| aliases: ["ModuleSpecifier"], | |
| fields: { | |
| local: { | |
| validate: (0, _utils.assertNodeType)("Identifier") | |
| }, | |
| exported: { | |
| validate: (0, _utils.assertNodeType)("Identifier") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ForOfStatement", { | |
| visitor: ["left", "right", "body"], | |
| aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"], | |
| fields: { | |
| left: { | |
| validate: (0, _utils.assertNodeType)("VariableDeclaration", "LVal") | |
| }, | |
| right: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| body: { | |
| validate: (0, _utils.assertNodeType)("Statement") | |
| }, | |
| await: { | |
| default: false, | |
| validate: (0, _utils.assertValueType)("boolean") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ImportDeclaration", { | |
| visitor: ["specifiers", "source"], | |
| aliases: ["Statement", "Declaration", "ModuleDeclaration"], | |
| fields: { | |
| specifiers: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier"))) | |
| }, | |
| source: { | |
| validate: (0, _utils.assertNodeType)("StringLiteral") | |
| }, | |
| importKind: { | |
| validate: (0, _utils.assertOneOf)("type", "typeof", "value"), | |
| optional: true | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ImportDefaultSpecifier", { | |
| visitor: ["local"], | |
| aliases: ["ModuleSpecifier"], | |
| fields: { | |
| local: { | |
| validate: (0, _utils.assertNodeType)("Identifier") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ImportNamespaceSpecifier", { | |
| visitor: ["local"], | |
| aliases: ["ModuleSpecifier"], | |
| fields: { | |
| local: { | |
| validate: (0, _utils.assertNodeType)("Identifier") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ImportSpecifier", { | |
| visitor: ["local", "imported"], | |
| aliases: ["ModuleSpecifier"], | |
| fields: { | |
| local: { | |
| validate: (0, _utils.assertNodeType)("Identifier") | |
| }, | |
| imported: { | |
| validate: (0, _utils.assertNodeType)("Identifier") | |
| }, | |
| importKind: { | |
| validate: (0, _utils.assertOneOf)("type", "typeof"), | |
| optional: true | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("MetaProperty", { | |
| visitor: ["meta", "property"], | |
| aliases: ["Expression"], | |
| fields: { | |
| meta: { | |
| validate: (0, _utils.assertNodeType)("Identifier") | |
| }, | |
| property: { | |
| validate: (0, _utils.assertNodeType)("Identifier") | |
| } | |
| } | |
| }); | |
| const classMethodOrPropertyCommon = { | |
| abstract: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| optional: true | |
| }, | |
| accessibility: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")), | |
| optional: true | |
| }, | |
| static: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| optional: true | |
| }, | |
| computed: { | |
| default: false, | |
| validate: (0, _utils.assertValueType)("boolean") | |
| }, | |
| optional: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| optional: true | |
| }, | |
| key: { | |
| validate: (0, _utils.chain)(function () { | |
| const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral"); | |
| const computed = (0, _utils.assertNodeType)("Expression"); | |
| return function (node, key, val) { | |
| const validator = node.computed ? computed : normal; | |
| validator(node, key, val); | |
| }; | |
| }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression")) | |
| } | |
| }; | |
| exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon; | |
| const classMethodOrDeclareMethodCommon = Object.assign({}, _core.functionCommon, classMethodOrPropertyCommon, { | |
| kind: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("get", "set", "method", "constructor")), | |
| default: "method" | |
| }, | |
| access: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")), | |
| optional: true | |
| }, | |
| decorators: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), | |
| optional: true | |
| } | |
| }); | |
| exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon; | |
| (0, _utils.default)("ClassMethod", { | |
| aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"], | |
| builder: ["kind", "key", "params", "body", "computed", "static"], | |
| visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"], | |
| fields: Object.assign({}, classMethodOrDeclareMethodCommon, _core.functionTypeAnnotationCommon, { | |
| body: { | |
| validate: (0, _utils.assertNodeType)("BlockStatement") | |
| } | |
| }) | |
| }); | |
| (0, _utils.default)("ObjectPattern", { | |
| visitor: ["properties", "typeAnnotation", "decorators"], | |
| builder: ["properties"], | |
| aliases: ["Pattern", "PatternLike", "LVal"], | |
| fields: Object.assign({}, _core.patternLikeCommon, { | |
| properties: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty"))) | |
| } | |
| }) | |
| }); | |
| (0, _utils.default)("SpreadElement", { | |
| visitor: ["argument"], | |
| aliases: ["UnaryLike"], | |
| deprecatedAlias: "SpreadProperty", | |
| fields: { | |
| argument: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("Super", { | |
| aliases: ["Expression"] | |
| }); | |
| (0, _utils.default)("TaggedTemplateExpression", { | |
| visitor: ["tag", "quasi"], | |
| aliases: ["Expression"], | |
| fields: { | |
| tag: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| quasi: { | |
| validate: (0, _utils.assertNodeType)("TemplateLiteral") | |
| }, | |
| typeParameters: { | |
| validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), | |
| optional: true | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("TemplateElement", { | |
| builder: ["value", "tail"], | |
| fields: { | |
| value: { | |
| validate: (0, _utils.assertShape)({ | |
| raw: { | |
| validate: (0, _utils.assertValueType)("string") | |
| }, | |
| cooked: { | |
| validate: (0, _utils.assertValueType)("string"), | |
| optional: true | |
| } | |
| }) | |
| }, | |
| tail: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| default: false | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("TemplateLiteral", { | |
| visitor: ["quasis", "expressions"], | |
| aliases: ["Expression", "Literal"], | |
| fields: { | |
| quasis: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TemplateElement"))) | |
| }, | |
| expressions: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression"))) | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("YieldExpression", { | |
| builder: ["argument", "delegate"], | |
| visitor: ["argument"], | |
| aliases: ["Expression", "Terminatorless"], | |
| fields: { | |
| delegate: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| default: false | |
| }, | |
| argument: { | |
| optional: true, | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| } | |
| }); | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/definitions/experimental.js": | |
| /*!************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/definitions/experimental.js ***! | |
| \************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| var _utils = _interopRequireWildcard(__webpack_require__(/*! ./utils */ "../babel-generator/node_modules/@babel/types/lib/definitions/utils.js")); | |
| var _es = __webpack_require__(/*! ./es2015 */ "../babel-generator/node_modules/@babel/types/lib/definitions/es2015.js"); | |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } | |
| (0, _utils.default)("ArgumentPlaceholder", {}); | |
| (0, _utils.default)("AwaitExpression", { | |
| builder: ["argument"], | |
| visitor: ["argument"], | |
| aliases: ["Expression", "Terminatorless"], | |
| fields: { | |
| argument: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("BindExpression", { | |
| visitor: ["object", "callee"], | |
| aliases: ["Expression"], | |
| fields: {} | |
| }); | |
| (0, _utils.default)("ClassProperty", { | |
| visitor: ["key", "value", "typeAnnotation", "decorators"], | |
| builder: ["key", "value", "typeAnnotation", "decorators", "computed"], | |
| aliases: ["Property"], | |
| fields: Object.assign({}, _es.classMethodOrPropertyCommon, { | |
| value: { | |
| validate: (0, _utils.assertNodeType)("Expression"), | |
| optional: true | |
| }, | |
| definite: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| optional: true | |
| }, | |
| typeAnnotation: { | |
| validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"), | |
| optional: true | |
| }, | |
| decorators: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), | |
| optional: true | |
| }, | |
| readonly: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| optional: true | |
| } | |
| }) | |
| }); | |
| (0, _utils.default)("OptionalMemberExpression", { | |
| builder: ["object", "property", "computed", "optional"], | |
| visitor: ["object", "property"], | |
| aliases: ["Expression"], | |
| fields: { | |
| object: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| property: { | |
| validate: function () { | |
| const normal = (0, _utils.assertNodeType)("Identifier"); | |
| const computed = (0, _utils.assertNodeType)("Expression"); | |
| return function (node, key, val) { | |
| const validator = node.computed ? computed : normal; | |
| validator(node, key, val); | |
| }; | |
| }() | |
| }, | |
| computed: { | |
| default: false | |
| }, | |
| optional: { | |
| validate: (0, _utils.assertValueType)("boolean") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("PipelineTopicExpression", { | |
| builder: ["expression"], | |
| visitor: ["expression"], | |
| fields: { | |
| expression: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("PipelineBareFunction", { | |
| builder: ["callee"], | |
| visitor: ["callee"], | |
| fields: { | |
| callee: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("PipelinePrimaryTopicReference", { | |
| aliases: ["Expression"] | |
| }); | |
| (0, _utils.default)("OptionalCallExpression", { | |
| visitor: ["callee", "arguments", "typeParameters", "typeArguments"], | |
| builder: ["callee", "arguments", "optional"], | |
| aliases: ["Expression"], | |
| fields: { | |
| callee: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| }, | |
| arguments: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName"))) | |
| }, | |
| optional: { | |
| validate: (0, _utils.assertValueType)("boolean") | |
| }, | |
| typeArguments: { | |
| validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"), | |
| optional: true | |
| }, | |
| typeParameters: { | |
| validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"), | |
| optional: true | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ClassPrivateProperty", { | |
| visitor: ["key", "value"], | |
| builder: ["key", "value"], | |
| aliases: ["Property", "Private"], | |
| fields: { | |
| key: { | |
| validate: (0, _utils.assertNodeType)("PrivateName") | |
| }, | |
| value: { | |
| validate: (0, _utils.assertNodeType)("Expression"), | |
| optional: true | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ClassPrivateMethod", { | |
| builder: ["kind", "key", "params", "body", "static"], | |
| visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"], | |
| aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"], | |
| fields: Object.assign({}, _es.classMethodOrDeclareMethodCommon, { | |
| key: { | |
| validate: (0, _utils.assertNodeType)("PrivateName") | |
| }, | |
| body: { | |
| validate: (0, _utils.assertNodeType)("BlockStatement") | |
| } | |
| }) | |
| }); | |
| (0, _utils.default)("Import", { | |
| aliases: ["Expression"] | |
| }); | |
| (0, _utils.default)("Decorator", { | |
| visitor: ["expression"], | |
| fields: { | |
| expression: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("DoExpression", { | |
| visitor: ["body"], | |
| aliases: ["Expression"], | |
| fields: { | |
| body: { | |
| validate: (0, _utils.assertNodeType)("BlockStatement") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ExportDefaultSpecifier", { | |
| visitor: ["exported"], | |
| aliases: ["ModuleSpecifier"], | |
| fields: { | |
| exported: { | |
| validate: (0, _utils.assertNodeType)("Identifier") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("ExportNamespaceSpecifier", { | |
| visitor: ["exported"], | |
| aliases: ["ModuleSpecifier"], | |
| fields: { | |
| exported: { | |
| validate: (0, _utils.assertNodeType)("Identifier") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("PrivateName", { | |
| visitor: ["id"], | |
| aliases: ["Private"], | |
| fields: { | |
| id: { | |
| validate: (0, _utils.assertNodeType)("Identifier") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("BigIntLiteral", { | |
| builder: ["value"], | |
| fields: { | |
| value: { | |
| validate: (0, _utils.assertValueType)("string") | |
| } | |
| }, | |
| aliases: ["Expression", "Pureish", "Literal", "Immutable"] | |
| }); | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/definitions/flow.js": | |
| /*!****************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/definitions/flow.js ***! | |
| \****************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| var _utils = _interopRequireWildcard(__webpack_require__(/*! ./utils */ "../babel-generator/node_modules/@babel/types/lib/definitions/utils.js")); | |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } | |
| const defineInterfaceishType = (name, typeParameterType = "TypeParameterDeclaration") => { | |
| (0, _utils.default)(name, { | |
| builder: ["id", "typeParameters", "extends", "body"], | |
| visitor: ["id", "typeParameters", "extends", "mixins", "implements", "body"], | |
| aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"], | |
| fields: { | |
| id: (0, _utils.validateType)("Identifier"), | |
| typeParameters: (0, _utils.validateOptionalType)(typeParameterType), | |
| extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")), | |
| mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")), | |
| implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ClassImplements")), | |
| body: (0, _utils.validateType)("ObjectTypeAnnotation") | |
| } | |
| }); | |
| }; | |
| (0, _utils.default)("AnyTypeAnnotation", { | |
| aliases: ["Flow", "FlowType", "FlowBaseAnnotation"] | |
| }); | |
| (0, _utils.default)("ArrayTypeAnnotation", { | |
| visitor: ["elementType"], | |
| aliases: ["Flow", "FlowType"], | |
| fields: { | |
| elementType: (0, _utils.validateType)("FlowType") | |
| } | |
| }); | |
| (0, _utils.default)("BooleanTypeAnnotation", { | |
| aliases: ["Flow", "FlowType", "FlowBaseAnnotation"] | |
| }); | |
| (0, _utils.default)("BooleanLiteralTypeAnnotation", { | |
| builder: ["value"], | |
| aliases: ["Flow", "FlowType"], | |
| fields: { | |
| value: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) | |
| } | |
| }); | |
| (0, _utils.default)("NullLiteralTypeAnnotation", { | |
| aliases: ["Flow", "FlowType", "FlowBaseAnnotation"] | |
| }); | |
| (0, _utils.default)("ClassImplements", { | |
| visitor: ["id", "typeParameters"], | |
| aliases: ["Flow"], | |
| fields: { | |
| id: (0, _utils.validateType)("Identifier"), | |
| typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation") | |
| } | |
| }); | |
| defineInterfaceishType("DeclareClass"); | |
| (0, _utils.default)("DeclareFunction", { | |
| visitor: ["id"], | |
| aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"], | |
| fields: { | |
| id: (0, _utils.validateType)("Identifier"), | |
| predicate: (0, _utils.validateOptionalType)("DeclaredPredicate") | |
| } | |
| }); | |
| defineInterfaceishType("DeclareInterface"); | |
| (0, _utils.default)("DeclareModule", { | |
| builder: ["id", "body", "kind"], | |
| visitor: ["id", "body"], | |
| aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"], | |
| fields: { | |
| id: (0, _utils.validateType)(["Identifier", "StringLiteral"]), | |
| body: (0, _utils.validateType)("BlockStatement"), | |
| kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES")) | |
| } | |
| }); | |
| (0, _utils.default)("DeclareModuleExports", { | |
| visitor: ["typeAnnotation"], | |
| aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"], | |
| fields: { | |
| typeAnnotation: (0, _utils.validateType)("TypeAnnotation") | |
| } | |
| }); | |
| (0, _utils.default)("DeclareTypeAlias", { | |
| visitor: ["id", "typeParameters", "right"], | |
| aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"], | |
| fields: { | |
| id: (0, _utils.validateType)("Identifier"), | |
| typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), | |
| right: (0, _utils.validateType)("FlowType") | |
| } | |
| }); | |
| (0, _utils.default)("DeclareOpaqueType", { | |
| visitor: ["id", "typeParameters", "supertype"], | |
| aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"], | |
| fields: { | |
| id: (0, _utils.validateType)("Identifier"), | |
| typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), | |
| supertype: (0, _utils.validateOptionalType)("FlowType") | |
| } | |
| }); | |
| (0, _utils.default)("DeclareVariable", { | |
| visitor: ["id"], | |
| aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"], | |
| fields: { | |
| id: (0, _utils.validateType)("Identifier") | |
| } | |
| }); | |
| (0, _utils.default)("DeclareExportDeclaration", { | |
| visitor: ["declaration", "specifiers", "source"], | |
| aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"], | |
| fields: { | |
| declaration: (0, _utils.validateOptionalType)("Flow"), | |
| specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(["ExportSpecifier", "ExportNamespaceSpecifier"])), | |
| source: (0, _utils.validateOptionalType)("StringLiteral"), | |
| default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean")) | |
| } | |
| }); | |
| (0, _utils.default)("DeclareExportAllDeclaration", { | |
| visitor: ["source"], | |
| aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"], | |
| fields: { | |
| source: (0, _utils.validateType)("StringLiteral"), | |
| exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")) | |
| } | |
| }); | |
| (0, _utils.default)("DeclaredPredicate", { | |
| visitor: ["value"], | |
| aliases: ["Flow", "FlowPredicate"], | |
| fields: { | |
| value: (0, _utils.validateType)("Flow") | |
| } | |
| }); | |
| (0, _utils.default)("ExistsTypeAnnotation", { | |
| aliases: ["Flow", "FlowType"] | |
| }); | |
| (0, _utils.default)("FunctionTypeAnnotation", { | |
| visitor: ["typeParameters", "params", "rest", "returnType"], | |
| aliases: ["Flow", "FlowType"], | |
| fields: { | |
| typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), | |
| params: (0, _utils.validate)((0, _utils.arrayOfType)("FunctionTypeParam")), | |
| rest: (0, _utils.validateOptionalType)("FunctionTypeParam"), | |
| returnType: (0, _utils.validateType)("FlowType") | |
| } | |
| }); | |
| (0, _utils.default)("FunctionTypeParam", { | |
| visitor: ["name", "typeAnnotation"], | |
| aliases: ["Flow"], | |
| fields: { | |
| name: (0, _utils.validateOptionalType)("Identifier"), | |
| typeAnnotation: (0, _utils.validateType)("FlowType"), | |
| optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean")) | |
| } | |
| }); | |
| (0, _utils.default)("GenericTypeAnnotation", { | |
| visitor: ["id", "typeParameters"], | |
| aliases: ["Flow", "FlowType"], | |
| fields: { | |
| id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]), | |
| typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation") | |
| } | |
| }); | |
| (0, _utils.default)("InferredPredicate", { | |
| aliases: ["Flow", "FlowPredicate"] | |
| }); | |
| (0, _utils.default)("InterfaceExtends", { | |
| visitor: ["id", "typeParameters"], | |
| aliases: ["Flow"], | |
| fields: { | |
| id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]), | |
| typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation") | |
| } | |
| }); | |
| defineInterfaceishType("InterfaceDeclaration"); | |
| (0, _utils.default)("InterfaceTypeAnnotation", { | |
| visitor: ["extends", "body"], | |
| aliases: ["Flow", "FlowType"], | |
| fields: { | |
| extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")), | |
| body: (0, _utils.validateType)("ObjectTypeAnnotation") | |
| } | |
| }); | |
| (0, _utils.default)("IntersectionTypeAnnotation", { | |
| visitor: ["types"], | |
| aliases: ["Flow", "FlowType"], | |
| fields: { | |
| types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) | |
| } | |
| }); | |
| (0, _utils.default)("MixedTypeAnnotation", { | |
| aliases: ["Flow", "FlowType", "FlowBaseAnnotation"] | |
| }); | |
| (0, _utils.default)("EmptyTypeAnnotation", { | |
| aliases: ["Flow", "FlowType", "FlowBaseAnnotation"] | |
| }); | |
| (0, _utils.default)("NullableTypeAnnotation", { | |
| visitor: ["typeAnnotation"], | |
| aliases: ["Flow", "FlowType"], | |
| fields: { | |
| typeAnnotation: (0, _utils.validateType)("FlowType") | |
| } | |
| }); | |
| (0, _utils.default)("NumberLiteralTypeAnnotation", { | |
| builder: ["value"], | |
| aliases: ["Flow", "FlowType"], | |
| fields: { | |
| value: (0, _utils.validate)((0, _utils.assertValueType)("number")) | |
| } | |
| }); | |
| (0, _utils.default)("NumberTypeAnnotation", { | |
| aliases: ["Flow", "FlowType", "FlowBaseAnnotation"] | |
| }); | |
| (0, _utils.default)("ObjectTypeAnnotation", { | |
| visitor: ["properties", "indexers", "callProperties", "internalSlots"], | |
| aliases: ["Flow", "FlowType"], | |
| builder: ["properties", "indexers", "callProperties", "internalSlots", "exact"], | |
| fields: { | |
| properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])), | |
| indexers: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeIndexer")), | |
| callProperties: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeCallProperty")), | |
| internalSlots: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeInternalSlot")), | |
| exact: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| default: false | |
| }, | |
| inexact: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean")) | |
| } | |
| }); | |
| (0, _utils.default)("ObjectTypeInternalSlot", { | |
| visitor: ["id", "value", "optional", "static", "method"], | |
| aliases: ["Flow", "UserWhitespacable"], | |
| fields: { | |
| id: (0, _utils.validateType)("Identifier"), | |
| value: (0, _utils.validateType)("FlowType"), | |
| optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), | |
| static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), | |
| method: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) | |
| } | |
| }); | |
| (0, _utils.default)("ObjectTypeCallProperty", { | |
| visitor: ["value"], | |
| aliases: ["Flow", "UserWhitespacable"], | |
| fields: { | |
| value: (0, _utils.validateType)("FlowType"), | |
| static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")) | |
| } | |
| }); | |
| (0, _utils.default)("ObjectTypeIndexer", { | |
| visitor: ["id", "key", "value", "variance"], | |
| aliases: ["Flow", "UserWhitespacable"], | |
| fields: { | |
| id: (0, _utils.validateOptionalType)("Identifier"), | |
| key: (0, _utils.validateType)("FlowType"), | |
| value: (0, _utils.validateType)("FlowType"), | |
| static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), | |
| variance: (0, _utils.validateOptionalType)("Variance") | |
| } | |
| }); | |
| (0, _utils.default)("ObjectTypeProperty", { | |
| visitor: ["key", "value", "variance"], | |
| aliases: ["Flow", "UserWhitespacable"], | |
| fields: { | |
| key: (0, _utils.validateType)(["Identifier", "StringLiteral"]), | |
| value: (0, _utils.validateType)("FlowType"), | |
| kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")), | |
| static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), | |
| proto: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), | |
| optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")), | |
| variance: (0, _utils.validateOptionalType)("Variance") | |
| } | |
| }); | |
| (0, _utils.default)("ObjectTypeSpreadProperty", { | |
| visitor: ["argument"], | |
| aliases: ["Flow", "UserWhitespacable"], | |
| fields: { | |
| argument: (0, _utils.validateType)("FlowType") | |
| } | |
| }); | |
| (0, _utils.default)("OpaqueType", { | |
| visitor: ["id", "typeParameters", "supertype", "impltype"], | |
| aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"], | |
| fields: { | |
| id: (0, _utils.validateType)("Identifier"), | |
| typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), | |
| supertype: (0, _utils.validateOptionalType)("FlowType"), | |
| impltype: (0, _utils.validateType)("FlowType") | |
| } | |
| }); | |
| (0, _utils.default)("QualifiedTypeIdentifier", { | |
| visitor: ["id", "qualification"], | |
| aliases: ["Flow"], | |
| fields: { | |
| id: (0, _utils.validateType)("Identifier"), | |
| qualification: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]) | |
| } | |
| }); | |
| (0, _utils.default)("StringLiteralTypeAnnotation", { | |
| builder: ["value"], | |
| aliases: ["Flow", "FlowType"], | |
| fields: { | |
| value: (0, _utils.validate)((0, _utils.assertValueType)("string")) | |
| } | |
| }); | |
| (0, _utils.default)("StringTypeAnnotation", { | |
| aliases: ["Flow", "FlowType", "FlowBaseAnnotation"] | |
| }); | |
| (0, _utils.default)("ThisTypeAnnotation", { | |
| aliases: ["Flow", "FlowType", "FlowBaseAnnotation"] | |
| }); | |
| (0, _utils.default)("TupleTypeAnnotation", { | |
| visitor: ["types"], | |
| aliases: ["Flow", "FlowType"], | |
| fields: { | |
| types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) | |
| } | |
| }); | |
| (0, _utils.default)("TypeofTypeAnnotation", { | |
| visitor: ["argument"], | |
| aliases: ["Flow", "FlowType"], | |
| fields: { | |
| argument: (0, _utils.validateType)("FlowType") | |
| } | |
| }); | |
| (0, _utils.default)("TypeAlias", { | |
| visitor: ["id", "typeParameters", "right"], | |
| aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"], | |
| fields: { | |
| id: (0, _utils.validateType)("Identifier"), | |
| typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"), | |
| right: (0, _utils.validateType)("FlowType") | |
| } | |
| }); | |
| (0, _utils.default)("TypeAnnotation", { | |
| aliases: ["Flow"], | |
| visitor: ["typeAnnotation"], | |
| fields: { | |
| typeAnnotation: (0, _utils.validateType)("FlowType") | |
| } | |
| }); | |
| (0, _utils.default)("TypeCastExpression", { | |
| visitor: ["expression", "typeAnnotation"], | |
| aliases: ["Flow", "ExpressionWrapper", "Expression"], | |
| fields: { | |
| expression: (0, _utils.validateType)("Expression"), | |
| typeAnnotation: (0, _utils.validateType)("TypeAnnotation") | |
| } | |
| }); | |
| (0, _utils.default)("TypeParameter", { | |
| aliases: ["Flow"], | |
| visitor: ["bound", "default", "variance"], | |
| fields: { | |
| name: (0, _utils.validate)((0, _utils.assertValueType)("string")), | |
| bound: (0, _utils.validateOptionalType)("TypeAnnotation"), | |
| default: (0, _utils.validateOptionalType)("FlowType"), | |
| variance: (0, _utils.validateOptionalType)("Variance") | |
| } | |
| }); | |
| (0, _utils.default)("TypeParameterDeclaration", { | |
| aliases: ["Flow"], | |
| visitor: ["params"], | |
| fields: { | |
| params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter")) | |
| } | |
| }); | |
| (0, _utils.default)("TypeParameterInstantiation", { | |
| aliases: ["Flow"], | |
| visitor: ["params"], | |
| fields: { | |
| params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) | |
| } | |
| }); | |
| (0, _utils.default)("UnionTypeAnnotation", { | |
| visitor: ["types"], | |
| aliases: ["Flow", "FlowType"], | |
| fields: { | |
| types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType")) | |
| } | |
| }); | |
| (0, _utils.default)("Variance", { | |
| aliases: ["Flow"], | |
| builder: ["kind"], | |
| fields: { | |
| kind: (0, _utils.validate)((0, _utils.assertOneOf)("minus", "plus")) | |
| } | |
| }); | |
| (0, _utils.default)("VoidTypeAnnotation", { | |
| aliases: ["Flow", "FlowType", "FlowBaseAnnotation"] | |
| }); | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/definitions/index.js": | |
| /*!*****************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/definitions/index.js ***! | |
| \*****************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| Object.defineProperty(exports, "VISITOR_KEYS", { | |
| enumerable: true, | |
| get: function () { | |
| return _utils.VISITOR_KEYS; | |
| } | |
| }); | |
| Object.defineProperty(exports, "ALIAS_KEYS", { | |
| enumerable: true, | |
| get: function () { | |
| return _utils.ALIAS_KEYS; | |
| } | |
| }); | |
| Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", { | |
| enumerable: true, | |
| get: function () { | |
| return _utils.FLIPPED_ALIAS_KEYS; | |
| } | |
| }); | |
| Object.defineProperty(exports, "NODE_FIELDS", { | |
| enumerable: true, | |
| get: function () { | |
| return _utils.NODE_FIELDS; | |
| } | |
| }); | |
| Object.defineProperty(exports, "BUILDER_KEYS", { | |
| enumerable: true, | |
| get: function () { | |
| return _utils.BUILDER_KEYS; | |
| } | |
| }); | |
| Object.defineProperty(exports, "DEPRECATED_KEYS", { | |
| enumerable: true, | |
| get: function () { | |
| return _utils.DEPRECATED_KEYS; | |
| } | |
| }); | |
| Object.defineProperty(exports, "PLACEHOLDERS", { | |
| enumerable: true, | |
| get: function () { | |
| return _placeholders.PLACEHOLDERS; | |
| } | |
| }); | |
| Object.defineProperty(exports, "PLACEHOLDERS_ALIAS", { | |
| enumerable: true, | |
| get: function () { | |
| return _placeholders.PLACEHOLDERS_ALIAS; | |
| } | |
| }); | |
| Object.defineProperty(exports, "PLACEHOLDERS_FLIPPED_ALIAS", { | |
| enumerable: true, | |
| get: function () { | |
| return _placeholders.PLACEHOLDERS_FLIPPED_ALIAS; | |
| } | |
| }); | |
| exports.TYPES = void 0; | |
| function _toFastProperties() { | |
| const data = _interopRequireDefault(__webpack_require__(/*! to-fast-properties */ "../babel-generator/node_modules/to-fast-properties/index.js")); | |
| _toFastProperties = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| __webpack_require__(/*! ./core */ "../babel-generator/node_modules/@babel/types/lib/definitions/core.js"); | |
| __webpack_require__(/*! ./es2015 */ "../babel-generator/node_modules/@babel/types/lib/definitions/es2015.js"); | |
| __webpack_require__(/*! ./flow */ "../babel-generator/node_modules/@babel/types/lib/definitions/flow.js"); | |
| __webpack_require__(/*! ./jsx */ "../babel-generator/node_modules/@babel/types/lib/definitions/jsx.js"); | |
| __webpack_require__(/*! ./misc */ "../babel-generator/node_modules/@babel/types/lib/definitions/misc.js"); | |
| __webpack_require__(/*! ./experimental */ "../babel-generator/node_modules/@babel/types/lib/definitions/experimental.js"); | |
| __webpack_require__(/*! ./typescript */ "../babel-generator/node_modules/@babel/types/lib/definitions/typescript.js"); | |
| var _utils = __webpack_require__(/*! ./utils */ "../babel-generator/node_modules/@babel/types/lib/definitions/utils.js"); | |
| var _placeholders = __webpack_require__(/*! ./placeholders */ "../babel-generator/node_modules/@babel/types/lib/definitions/placeholders.js"); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| (0, _toFastProperties().default)(_utils.VISITOR_KEYS); | |
| (0, _toFastProperties().default)(_utils.ALIAS_KEYS); | |
| (0, _toFastProperties().default)(_utils.FLIPPED_ALIAS_KEYS); | |
| (0, _toFastProperties().default)(_utils.NODE_FIELDS); | |
| (0, _toFastProperties().default)(_utils.BUILDER_KEYS); | |
| (0, _toFastProperties().default)(_utils.DEPRECATED_KEYS); | |
| (0, _toFastProperties().default)(_placeholders.PLACEHOLDERS_ALIAS); | |
| (0, _toFastProperties().default)(_placeholders.PLACEHOLDERS_FLIPPED_ALIAS); | |
| const TYPES = Object.keys(_utils.VISITOR_KEYS).concat(Object.keys(_utils.FLIPPED_ALIAS_KEYS)).concat(Object.keys(_utils.DEPRECATED_KEYS)); | |
| exports.TYPES = TYPES; | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/definitions/jsx.js": | |
| /*!***************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/definitions/jsx.js ***! | |
| \***************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| var _utils = _interopRequireWildcard(__webpack_require__(/*! ./utils */ "../babel-generator/node_modules/@babel/types/lib/definitions/utils.js")); | |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } | |
| (0, _utils.default)("JSXAttribute", { | |
| visitor: ["name", "value"], | |
| aliases: ["JSX", "Immutable"], | |
| fields: { | |
| name: { | |
| validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXNamespacedName") | |
| }, | |
| value: { | |
| optional: true, | |
| validate: (0, _utils.assertNodeType)("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("JSXClosingElement", { | |
| visitor: ["name"], | |
| aliases: ["JSX", "Immutable"], | |
| fields: { | |
| name: { | |
| validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("JSXElement", { | |
| builder: ["openingElement", "closingElement", "children", "selfClosing"], | |
| visitor: ["openingElement", "children", "closingElement"], | |
| aliases: ["JSX", "Immutable", "Expression"], | |
| fields: { | |
| openingElement: { | |
| validate: (0, _utils.assertNodeType)("JSXOpeningElement") | |
| }, | |
| closingElement: { | |
| optional: true, | |
| validate: (0, _utils.assertNodeType)("JSXClosingElement") | |
| }, | |
| children: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment"))) | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("JSXEmptyExpression", { | |
| aliases: ["JSX"] | |
| }); | |
| (0, _utils.default)("JSXExpressionContainer", { | |
| visitor: ["expression"], | |
| aliases: ["JSX", "Immutable"], | |
| fields: { | |
| expression: { | |
| validate: (0, _utils.assertNodeType)("Expression", "JSXEmptyExpression") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("JSXSpreadChild", { | |
| visitor: ["expression"], | |
| aliases: ["JSX", "Immutable"], | |
| fields: { | |
| expression: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("JSXIdentifier", { | |
| builder: ["name"], | |
| aliases: ["JSX"], | |
| fields: { | |
| name: { | |
| validate: (0, _utils.assertValueType)("string") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("JSXMemberExpression", { | |
| visitor: ["object", "property"], | |
| aliases: ["JSX"], | |
| fields: { | |
| object: { | |
| validate: (0, _utils.assertNodeType)("JSXMemberExpression", "JSXIdentifier") | |
| }, | |
| property: { | |
| validate: (0, _utils.assertNodeType)("JSXIdentifier") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("JSXNamespacedName", { | |
| visitor: ["namespace", "name"], | |
| aliases: ["JSX"], | |
| fields: { | |
| namespace: { | |
| validate: (0, _utils.assertNodeType)("JSXIdentifier") | |
| }, | |
| name: { | |
| validate: (0, _utils.assertNodeType)("JSXIdentifier") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("JSXOpeningElement", { | |
| builder: ["name", "attributes", "selfClosing"], | |
| visitor: ["name", "attributes"], | |
| aliases: ["JSX", "Immutable"], | |
| fields: { | |
| name: { | |
| validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression") | |
| }, | |
| selfClosing: { | |
| default: false, | |
| validate: (0, _utils.assertValueType)("boolean") | |
| }, | |
| attributes: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXAttribute", "JSXSpreadAttribute"))) | |
| }, | |
| typeParameters: { | |
| validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), | |
| optional: true | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("JSXSpreadAttribute", { | |
| visitor: ["argument"], | |
| aliases: ["JSX"], | |
| fields: { | |
| argument: { | |
| validate: (0, _utils.assertNodeType)("Expression") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("JSXText", { | |
| aliases: ["JSX", "Immutable"], | |
| builder: ["value"], | |
| fields: { | |
| value: { | |
| validate: (0, _utils.assertValueType)("string") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("JSXFragment", { | |
| builder: ["openingFragment", "closingFragment", "children"], | |
| visitor: ["openingFragment", "children", "closingFragment"], | |
| aliases: ["JSX", "Immutable", "Expression"], | |
| fields: { | |
| openingFragment: { | |
| validate: (0, _utils.assertNodeType)("JSXOpeningFragment") | |
| }, | |
| closingFragment: { | |
| validate: (0, _utils.assertNodeType)("JSXClosingFragment") | |
| }, | |
| children: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment"))) | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("JSXOpeningFragment", { | |
| aliases: ["JSX", "Immutable"] | |
| }); | |
| (0, _utils.default)("JSXClosingFragment", { | |
| aliases: ["JSX", "Immutable"] | |
| }); | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/definitions/misc.js": | |
| /*!****************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/definitions/misc.js ***! | |
| \****************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| var _utils = _interopRequireWildcard(__webpack_require__(/*! ./utils */ "../babel-generator/node_modules/@babel/types/lib/definitions/utils.js")); | |
| var _placeholders = __webpack_require__(/*! ./placeholders */ "../babel-generator/node_modules/@babel/types/lib/definitions/placeholders.js"); | |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } | |
| (0, _utils.default)("Noop", { | |
| visitor: [] | |
| }); | |
| (0, _utils.default)("Placeholder", { | |
| visitor: [], | |
| builder: ["expectedNode", "name"], | |
| fields: { | |
| name: { | |
| validate: (0, _utils.assertNodeType)("Identifier") | |
| }, | |
| expectedNode: { | |
| validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS) | |
| } | |
| } | |
| }); | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/definitions/placeholders.js": | |
| /*!************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/definitions/placeholders.js ***! | |
| \************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS = void 0; | |
| var _utils = __webpack_require__(/*! ./utils */ "../babel-generator/node_modules/@babel/types/lib/definitions/utils.js"); | |
| const PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"]; | |
| exports.PLACEHOLDERS = PLACEHOLDERS; | |
| const PLACEHOLDERS_ALIAS = { | |
| Declaration: ["Statement"], | |
| Pattern: ["PatternLike", "LVal"] | |
| }; | |
| exports.PLACEHOLDERS_ALIAS = PLACEHOLDERS_ALIAS; | |
| for (const type of PLACEHOLDERS) { | |
| const alias = _utils.ALIAS_KEYS[type]; | |
| if (alias && alias.length) PLACEHOLDERS_ALIAS[type] = alias; | |
| } | |
| const PLACEHOLDERS_FLIPPED_ALIAS = {}; | |
| exports.PLACEHOLDERS_FLIPPED_ALIAS = PLACEHOLDERS_FLIPPED_ALIAS; | |
| Object.keys(PLACEHOLDERS_ALIAS).forEach(type => { | |
| PLACEHOLDERS_ALIAS[type].forEach(alias => { | |
| if (!Object.hasOwnProperty.call(PLACEHOLDERS_FLIPPED_ALIAS, alias)) { | |
| PLACEHOLDERS_FLIPPED_ALIAS[alias] = []; | |
| } | |
| PLACEHOLDERS_FLIPPED_ALIAS[alias].push(type); | |
| }); | |
| }); | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/definitions/typescript.js": | |
| /*!**********************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/definitions/typescript.js ***! | |
| \**********************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| var _utils = _interopRequireWildcard(__webpack_require__(/*! ./utils */ "../babel-generator/node_modules/@babel/types/lib/definitions/utils.js")); | |
| var _core = __webpack_require__(/*! ./core */ "../babel-generator/node_modules/@babel/types/lib/definitions/core.js"); | |
| var _es = __webpack_require__(/*! ./es2015 */ "../babel-generator/node_modules/@babel/types/lib/definitions/es2015.js"); | |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } | |
| const bool = (0, _utils.assertValueType)("boolean"); | |
| const tSFunctionTypeAnnotationCommon = { | |
| returnType: { | |
| validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"), | |
| optional: true | |
| }, | |
| typeParameters: { | |
| validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"), | |
| optional: true | |
| } | |
| }; | |
| (0, _utils.default)("TSParameterProperty", { | |
| aliases: ["LVal"], | |
| visitor: ["parameter"], | |
| fields: { | |
| accessibility: { | |
| validate: (0, _utils.assertOneOf)("public", "private", "protected"), | |
| optional: true | |
| }, | |
| readonly: { | |
| validate: (0, _utils.assertValueType)("boolean"), | |
| optional: true | |
| }, | |
| parameter: { | |
| validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("TSDeclareFunction", { | |
| aliases: ["Statement", "Declaration"], | |
| visitor: ["id", "typeParameters", "params", "returnType"], | |
| fields: Object.assign({}, _core.functionDeclarationCommon, tSFunctionTypeAnnotationCommon) | |
| }); | |
| (0, _utils.default)("TSDeclareMethod", { | |
| visitor: ["decorators", "key", "typeParameters", "params", "returnType"], | |
| fields: Object.assign({}, _es.classMethodOrDeclareMethodCommon, tSFunctionTypeAnnotationCommon) | |
| }); | |
| (0, _utils.default)("TSQualifiedName", { | |
| aliases: ["TSEntityName"], | |
| visitor: ["left", "right"], | |
| fields: { | |
| left: (0, _utils.validateType)("TSEntityName"), | |
| right: (0, _utils.validateType)("Identifier") | |
| } | |
| }); | |
| const signatureDeclarationCommon = { | |
| typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), | |
| parameters: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]), | |
| typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation") | |
| }; | |
| const callConstructSignatureDeclaration = { | |
| aliases: ["TSTypeElement"], | |
| visitor: ["typeParameters", "parameters", "typeAnnotation"], | |
| fields: signatureDeclarationCommon | |
| }; | |
| (0, _utils.default)("TSCallSignatureDeclaration", callConstructSignatureDeclaration); | |
| (0, _utils.default)("TSConstructSignatureDeclaration", callConstructSignatureDeclaration); | |
| const namedTypeElementCommon = { | |
| key: (0, _utils.validateType)("Expression"), | |
| computed: (0, _utils.validate)(bool), | |
| optional: (0, _utils.validateOptional)(bool) | |
| }; | |
| (0, _utils.default)("TSPropertySignature", { | |
| aliases: ["TSTypeElement"], | |
| visitor: ["key", "typeAnnotation", "initializer"], | |
| fields: Object.assign({}, namedTypeElementCommon, { | |
| readonly: (0, _utils.validateOptional)(bool), | |
| typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"), | |
| initializer: (0, _utils.validateOptionalType)("Expression") | |
| }) | |
| }); | |
| (0, _utils.default)("TSMethodSignature", { | |
| aliases: ["TSTypeElement"], | |
| visitor: ["key", "typeParameters", "parameters", "typeAnnotation"], | |
| fields: Object.assign({}, signatureDeclarationCommon, namedTypeElementCommon) | |
| }); | |
| (0, _utils.default)("TSIndexSignature", { | |
| aliases: ["TSTypeElement"], | |
| visitor: ["parameters", "typeAnnotation"], | |
| fields: { | |
| readonly: (0, _utils.validateOptional)(bool), | |
| parameters: (0, _utils.validateArrayOfType)("Identifier"), | |
| typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation") | |
| } | |
| }); | |
| const tsKeywordTypes = ["TSAnyKeyword", "TSUnknownKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSBooleanKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSVoidKeyword", "TSUndefinedKeyword", "TSNullKeyword", "TSNeverKeyword"]; | |
| for (const type of tsKeywordTypes) { | |
| (0, _utils.default)(type, { | |
| aliases: ["TSType"], | |
| visitor: [], | |
| fields: {} | |
| }); | |
| } | |
| (0, _utils.default)("TSThisType", { | |
| aliases: ["TSType"], | |
| visitor: [], | |
| fields: {} | |
| }); | |
| const fnOrCtr = { | |
| aliases: ["TSType"], | |
| visitor: ["typeParameters", "parameters", "typeAnnotation"], | |
| fields: signatureDeclarationCommon | |
| }; | |
| (0, _utils.default)("TSFunctionType", fnOrCtr); | |
| (0, _utils.default)("TSConstructorType", fnOrCtr); | |
| (0, _utils.default)("TSTypeReference", { | |
| aliases: ["TSType"], | |
| visitor: ["typeName", "typeParameters"], | |
| fields: { | |
| typeName: (0, _utils.validateType)("TSEntityName"), | |
| typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") | |
| } | |
| }); | |
| (0, _utils.default)("TSTypePredicate", { | |
| aliases: ["TSType"], | |
| visitor: ["parameterName", "typeAnnotation"], | |
| fields: { | |
| parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]), | |
| typeAnnotation: (0, _utils.validateType)("TSTypeAnnotation") | |
| } | |
| }); | |
| (0, _utils.default)("TSTypeQuery", { | |
| aliases: ["TSType"], | |
| visitor: ["exprName"], | |
| fields: { | |
| exprName: (0, _utils.validateType)(["TSEntityName", "TSImportType"]) | |
| } | |
| }); | |
| (0, _utils.default)("TSTypeLiteral", { | |
| aliases: ["TSType"], | |
| visitor: ["members"], | |
| fields: { | |
| members: (0, _utils.validateArrayOfType)("TSTypeElement") | |
| } | |
| }); | |
| (0, _utils.default)("TSArrayType", { | |
| aliases: ["TSType"], | |
| visitor: ["elementType"], | |
| fields: { | |
| elementType: (0, _utils.validateType)("TSType") | |
| } | |
| }); | |
| (0, _utils.default)("TSTupleType", { | |
| aliases: ["TSType"], | |
| visitor: ["elementTypes"], | |
| fields: { | |
| elementTypes: (0, _utils.validateArrayOfType)("TSType") | |
| } | |
| }); | |
| (0, _utils.default)("TSOptionalType", { | |
| aliases: ["TSType"], | |
| visitor: ["typeAnnotation"], | |
| fields: { | |
| typeAnnotation: (0, _utils.validateType)("TSType") | |
| } | |
| }); | |
| (0, _utils.default)("TSRestType", { | |
| aliases: ["TSType"], | |
| visitor: ["typeAnnotation"], | |
| fields: { | |
| typeAnnotation: (0, _utils.validateType)("TSType") | |
| } | |
| }); | |
| const unionOrIntersection = { | |
| aliases: ["TSType"], | |
| visitor: ["types"], | |
| fields: { | |
| types: (0, _utils.validateArrayOfType)("TSType") | |
| } | |
| }; | |
| (0, _utils.default)("TSUnionType", unionOrIntersection); | |
| (0, _utils.default)("TSIntersectionType", unionOrIntersection); | |
| (0, _utils.default)("TSConditionalType", { | |
| aliases: ["TSType"], | |
| visitor: ["checkType", "extendsType", "trueType", "falseType"], | |
| fields: { | |
| checkType: (0, _utils.validateType)("TSType"), | |
| extendsType: (0, _utils.validateType)("TSType"), | |
| trueType: (0, _utils.validateType)("TSType"), | |
| falseType: (0, _utils.validateType)("TSType") | |
| } | |
| }); | |
| (0, _utils.default)("TSInferType", { | |
| aliases: ["TSType"], | |
| visitor: ["typeParameter"], | |
| fields: { | |
| typeParameter: (0, _utils.validateType)("TSTypeParameter") | |
| } | |
| }); | |
| (0, _utils.default)("TSParenthesizedType", { | |
| aliases: ["TSType"], | |
| visitor: ["typeAnnotation"], | |
| fields: { | |
| typeAnnotation: (0, _utils.validateType)("TSType") | |
| } | |
| }); | |
| (0, _utils.default)("TSTypeOperator", { | |
| aliases: ["TSType"], | |
| visitor: ["typeAnnotation"], | |
| fields: { | |
| operator: (0, _utils.validate)((0, _utils.assertValueType)("string")), | |
| typeAnnotation: (0, _utils.validateType)("TSType") | |
| } | |
| }); | |
| (0, _utils.default)("TSIndexedAccessType", { | |
| aliases: ["TSType"], | |
| visitor: ["objectType", "indexType"], | |
| fields: { | |
| objectType: (0, _utils.validateType)("TSType"), | |
| indexType: (0, _utils.validateType)("TSType") | |
| } | |
| }); | |
| (0, _utils.default)("TSMappedType", { | |
| aliases: ["TSType"], | |
| visitor: ["typeParameter", "typeAnnotation"], | |
| fields: { | |
| readonly: (0, _utils.validateOptional)(bool), | |
| typeParameter: (0, _utils.validateType)("TSTypeParameter"), | |
| optional: (0, _utils.validateOptional)(bool), | |
| typeAnnotation: (0, _utils.validateOptionalType)("TSType") | |
| } | |
| }); | |
| (0, _utils.default)("TSLiteralType", { | |
| aliases: ["TSType"], | |
| visitor: ["literal"], | |
| fields: { | |
| literal: (0, _utils.validateType)(["NumericLiteral", "StringLiteral", "BooleanLiteral"]) | |
| } | |
| }); | |
| (0, _utils.default)("TSExpressionWithTypeArguments", { | |
| aliases: ["TSType"], | |
| visitor: ["expression", "typeParameters"], | |
| fields: { | |
| expression: (0, _utils.validateType)("TSEntityName"), | |
| typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") | |
| } | |
| }); | |
| (0, _utils.default)("TSInterfaceDeclaration", { | |
| aliases: ["Statement", "Declaration"], | |
| visitor: ["id", "typeParameters", "extends", "body"], | |
| fields: { | |
| declare: (0, _utils.validateOptional)(bool), | |
| id: (0, _utils.validateType)("Identifier"), | |
| typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), | |
| extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")), | |
| body: (0, _utils.validateType)("TSInterfaceBody") | |
| } | |
| }); | |
| (0, _utils.default)("TSInterfaceBody", { | |
| visitor: ["body"], | |
| fields: { | |
| body: (0, _utils.validateArrayOfType)("TSTypeElement") | |
| } | |
| }); | |
| (0, _utils.default)("TSTypeAliasDeclaration", { | |
| aliases: ["Statement", "Declaration"], | |
| visitor: ["id", "typeParameters", "typeAnnotation"], | |
| fields: { | |
| declare: (0, _utils.validateOptional)(bool), | |
| id: (0, _utils.validateType)("Identifier"), | |
| typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"), | |
| typeAnnotation: (0, _utils.validateType)("TSType") | |
| } | |
| }); | |
| (0, _utils.default)("TSAsExpression", { | |
| aliases: ["Expression"], | |
| visitor: ["expression", "typeAnnotation"], | |
| fields: { | |
| expression: (0, _utils.validateType)("Expression"), | |
| typeAnnotation: (0, _utils.validateType)("TSType") | |
| } | |
| }); | |
| (0, _utils.default)("TSTypeAssertion", { | |
| aliases: ["Expression"], | |
| visitor: ["typeAnnotation", "expression"], | |
| fields: { | |
| typeAnnotation: (0, _utils.validateType)("TSType"), | |
| expression: (0, _utils.validateType)("Expression") | |
| } | |
| }); | |
| (0, _utils.default)("TSEnumDeclaration", { | |
| aliases: ["Statement", "Declaration"], | |
| visitor: ["id", "members"], | |
| fields: { | |
| declare: (0, _utils.validateOptional)(bool), | |
| const: (0, _utils.validateOptional)(bool), | |
| id: (0, _utils.validateType)("Identifier"), | |
| members: (0, _utils.validateArrayOfType)("TSEnumMember"), | |
| initializer: (0, _utils.validateOptionalType)("Expression") | |
| } | |
| }); | |
| (0, _utils.default)("TSEnumMember", { | |
| visitor: ["id", "initializer"], | |
| fields: { | |
| id: (0, _utils.validateType)(["Identifier", "StringLiteral"]), | |
| initializer: (0, _utils.validateOptionalType)("Expression") | |
| } | |
| }); | |
| (0, _utils.default)("TSModuleDeclaration", { | |
| aliases: ["Statement", "Declaration"], | |
| visitor: ["id", "body"], | |
| fields: { | |
| declare: (0, _utils.validateOptional)(bool), | |
| global: (0, _utils.validateOptional)(bool), | |
| id: (0, _utils.validateType)(["Identifier", "StringLiteral"]), | |
| body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"]) | |
| } | |
| }); | |
| (0, _utils.default)("TSModuleBlock", { | |
| aliases: ["Scopable", "Block", "BlockParent"], | |
| visitor: ["body"], | |
| fields: { | |
| body: (0, _utils.validateArrayOfType)("Statement") | |
| } | |
| }); | |
| (0, _utils.default)("TSImportType", { | |
| aliases: ["TSType"], | |
| visitor: ["argument", "qualifier", "typeParameters"], | |
| fields: { | |
| argument: (0, _utils.validateType)("StringLiteral"), | |
| qualifier: (0, _utils.validateOptionalType)("TSEntityName"), | |
| typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") | |
| } | |
| }); | |
| (0, _utils.default)("TSImportEqualsDeclaration", { | |
| aliases: ["Statement"], | |
| visitor: ["id", "moduleReference"], | |
| fields: { | |
| isExport: (0, _utils.validate)(bool), | |
| id: (0, _utils.validateType)("Identifier"), | |
| moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"]) | |
| } | |
| }); | |
| (0, _utils.default)("TSExternalModuleReference", { | |
| visitor: ["expression"], | |
| fields: { | |
| expression: (0, _utils.validateType)("StringLiteral") | |
| } | |
| }); | |
| (0, _utils.default)("TSNonNullExpression", { | |
| aliases: ["Expression"], | |
| visitor: ["expression"], | |
| fields: { | |
| expression: (0, _utils.validateType)("Expression") | |
| } | |
| }); | |
| (0, _utils.default)("TSExportAssignment", { | |
| aliases: ["Statement"], | |
| visitor: ["expression"], | |
| fields: { | |
| expression: (0, _utils.validateType)("Expression") | |
| } | |
| }); | |
| (0, _utils.default)("TSNamespaceExportDeclaration", { | |
| aliases: ["Statement"], | |
| visitor: ["id"], | |
| fields: { | |
| id: (0, _utils.validateType)("Identifier") | |
| } | |
| }); | |
| (0, _utils.default)("TSTypeAnnotation", { | |
| visitor: ["typeAnnotation"], | |
| fields: { | |
| typeAnnotation: { | |
| validate: (0, _utils.assertNodeType)("TSType") | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("TSTypeParameterInstantiation", { | |
| visitor: ["params"], | |
| fields: { | |
| params: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType"))) | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("TSTypeParameterDeclaration", { | |
| visitor: ["params"], | |
| fields: { | |
| params: { | |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter"))) | |
| } | |
| } | |
| }); | |
| (0, _utils.default)("TSTypeParameter", { | |
| visitor: ["constraint", "default"], | |
| fields: { | |
| name: { | |
| validate: (0, _utils.assertValueType)("string") | |
| }, | |
| constraint: { | |
| validate: (0, _utils.assertNodeType)("TSType"), | |
| optional: true | |
| }, | |
| default: { | |
| validate: (0, _utils.assertNodeType)("TSType"), | |
| optional: true | |
| } | |
| } | |
| }); | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/definitions/utils.js": | |
| /*!*****************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/definitions/utils.js ***! | |
| \*****************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.validate = validate; | |
| exports.typeIs = typeIs; | |
| exports.validateType = validateType; | |
| exports.validateOptional = validateOptional; | |
| exports.validateOptionalType = validateOptionalType; | |
| exports.arrayOf = arrayOf; | |
| exports.arrayOfType = arrayOfType; | |
| exports.validateArrayOfType = validateArrayOfType; | |
| exports.assertEach = assertEach; | |
| exports.assertOneOf = assertOneOf; | |
| exports.assertNodeType = assertNodeType; | |
| exports.assertNodeOrValueType = assertNodeOrValueType; | |
| exports.assertValueType = assertValueType; | |
| exports.assertShape = assertShape; | |
| exports.chain = chain; | |
| exports.default = defineType; | |
| exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.ALIAS_KEYS = exports.VISITOR_KEYS = void 0; | |
| var _is = _interopRequireDefault(__webpack_require__(/*! ../validators/is */ "../babel-generator/node_modules/@babel/types/lib/validators/is.js")); | |
| var _validate = __webpack_require__(/*! ../validators/validate */ "../babel-generator/node_modules/@babel/types/lib/validators/validate.js"); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| const VISITOR_KEYS = {}; | |
| exports.VISITOR_KEYS = VISITOR_KEYS; | |
| const ALIAS_KEYS = {}; | |
| exports.ALIAS_KEYS = ALIAS_KEYS; | |
| const FLIPPED_ALIAS_KEYS = {}; | |
| exports.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS; | |
| const NODE_FIELDS = {}; | |
| exports.NODE_FIELDS = NODE_FIELDS; | |
| const BUILDER_KEYS = {}; | |
| exports.BUILDER_KEYS = BUILDER_KEYS; | |
| const DEPRECATED_KEYS = {}; | |
| exports.DEPRECATED_KEYS = DEPRECATED_KEYS; | |
| function getType(val) { | |
| if (Array.isArray(val)) { | |
| return "array"; | |
| } else if (val === null) { | |
| return "null"; | |
| } else if (val === undefined) { | |
| return "undefined"; | |
| } else { | |
| return typeof val; | |
| } | |
| } | |
| function validate(validate) { | |
| return { | |
| validate | |
| }; | |
| } | |
| function typeIs(typeName) { | |
| return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName); | |
| } | |
| function validateType(typeName) { | |
| return validate(typeIs(typeName)); | |
| } | |
| function validateOptional(validate) { | |
| return { | |
| validate, | |
| optional: true | |
| }; | |
| } | |
| function validateOptionalType(typeName) { | |
| return { | |
| validate: typeIs(typeName), | |
| optional: true | |
| }; | |
| } | |
| function arrayOf(elementType) { | |
| return chain(assertValueType("array"), assertEach(elementType)); | |
| } | |
| function arrayOfType(typeName) { | |
| return arrayOf(typeIs(typeName)); | |
| } | |
| function validateArrayOfType(typeName) { | |
| return validate(arrayOfType(typeName)); | |
| } | |
| function assertEach(callback) { | |
| function validator(node, key, val) { | |
| if (!Array.isArray(val)) return; | |
| for (let i = 0; i < val.length; i++) { | |
| callback(node, `${key}[${i}]`, val[i]); | |
| } | |
| } | |
| validator.each = callback; | |
| return validator; | |
| } | |
| function assertOneOf(...values) { | |
| function validate(node, key, val) { | |
| if (values.indexOf(val) < 0) { | |
| throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`); | |
| } | |
| } | |
| validate.oneOf = values; | |
| return validate; | |
| } | |
| function assertNodeType(...types) { | |
| function validate(node, key, val) { | |
| let valid = false; | |
| for (const type of types) { | |
| if ((0, _is.default)(type, val)) { | |
| valid = true; | |
| break; | |
| } | |
| } | |
| if (!valid) { | |
| throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} ` + `but instead got ${JSON.stringify(val && val.type)}`); | |
| } | |
| } | |
| validate.oneOfNodeTypes = types; | |
| return validate; | |
| } | |
| function assertNodeOrValueType(...types) { | |
| function validate(node, key, val) { | |
| let valid = false; | |
| for (const type of types) { | |
| if (getType(val) === type || (0, _is.default)(type, val)) { | |
| valid = true; | |
| break; | |
| } | |
| } | |
| if (!valid) { | |
| throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} ` + `but instead got ${JSON.stringify(val && val.type)}`); | |
| } | |
| } | |
| validate.oneOfNodeOrValueTypes = types; | |
| return validate; | |
| } | |
| function assertValueType(type) { | |
| function validate(node, key, val) { | |
| const valid = getType(val) === type; | |
| if (!valid) { | |
| throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`); | |
| } | |
| } | |
| validate.type = type; | |
| return validate; | |
| } | |
| function assertShape(shape) { | |
| function validate(node, key, val) { | |
| const errors = []; | |
| for (const property of Object.keys(shape)) { | |
| try { | |
| (0, _validate.validateField)(node, property, val[property], shape[property]); | |
| } catch (error) { | |
| if (error instanceof TypeError) { | |
| errors.push(error.message); | |
| continue; | |
| } | |
| throw error; | |
| } | |
| } | |
| if (errors.length) { | |
| throw new TypeError(`Property ${key} of ${node.type} expected to have the following:\n${errors.join("\n")}`); | |
| } | |
| } | |
| validate.shapeOf = shape; | |
| return validate; | |
| } | |
| function chain(...fns) { | |
| function validate(...args) { | |
| for (const fn of fns) { | |
| fn(...args); | |
| } | |
| } | |
| validate.chainOf = fns; | |
| return validate; | |
| } | |
| function defineType(type, opts = {}) { | |
| const inherits = opts.inherits && store[opts.inherits] || {}; | |
| const fields = opts.fields || inherits.fields || {}; | |
| const visitor = opts.visitor || inherits.visitor || []; | |
| const aliases = opts.aliases || inherits.aliases || []; | |
| const builder = opts.builder || inherits.builder || opts.visitor || []; | |
| if (opts.deprecatedAlias) { | |
| DEPRECATED_KEYS[opts.deprecatedAlias] = type; | |
| } | |
| for (const key of visitor.concat(builder)) { | |
| fields[key] = fields[key] || {}; | |
| } | |
| for (const key of Object.keys(fields)) { | |
| const field = fields[key]; | |
| if (builder.indexOf(key) === -1) { | |
| field.optional = true; | |
| } | |
| if (field.default === undefined) { | |
| field.default = null; | |
| } else if (!field.validate) { | |
| field.validate = assertValueType(getType(field.default)); | |
| } | |
| } | |
| VISITOR_KEYS[type] = opts.visitor = visitor; | |
| BUILDER_KEYS[type] = opts.builder = builder; | |
| NODE_FIELDS[type] = opts.fields = fields; | |
| ALIAS_KEYS[type] = opts.aliases = aliases; | |
| aliases.forEach(alias => { | |
| FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || []; | |
| FLIPPED_ALIAS_KEYS[alias].push(type); | |
| }); | |
| store[type] = opts; | |
| } | |
| const store = {}; | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/index.js": | |
| /*!*****************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/index.js ***! | |
| \*****************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| var _exportNames = { | |
| react: true, | |
| assertNode: true, | |
| createTypeAnnotationBasedOnTypeof: true, | |
| createUnionTypeAnnotation: true, | |
| cloneNode: true, | |
| clone: true, | |
| cloneDeep: true, | |
| cloneWithoutLoc: true, | |
| addComment: true, | |
| addComments: true, | |
| inheritInnerComments: true, | |
| inheritLeadingComments: true, | |
| inheritsComments: true, | |
| inheritTrailingComments: true, | |
| removeComments: true, | |
| ensureBlock: true, | |
| toBindingIdentifierName: true, | |
| toBlock: true, | |
| toComputedKey: true, | |
| toExpression: true, | |
| toIdentifier: true, | |
| toKeyAlias: true, | |
| toSequenceExpression: true, | |
| toStatement: true, | |
| valueToNode: true, | |
| appendToMemberExpression: true, | |
| inherits: true, | |
| prependToMemberExpression: true, | |
| removeProperties: true, | |
| removePropertiesDeep: true, | |
| removeTypeDuplicates: true, | |
| getBindingIdentifiers: true, | |
| getOuterBindingIdentifiers: true, | |
| traverse: true, | |
| traverseFast: true, | |
| shallowEqual: true, | |
| is: true, | |
| isBinding: true, | |
| isBlockScoped: true, | |
| isImmutable: true, | |
| isLet: true, | |
| isNode: true, | |
| isNodesEquivalent: true, | |
| isPlaceholderType: true, | |
| isReferenced: true, | |
| isScope: true, | |
| isSpecifierDefault: true, | |
| isType: true, | |
| isValidES3Identifier: true, | |
| isValidIdentifier: true, | |
| isVar: true, | |
| matchesPattern: true, | |
| validate: true, | |
| buildMatchMemberExpression: true | |
| }; | |
| Object.defineProperty(exports, "assertNode", { | |
| enumerable: true, | |
| get: function () { | |
| return _assertNode.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", { | |
| enumerable: true, | |
| get: function () { | |
| return _createTypeAnnotationBasedOnTypeof.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "createUnionTypeAnnotation", { | |
| enumerable: true, | |
| get: function () { | |
| return _createUnionTypeAnnotation.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "cloneNode", { | |
| enumerable: true, | |
| get: function () { | |
| return _cloneNode.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "clone", { | |
| enumerable: true, | |
| get: function () { | |
| return _clone.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "cloneDeep", { | |
| enumerable: true, | |
| get: function () { | |
| return _cloneDeep.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "cloneWithoutLoc", { | |
| enumerable: true, | |
| get: function () { | |
| return _cloneWithoutLoc.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "addComment", { | |
| enumerable: true, | |
| get: function () { | |
| return _addComment.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "addComments", { | |
| enumerable: true, | |
| get: function () { | |
| return _addComments.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "inheritInnerComments", { | |
| enumerable: true, | |
| get: function () { | |
| return _inheritInnerComments.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "inheritLeadingComments", { | |
| enumerable: true, | |
| get: function () { | |
| return _inheritLeadingComments.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "inheritsComments", { | |
| enumerable: true, | |
| get: function () { | |
| return _inheritsComments.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "inheritTrailingComments", { | |
| enumerable: true, | |
| get: function () { | |
| return _inheritTrailingComments.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "removeComments", { | |
| enumerable: true, | |
| get: function () { | |
| return _removeComments.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "ensureBlock", { | |
| enumerable: true, | |
| get: function () { | |
| return _ensureBlock.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "toBindingIdentifierName", { | |
| enumerable: true, | |
| get: function () { | |
| return _toBindingIdentifierName.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "toBlock", { | |
| enumerable: true, | |
| get: function () { | |
| return _toBlock.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "toComputedKey", { | |
| enumerable: true, | |
| get: function () { | |
| return _toComputedKey.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "toExpression", { | |
| enumerable: true, | |
| get: function () { | |
| return _toExpression.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "toIdentifier", { | |
| enumerable: true, | |
| get: function () { | |
| return _toIdentifier.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "toKeyAlias", { | |
| enumerable: true, | |
| get: function () { | |
| return _toKeyAlias.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "toSequenceExpression", { | |
| enumerable: true, | |
| get: function () { | |
| return _toSequenceExpression.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "toStatement", { | |
| enumerable: true, | |
| get: function () { | |
| return _toStatement.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "valueToNode", { | |
| enumerable: true, | |
| get: function () { | |
| return _valueToNode.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "appendToMemberExpression", { | |
| enumerable: true, | |
| get: function () { | |
| return _appendToMemberExpression.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "inherits", { | |
| enumerable: true, | |
| get: function () { | |
| return _inherits.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "prependToMemberExpression", { | |
| enumerable: true, | |
| get: function () { | |
| return _prependToMemberExpression.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "removeProperties", { | |
| enumerable: true, | |
| get: function () { | |
| return _removeProperties.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "removePropertiesDeep", { | |
| enumerable: true, | |
| get: function () { | |
| return _removePropertiesDeep.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "removeTypeDuplicates", { | |
| enumerable: true, | |
| get: function () { | |
| return _removeTypeDuplicates.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "getBindingIdentifiers", { | |
| enumerable: true, | |
| get: function () { | |
| return _getBindingIdentifiers.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "getOuterBindingIdentifiers", { | |
| enumerable: true, | |
| get: function () { | |
| return _getOuterBindingIdentifiers.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "traverse", { | |
| enumerable: true, | |
| get: function () { | |
| return _traverse.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "traverseFast", { | |
| enumerable: true, | |
| get: function () { | |
| return _traverseFast.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "shallowEqual", { | |
| enumerable: true, | |
| get: function () { | |
| return _shallowEqual.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "is", { | |
| enumerable: true, | |
| get: function () { | |
| return _is.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "isBinding", { | |
| enumerable: true, | |
| get: function () { | |
| return _isBinding.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "isBlockScoped", { | |
| enumerable: true, | |
| get: function () { | |
| return _isBlockScoped.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "isImmutable", { | |
| enumerable: true, | |
| get: function () { | |
| return _isImmutable.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "isLet", { | |
| enumerable: true, | |
| get: function () { | |
| return _isLet.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "isNode", { | |
| enumerable: true, | |
| get: function () { | |
| return _isNode.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "isNodesEquivalent", { | |
| enumerable: true, | |
| get: function () { | |
| return _isNodesEquivalent.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "isPlaceholderType", { | |
| enumerable: true, | |
| get: function () { | |
| return _isPlaceholderType.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "isReferenced", { | |
| enumerable: true, | |
| get: function () { | |
| return _isReferenced.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "isScope", { | |
| enumerable: true, | |
| get: function () { | |
| return _isScope.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "isSpecifierDefault", { | |
| enumerable: true, | |
| get: function () { | |
| return _isSpecifierDefault.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "isType", { | |
| enumerable: true, | |
| get: function () { | |
| return _isType.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "isValidES3Identifier", { | |
| enumerable: true, | |
| get: function () { | |
| return _isValidES3Identifier.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "isValidIdentifier", { | |
| enumerable: true, | |
| get: function () { | |
| return _isValidIdentifier.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "isVar", { | |
| enumerable: true, | |
| get: function () { | |
| return _isVar.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "matchesPattern", { | |
| enumerable: true, | |
| get: function () { | |
| return _matchesPattern.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "validate", { | |
| enumerable: true, | |
| get: function () { | |
| return _validate.default; | |
| } | |
| }); | |
| Object.defineProperty(exports, "buildMatchMemberExpression", { | |
| enumerable: true, | |
| get: function () { | |
| return _buildMatchMemberExpression.default; | |
| } | |
| }); | |
| exports.react = void 0; | |
| var _isReactComponent = _interopRequireDefault(__webpack_require__(/*! ./validators/react/isReactComponent */ "../babel-generator/node_modules/@babel/types/lib/validators/react/isReactComponent.js")); | |
| var _isCompatTag = _interopRequireDefault(__webpack_require__(/*! ./validators/react/isCompatTag */ "../babel-generator/node_modules/@babel/types/lib/validators/react/isCompatTag.js")); | |
| var _buildChildren = _interopRequireDefault(__webpack_require__(/*! ./builders/react/buildChildren */ "../babel-generator/node_modules/@babel/types/lib/builders/react/buildChildren.js")); | |
| var _assertNode = _interopRequireDefault(__webpack_require__(/*! ./asserts/assertNode */ "../babel-generator/node_modules/@babel/types/lib/asserts/assertNode.js")); | |
| var _generated = __webpack_require__(/*! ./asserts/generated */ "../babel-generator/node_modules/@babel/types/lib/asserts/generated/index.js"); | |
| Object.keys(_generated).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _generated[key]; | |
| } | |
| }); | |
| }); | |
| var _createTypeAnnotationBasedOnTypeof = _interopRequireDefault(__webpack_require__(/*! ./builders/flow/createTypeAnnotationBasedOnTypeof */ "../babel-generator/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js")); | |
| var _createUnionTypeAnnotation = _interopRequireDefault(__webpack_require__(/*! ./builders/flow/createUnionTypeAnnotation */ "../babel-generator/node_modules/@babel/types/lib/builders/flow/createUnionTypeAnnotation.js")); | |
| var _generated2 = __webpack_require__(/*! ./builders/generated */ "../babel-generator/node_modules/@babel/types/lib/builders/generated/index.js"); | |
| Object.keys(_generated2).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _generated2[key]; | |
| } | |
| }); | |
| }); | |
| var _cloneNode = _interopRequireDefault(__webpack_require__(/*! ./clone/cloneNode */ "../babel-generator/node_modules/@babel/types/lib/clone/cloneNode.js")); | |
| var _clone = _interopRequireDefault(__webpack_require__(/*! ./clone/clone */ "../babel-generator/node_modules/@babel/types/lib/clone/clone.js")); | |
| var _cloneDeep = _interopRequireDefault(__webpack_require__(/*! ./clone/cloneDeep */ "../babel-generator/node_modules/@babel/types/lib/clone/cloneDeep.js")); | |
| var _cloneWithoutLoc = _interopRequireDefault(__webpack_require__(/*! ./clone/cloneWithoutLoc */ "../babel-generator/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js")); | |
| var _addComment = _interopRequireDefault(__webpack_require__(/*! ./comments/addComment */ "../babel-generator/node_modules/@babel/types/lib/comments/addComment.js")); | |
| var _addComments = _interopRequireDefault(__webpack_require__(/*! ./comments/addComments */ "../babel-generator/node_modules/@babel/types/lib/comments/addComments.js")); | |
| var _inheritInnerComments = _interopRequireDefault(__webpack_require__(/*! ./comments/inheritInnerComments */ "../babel-generator/node_modules/@babel/types/lib/comments/inheritInnerComments.js")); | |
| var _inheritLeadingComments = _interopRequireDefault(__webpack_require__(/*! ./comments/inheritLeadingComments */ "../babel-generator/node_modules/@babel/types/lib/comments/inheritLeadingComments.js")); | |
| var _inheritsComments = _interopRequireDefault(__webpack_require__(/*! ./comments/inheritsComments */ "../babel-generator/node_modules/@babel/types/lib/comments/inheritsComments.js")); | |
| var _inheritTrailingComments = _interopRequireDefault(__webpack_require__(/*! ./comments/inheritTrailingComments */ "../babel-generator/node_modules/@babel/types/lib/comments/inheritTrailingComments.js")); | |
| var _removeComments = _interopRequireDefault(__webpack_require__(/*! ./comments/removeComments */ "../babel-generator/node_modules/@babel/types/lib/comments/removeComments.js")); | |
| var _generated3 = __webpack_require__(/*! ./constants/generated */ "../babel-generator/node_modules/@babel/types/lib/constants/generated/index.js"); | |
| Object.keys(_generated3).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _generated3[key]; | |
| } | |
| }); | |
| }); | |
| var _constants = __webpack_require__(/*! ./constants */ "../babel-generator/node_modules/@babel/types/lib/constants/index.js"); | |
| Object.keys(_constants).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _constants[key]; | |
| } | |
| }); | |
| }); | |
| var _ensureBlock = _interopRequireDefault(__webpack_require__(/*! ./converters/ensureBlock */ "../babel-generator/node_modules/@babel/types/lib/converters/ensureBlock.js")); | |
| var _toBindingIdentifierName = _interopRequireDefault(__webpack_require__(/*! ./converters/toBindingIdentifierName */ "../babel-generator/node_modules/@babel/types/lib/converters/toBindingIdentifierName.js")); | |
| var _toBlock = _interopRequireDefault(__webpack_require__(/*! ./converters/toBlock */ "../babel-generator/node_modules/@babel/types/lib/converters/toBlock.js")); | |
| var _toComputedKey = _interopRequireDefault(__webpack_require__(/*! ./converters/toComputedKey */ "../babel-generator/node_modules/@babel/types/lib/converters/toComputedKey.js")); | |
| var _toExpression = _interopRequireDefault(__webpack_require__(/*! ./converters/toExpression */ "../babel-generator/node_modules/@babel/types/lib/converters/toExpression.js")); | |
| var _toIdentifier = _interopRequireDefault(__webpack_require__(/*! ./converters/toIdentifier */ "../babel-generator/node_modules/@babel/types/lib/converters/toIdentifier.js")); | |
| var _toKeyAlias = _interopRequireDefault(__webpack_require__(/*! ./converters/toKeyAlias */ "../babel-generator/node_modules/@babel/types/lib/converters/toKeyAlias.js")); | |
| var _toSequenceExpression = _interopRequireDefault(__webpack_require__(/*! ./converters/toSequenceExpression */ "../babel-generator/node_modules/@babel/types/lib/converters/toSequenceExpression.js")); | |
| var _toStatement = _interopRequireDefault(__webpack_require__(/*! ./converters/toStatement */ "../babel-generator/node_modules/@babel/types/lib/converters/toStatement.js")); | |
| var _valueToNode = _interopRequireDefault(__webpack_require__(/*! ./converters/valueToNode */ "../babel-generator/node_modules/@babel/types/lib/converters/valueToNode.js")); | |
| var _definitions = __webpack_require__(/*! ./definitions */ "../babel-generator/node_modules/@babel/types/lib/definitions/index.js"); | |
| Object.keys(_definitions).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _definitions[key]; | |
| } | |
| }); | |
| }); | |
| var _appendToMemberExpression = _interopRequireDefault(__webpack_require__(/*! ./modifications/appendToMemberExpression */ "../babel-generator/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js")); | |
| var _inherits = _interopRequireDefault(__webpack_require__(/*! ./modifications/inherits */ "../babel-generator/node_modules/@babel/types/lib/modifications/inherits.js")); | |
| var _prependToMemberExpression = _interopRequireDefault(__webpack_require__(/*! ./modifications/prependToMemberExpression */ "../babel-generator/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js")); | |
| var _removeProperties = _interopRequireDefault(__webpack_require__(/*! ./modifications/removeProperties */ "../babel-generator/node_modules/@babel/types/lib/modifications/removeProperties.js")); | |
| var _removePropertiesDeep = _interopRequireDefault(__webpack_require__(/*! ./modifications/removePropertiesDeep */ "../babel-generator/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js")); | |
| var _removeTypeDuplicates = _interopRequireDefault(__webpack_require__(/*! ./modifications/flow/removeTypeDuplicates */ "../babel-generator/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js")); | |
| var _getBindingIdentifiers = _interopRequireDefault(__webpack_require__(/*! ./retrievers/getBindingIdentifiers */ "../babel-generator/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js")); | |
| var _getOuterBindingIdentifiers = _interopRequireDefault(__webpack_require__(/*! ./retrievers/getOuterBindingIdentifiers */ "../babel-generator/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js")); | |
| var _traverse = _interopRequireDefault(__webpack_require__(/*! ./traverse/traverse */ "../babel-generator/node_modules/@babel/types/lib/traverse/traverse.js")); | |
| var _traverseFast = _interopRequireDefault(__webpack_require__(/*! ./traverse/traverseFast */ "../babel-generator/node_modules/@babel/types/lib/traverse/traverseFast.js")); | |
| var _shallowEqual = _interopRequireDefault(__webpack_require__(/*! ./utils/shallowEqual */ "../babel-generator/node_modules/@babel/types/lib/utils/shallowEqual.js")); | |
| var _is = _interopRequireDefault(__webpack_require__(/*! ./validators/is */ "../babel-generator/node_modules/@babel/types/lib/validators/is.js")); | |
| var _isBinding = _interopRequireDefault(__webpack_require__(/*! ./validators/isBinding */ "../babel-generator/node_modules/@babel/types/lib/validators/isBinding.js")); | |
| var _isBlockScoped = _interopRequireDefault(__webpack_require__(/*! ./validators/isBlockScoped */ "../babel-generator/node_modules/@babel/types/lib/validators/isBlockScoped.js")); | |
| var _isImmutable = _interopRequireDefault(__webpack_require__(/*! ./validators/isImmutable */ "../babel-generator/node_modules/@babel/types/lib/validators/isImmutable.js")); | |
| var _isLet = _interopRequireDefault(__webpack_require__(/*! ./validators/isLet */ "../babel-generator/node_modules/@babel/types/lib/validators/isLet.js")); | |
| var _isNode = _interopRequireDefault(__webpack_require__(/*! ./validators/isNode */ "../babel-generator/node_modules/@babel/types/lib/validators/isNode.js")); | |
| var _isNodesEquivalent = _interopRequireDefault(__webpack_require__(/*! ./validators/isNodesEquivalent */ "../babel-generator/node_modules/@babel/types/lib/validators/isNodesEquivalent.js")); | |
| var _isPlaceholderType = _interopRequireDefault(__webpack_require__(/*! ./validators/isPlaceholderType */ "../babel-generator/node_modules/@babel/types/lib/validators/isPlaceholderType.js")); | |
| var _isReferenced = _interopRequireDefault(__webpack_require__(/*! ./validators/isReferenced */ "../babel-generator/node_modules/@babel/types/lib/validators/isReferenced.js")); | |
| var _isScope = _interopRequireDefault(__webpack_require__(/*! ./validators/isScope */ "../babel-generator/node_modules/@babel/types/lib/validators/isScope.js")); | |
| var _isSpecifierDefault = _interopRequireDefault(__webpack_require__(/*! ./validators/isSpecifierDefault */ "../babel-generator/node_modules/@babel/types/lib/validators/isSpecifierDefault.js")); | |
| var _isType = _interopRequireDefault(__webpack_require__(/*! ./validators/isType */ "../babel-generator/node_modules/@babel/types/lib/validators/isType.js")); | |
| var _isValidES3Identifier = _interopRequireDefault(__webpack_require__(/*! ./validators/isValidES3Identifier */ "../babel-generator/node_modules/@babel/types/lib/validators/isValidES3Identifier.js")); | |
| var _isValidIdentifier = _interopRequireDefault(__webpack_require__(/*! ./validators/isValidIdentifier */ "../babel-generator/node_modules/@babel/types/lib/validators/isValidIdentifier.js")); | |
| var _isVar = _interopRequireDefault(__webpack_require__(/*! ./validators/isVar */ "../babel-generator/node_modules/@babel/types/lib/validators/isVar.js")); | |
| var _matchesPattern = _interopRequireDefault(__webpack_require__(/*! ./validators/matchesPattern */ "../babel-generator/node_modules/@babel/types/lib/validators/matchesPattern.js")); | |
| var _validate = _interopRequireDefault(__webpack_require__(/*! ./validators/validate */ "../babel-generator/node_modules/@babel/types/lib/validators/validate.js")); | |
| var _buildMatchMemberExpression = _interopRequireDefault(__webpack_require__(/*! ./validators/buildMatchMemberExpression */ "../babel-generator/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js")); | |
| var _generated4 = __webpack_require__(/*! ./validators/generated */ "../babel-generator/node_modules/@babel/types/lib/validators/generated/index.js"); | |
| Object.keys(_generated4).forEach(function (key) { | |
| if (key === "default" || key === "__esModule") return; | |
| if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; | |
| Object.defineProperty(exports, key, { | |
| enumerable: true, | |
| get: function () { | |
| return _generated4[key]; | |
| } | |
| }); | |
| }); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| const react = { | |
| isReactComponent: _isReactComponent.default, | |
| isCompatTag: _isCompatTag.default, | |
| buildChildren: _buildChildren.default | |
| }; | |
| exports.react = react; | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js": | |
| /*!**************************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js ***! | |
| \**************************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = appendToMemberExpression; | |
| var _generated = __webpack_require__(/*! ../builders/generated */ "../babel-generator/node_modules/@babel/types/lib/builders/generated/index.js"); | |
| function appendToMemberExpression(member, append, computed = false) { | |
| member.object = (0, _generated.memberExpression)(member.object, member.property, member.computed); | |
| member.property = append; | |
| member.computed = !!computed; | |
| return member; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js": | |
| /*!***************************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js ***! | |
| \***************************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = removeTypeDuplicates; | |
| var _generated = __webpack_require__(/*! ../../validators/generated */ "../babel-generator/node_modules/@babel/types/lib/validators/generated/index.js"); | |
| function removeTypeDuplicates(nodes) { | |
| const generics = {}; | |
| const bases = {}; | |
| const typeGroups = []; | |
| const types = []; | |
| for (let i = 0; i < nodes.length; i++) { | |
| const node = nodes[i]; | |
| if (!node) continue; | |
| if (types.indexOf(node) >= 0) { | |
| continue; | |
| } | |
| if ((0, _generated.isAnyTypeAnnotation)(node)) { | |
| return [node]; | |
| } | |
| if ((0, _generated.isFlowBaseAnnotation)(node)) { | |
| bases[node.type] = node; | |
| continue; | |
| } | |
| if ((0, _generated.isUnionTypeAnnotation)(node)) { | |
| if (typeGroups.indexOf(node.types) < 0) { | |
| nodes = nodes.concat(node.types); | |
| typeGroups.push(node.types); | |
| } | |
| continue; | |
| } | |
| if ((0, _generated.isGenericTypeAnnotation)(node)) { | |
| const name = node.id.name; | |
| if (generics[name]) { | |
| let existing = generics[name]; | |
| if (existing.typeParameters) { | |
| if (node.typeParameters) { | |
| existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node.typeParameters.params)); | |
| } | |
| } else { | |
| existing = node.typeParameters; | |
| } | |
| } else { | |
| generics[name] = node; | |
| } | |
| continue; | |
| } | |
| types.push(node); | |
| } | |
| for (const type of Object.keys(bases)) { | |
| types.push(bases[type]); | |
| } | |
| for (const name of Object.keys(generics)) { | |
| types.push(generics[name]); | |
| } | |
| return types; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/modifications/inherits.js": | |
| /*!**********************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/modifications/inherits.js ***! | |
| \**********************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = inherits; | |
| var _constants = __webpack_require__(/*! ../constants */ "../babel-generator/node_modules/@babel/types/lib/constants/index.js"); | |
| var _inheritsComments = _interopRequireDefault(__webpack_require__(/*! ../comments/inheritsComments */ "../babel-generator/node_modules/@babel/types/lib/comments/inheritsComments.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function inherits(child, parent) { | |
| if (!child || !parent) return child; | |
| for (const key of _constants.INHERIT_KEYS.optional) { | |
| if (child[key] == null) { | |
| child[key] = parent[key]; | |
| } | |
| } | |
| for (const key of Object.keys(parent)) { | |
| if (key[0] === "_" && key !== "__clone") child[key] = parent[key]; | |
| } | |
| for (const key of _constants.INHERIT_KEYS.force) { | |
| child[key] = parent[key]; | |
| } | |
| (0, _inheritsComments.default)(child, parent); | |
| return child; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js": | |
| /*!***************************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js ***! | |
| \***************************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = prependToMemberExpression; | |
| var _generated = __webpack_require__(/*! ../builders/generated */ "../babel-generator/node_modules/@babel/types/lib/builders/generated/index.js"); | |
| function prependToMemberExpression(member, prepend) { | |
| member.object = (0, _generated.memberExpression)(prepend, member.object); | |
| return member; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/modifications/removeProperties.js": | |
| /*!******************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/modifications/removeProperties.js ***! | |
| \******************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = removeProperties; | |
| var _constants = __webpack_require__(/*! ../constants */ "../babel-generator/node_modules/@babel/types/lib/constants/index.js"); | |
| const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"]; | |
| const CLEAR_KEYS_PLUS_COMMENTS = _constants.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS); | |
| function removeProperties(node, opts = {}) { | |
| const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS; | |
| for (const key of map) { | |
| if (node[key] != null) node[key] = undefined; | |
| } | |
| for (const key of Object.keys(node)) { | |
| if (key[0] === "_" && node[key] != null) node[key] = undefined; | |
| } | |
| const symbols = Object.getOwnPropertySymbols(node); | |
| for (const sym of symbols) { | |
| node[sym] = null; | |
| } | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js": | |
| /*!**********************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js ***! | |
| \**********************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = removePropertiesDeep; | |
| var _traverseFast = _interopRequireDefault(__webpack_require__(/*! ../traverse/traverseFast */ "../babel-generator/node_modules/@babel/types/lib/traverse/traverseFast.js")); | |
| var _removeProperties = _interopRequireDefault(__webpack_require__(/*! ./removeProperties */ "../babel-generator/node_modules/@babel/types/lib/modifications/removeProperties.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function removePropertiesDeep(tree, opts) { | |
| (0, _traverseFast.default)(tree, _removeProperties.default, opts); | |
| return tree; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js": | |
| /*!********************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js ***! | |
| \********************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = getBindingIdentifiers; | |
| var _generated = __webpack_require__(/*! ../validators/generated */ "../babel-generator/node_modules/@babel/types/lib/validators/generated/index.js"); | |
| function getBindingIdentifiers(node, duplicates, outerOnly) { | |
| let search = [].concat(node); | |
| const ids = Object.create(null); | |
| while (search.length) { | |
| const id = search.shift(); | |
| if (!id) continue; | |
| const keys = getBindingIdentifiers.keys[id.type]; | |
| if ((0, _generated.isIdentifier)(id)) { | |
| if (duplicates) { | |
| const _ids = ids[id.name] = ids[id.name] || []; | |
| _ids.push(id); | |
| } else { | |
| ids[id.name] = id; | |
| } | |
| continue; | |
| } | |
| if ((0, _generated.isExportDeclaration)(id)) { | |
| if ((0, _generated.isDeclaration)(id.declaration)) { | |
| search.push(id.declaration); | |
| } | |
| continue; | |
| } | |
| if (outerOnly) { | |
| if ((0, _generated.isFunctionDeclaration)(id)) { | |
| search.push(id.id); | |
| continue; | |
| } | |
| if ((0, _generated.isFunctionExpression)(id)) { | |
| continue; | |
| } | |
| } | |
| if (keys) { | |
| for (let i = 0; i < keys.length; i++) { | |
| const key = keys[i]; | |
| if (id[key]) { | |
| search = search.concat(id[key]); | |
| } | |
| } | |
| } | |
| } | |
| return ids; | |
| } | |
| getBindingIdentifiers.keys = { | |
| DeclareClass: ["id"], | |
| DeclareFunction: ["id"], | |
| DeclareModule: ["id"], | |
| DeclareVariable: ["id"], | |
| DeclareInterface: ["id"], | |
| DeclareTypeAlias: ["id"], | |
| DeclareOpaqueType: ["id"], | |
| InterfaceDeclaration: ["id"], | |
| TypeAlias: ["id"], | |
| OpaqueType: ["id"], | |
| CatchClause: ["param"], | |
| LabeledStatement: ["label"], | |
| UnaryExpression: ["argument"], | |
| AssignmentExpression: ["left"], | |
| ImportSpecifier: ["local"], | |
| ImportNamespaceSpecifier: ["local"], | |
| ImportDefaultSpecifier: ["local"], | |
| ImportDeclaration: ["specifiers"], | |
| ExportSpecifier: ["exported"], | |
| ExportNamespaceSpecifier: ["exported"], | |
| ExportDefaultSpecifier: ["exported"], | |
| FunctionDeclaration: ["id", "params"], | |
| FunctionExpression: ["id", "params"], | |
| ArrowFunctionExpression: ["params"], | |
| ObjectMethod: ["params"], | |
| ClassMethod: ["params"], | |
| ForInStatement: ["left"], | |
| ForOfStatement: ["left"], | |
| ClassDeclaration: ["id"], | |
| ClassExpression: ["id"], | |
| RestElement: ["argument"], | |
| UpdateExpression: ["argument"], | |
| ObjectProperty: ["value"], | |
| AssignmentPattern: ["left"], | |
| ArrayPattern: ["elements"], | |
| ObjectPattern: ["properties"], | |
| VariableDeclaration: ["declarations"], | |
| VariableDeclarator: ["id"] | |
| }; | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js": | |
| /*!*************************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js ***! | |
| \*************************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = getOuterBindingIdentifiers; | |
| var _getBindingIdentifiers = _interopRequireDefault(__webpack_require__(/*! ./getBindingIdentifiers */ "../babel-generator/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function getOuterBindingIdentifiers(node, duplicates) { | |
| return (0, _getBindingIdentifiers.default)(node, duplicates, true); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/traverse/traverse.js": | |
| /*!*****************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/traverse/traverse.js ***! | |
| \*****************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = traverse; | |
| var _definitions = __webpack_require__(/*! ../definitions */ "../babel-generator/node_modules/@babel/types/lib/definitions/index.js"); | |
| function traverse(node, handlers, state) { | |
| if (typeof handlers === "function") { | |
| handlers = { | |
| enter: handlers | |
| }; | |
| } | |
| const { | |
| enter, | |
| exit | |
| } = handlers; | |
| traverseSimpleImpl(node, enter, exit, state, []); | |
| } | |
| function traverseSimpleImpl(node, enter, exit, state, ancestors) { | |
| const keys = _definitions.VISITOR_KEYS[node.type]; | |
| if (!keys) return; | |
| if (enter) enter(node, ancestors, state); | |
| for (const key of keys) { | |
| const subNode = node[key]; | |
| if (Array.isArray(subNode)) { | |
| for (let i = 0; i < subNode.length; i++) { | |
| const child = subNode[i]; | |
| if (!child) continue; | |
| ancestors.push({ | |
| node, | |
| key, | |
| index: i | |
| }); | |
| traverseSimpleImpl(child, enter, exit, state, ancestors); | |
| ancestors.pop(); | |
| } | |
| } else if (subNode) { | |
| ancestors.push({ | |
| node, | |
| key | |
| }); | |
| traverseSimpleImpl(subNode, enter, exit, state, ancestors); | |
| ancestors.pop(); | |
| } | |
| } | |
| if (exit) exit(node, ancestors, state); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/traverse/traverseFast.js": | |
| /*!*********************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/traverse/traverseFast.js ***! | |
| \*********************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = traverseFast; | |
| var _definitions = __webpack_require__(/*! ../definitions */ "../babel-generator/node_modules/@babel/types/lib/definitions/index.js"); | |
| function traverseFast(node, enter, opts) { | |
| if (!node) return; | |
| const keys = _definitions.VISITOR_KEYS[node.type]; | |
| if (!keys) return; | |
| opts = opts || {}; | |
| enter(node, opts); | |
| for (const key of keys) { | |
| const subNode = node[key]; | |
| if (Array.isArray(subNode)) { | |
| for (const node of subNode) { | |
| traverseFast(node, enter, opts); | |
| } | |
| } else { | |
| traverseFast(subNode, enter, opts); | |
| } | |
| } | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/utils/inherit.js": | |
| /*!*************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/utils/inherit.js ***! | |
| \*************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = inherit; | |
| function _uniq() { | |
| const data = _interopRequireDefault(__webpack_require__(/*! lodash/uniq */ "../babel-generator/node_modules/lodash/uniq.js")); | |
| _uniq = function () { | |
| return data; | |
| }; | |
| return data; | |
| } | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function inherit(key, child, parent) { | |
| if (child && parent) { | |
| child[key] = (0, _uniq().default)([].concat(child[key], parent[key]).filter(Boolean)); | |
| } | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js": | |
| /*!***************************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js ***! | |
| \***************************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = cleanJSXElementLiteralChild; | |
| var _generated = __webpack_require__(/*! ../../builders/generated */ "../babel-generator/node_modules/@babel/types/lib/builders/generated/index.js"); | |
| function cleanJSXElementLiteralChild(child, args) { | |
| const lines = child.value.split(/\r\n|\n|\r/); | |
| let lastNonEmptyLine = 0; | |
| for (let i = 0; i < lines.length; i++) { | |
| if (lines[i].match(/[^ \t]/)) { | |
| lastNonEmptyLine = i; | |
| } | |
| } | |
| let str = ""; | |
| for (let i = 0; i < lines.length; i++) { | |
| const line = lines[i]; | |
| const isFirstLine = i === 0; | |
| const isLastLine = i === lines.length - 1; | |
| const isLastNonEmptyLine = i === lastNonEmptyLine; | |
| let trimmedLine = line.replace(/\t/g, " "); | |
| if (!isFirstLine) { | |
| trimmedLine = trimmedLine.replace(/^[ ]+/, ""); | |
| } | |
| if (!isLastLine) { | |
| trimmedLine = trimmedLine.replace(/[ ]+$/, ""); | |
| } | |
| if (trimmedLine) { | |
| if (!isLastNonEmptyLine) { | |
| trimmedLine += " "; | |
| } | |
| str += trimmedLine; | |
| } | |
| } | |
| if (str) args.push((0, _generated.stringLiteral)(str)); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/utils/shallowEqual.js": | |
| /*!******************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/utils/shallowEqual.js ***! | |
| \******************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = shallowEqual; | |
| function shallowEqual(actual, expected) { | |
| const keys = Object.keys(expected); | |
| for (const key of keys) { | |
| if (actual[key] !== expected[key]) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js": | |
| /*!*************************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js ***! | |
| \*************************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.default = buildMatchMemberExpression; | |
| var _matchesPattern = _interopRequireDefault(__webpack_require__(/*! ./matchesPattern */ "../babel-generator/node_modules/@babel/types/lib/validators/matchesPattern.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function buildMatchMemberExpression(match, allowPartial) { | |
| const parts = match.split("."); | |
| return member => (0, _matchesPattern.default)(member, parts, allowPartial); | |
| } | |
| /***/ }), | |
| /***/ "../babel-generator/node_modules/@babel/types/lib/validators/generated/index.js": | |
| /*!**************************************************************************************!*\ | |
| !*** ../babel-generator/node_modules/@babel/types/lib/validators/generated/index.js ***! | |
| \**************************************************************************************/ | |
| /*! no static exports found */ | |
| /***/ (function(module, exports, __webpack_require__) { | |
| "use strict"; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.isArrayExpression = isArrayExpression; | |
| exports.isAssignmentExpression = isAssignmentExpression; | |
| exports.isBinaryExpression = isBinaryExpression; | |
| exports.isInterpreterDirective = isInterpreterDirective; | |
| exports.isDirective = isDirective; | |
| exports.isDirectiveLiteral = isDirectiveLiteral; | |
| exports.isBlockStatement = isBlockStatement; | |
| exports.isBreakStatement = isBreakStatement; | |
| exports.isCallExpression = isCallExpression; | |
| exports.isCatchClause = isCatchClause; | |
| exports.isConditionalExpression = isConditionalExpression; | |
| exports.isContinueStatement = isContinueStatement; | |
| exports.isDebuggerStatement = isDebuggerStatement; | |
| exports.isDoWhileStatement = isDoWhileStatement; | |
| exports.isEmptyStatement = isEmptyStatement; | |
| exports.isExpressionStatement = isExpressionStatement; | |
| exports.isFile = isFile; | |
| exports.isForInStatement = isForInStatement; | |
| exports.isForStatement = isForStatement; | |
| exports.isFunctionDeclaration = isFunctionDeclaration; | |
| exports.isFunctionExpression = isFunctionExpression; | |
| exports.isIdentifier = isIdentifier; | |
| exports.isIfStatement = isIfStatement; | |
| exports.isLabeledStatement = isLabeledStatement; | |
| exports.isStringLiteral = isStringLiteral; | |
| exports.isNumericLiteral = isNumericLiteral; | |
| exports.isNullLiteral = isNullLiteral; | |
| exports.isBooleanLiteral = isBooleanLiteral; | |
| exports.isRegExpLiteral = isRegExpLiteral; | |
| exports.isLogicalExpression = isLogicalExpression; | |
| exports.isMemberExpression = isMemberExpression; | |
| exports.isNewExpression = isNewExpression; | |
| exports.isProgram = isProgram; | |
| exports.isObjectExpression = isObjectExpression; | |
| exports.isObjectMethod = isObjectMethod; | |
| exports.isObjectProperty = isObjectProperty; | |
| exports.isRestElement = isRestElement; | |
| exports.isReturnStatement = isReturnStatement; | |
| exports.isSequenceExpression = isSequenceExpression; | |
| exports.isParenthesizedExpression = isParenthesizedExpression; | |
| exports.isSwitchCase = isSwitchCase; | |
| exports.isSwitchStatement = isSwitchStatement; | |
| exports.isThisExpression = isThisExpression; | |
| exports.isThrowStatement = isThrowStatement; | |
| exports.isTryStatement = isTryStatement; | |
| exports.isUnaryExpression = isUnaryExpression; | |
| exports.isUpdateExpression = isUpdateExpression; | |
| exports.isVariableDeclaration = isVariableDeclaration; | |
| exports.isVariableDeclarator = isVariableDeclarator; | |
| exports.isWhileStatement = isWhileStatement; | |
| exports.isWithStatement = isWithStatement; | |
| exports.isAssignmentPattern = isAssignmentPattern; | |
| exports.isArrayPattern = isArrayPattern; | |
| exports.isArrowFunctionExpression = isArrowFunctionExpression; | |
| exports.isClassBody = isClassBody; | |
| exports.isClassDeclaration = isClassDeclaration; | |
| exports.isClassExpression = isClassExpression; | |
| exports.isExportAllDeclaration = isExportAllDeclaration; | |
| exports.isExportDefaultDeclaration = isExportDefaultDeclaration; | |
| exports.isExportNamedDeclaration = isExportNamedDeclaration; | |
| exports.isExportSpecifier = isExportSpecifier; | |
| exports.isForOfStatement = isForOfStatement; | |
| exports.isImportDeclaration = isImportDeclaration; | |
| exports.isImportDefaultSpecifier = isImportDefaultSpecifier; | |
| exports.isImportNamespaceSpecifier = isImportNamespaceSpecifier; | |
| exports.isImportSpecifier = isImportSpecifier; | |
| exports.isMetaProperty = isMetaProperty; | |
| exports.isClassMethod = isClassMethod; | |
| exports.isObjectPattern = isObjectPattern; | |
| exports.isSpreadElement = isSpreadElement; | |
| exports.isSuper = isSuper; | |
| exports.isTaggedTemplateExpression = isTaggedTemplateExpression; | |
| exports.isTemplateElement = isTemplateElement; | |
| exports.isTemplateLiteral = isTemplateLiteral; | |
| exports.isYieldExpression = isYieldExpression; | |
| exports.isAnyTypeAnnotation = isAnyTypeAnnotation; | |
| exports.isArrayTypeAnnotation = isArrayTypeAnnotation; | |
| exports.isBooleanTypeAnnotation = isBooleanTypeAnnotation; | |
| exports.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation; | |
| exports.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation; | |
| exports.isClassImplements = isClassImplements; | |
| exports.isDeclareClass = isDeclareClass; | |
| exports.isDeclareFunction = isDeclareFunction; | |
| exports.isDeclareInterface = isDeclareInterface; | |
| exports.isDeclareModule = isDeclareModule; | |
| exports.isDeclareModuleExports = isDeclareModuleExports; | |
| exports.isDeclareTypeAlias = isDeclareTypeAlias; | |
| exports.isDeclareOpaqueType = isDeclareOpaqueType; | |
| exports.isDeclareVariable = isDeclareVariable; | |
| exports.isDeclareExportDeclaration = isDeclareExportDeclaration; | |
| exports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration; | |
| exports.isDeclaredPredicate = isDeclaredPredicate; | |
| exports.isExistsTypeAnnotation = isExistsTypeAnnotation; | |
| exports.isFunctionTypeAnnotation = isFunctionTypeAnnotation; | |
| exports.isFunctionTypeParam = isFunctionTypeParam; | |
| exports.isGenericTypeAnnotation = isGenericTypeAnnotation; | |
| exports.isInferredPredicate = isInferredPredicate; | |
| exports.isInterfaceExtends = isInterfaceExtends; | |
| exports.isInterfaceDeclaration = isInterfaceDeclaration; | |
| exports.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation; | |
| exports.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation; | |
| exports.isMixedTypeAnnotation = isMixedTypeAnnotation; | |
| exports.isEmptyTypeAnnotation = isEmptyTypeAnnotation; | |
| exports.isNullableTypeAnnotation = isNullableTypeAnnotation; | |
| exports.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation; | |
| exports.isNumberTypeAnnotation = isNumberTypeAnnotation; | |
| exports.isObjectTypeAnnotation = isObjectTypeAnnotation; | |
| exports.isObjectTypeInternalSlot = isObjectTypeInternalSlot; | |
| exports.isObjectTypeCallProperty = isObjectTypeCallProperty; | |
| exports.isObjectTypeIndexer = isObjectTypeIndexer; | |
| exports.isObjectTypeProperty = isObjectTypeProperty; | |
| exports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty; | |
| exports.isOpaqueType = isOpaqueType; | |
| exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier; | |
| exports.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation; | |
| exports.isStringTypeAnnotation = isStringTypeAnnotation; | |
| exports.isThisTypeAnnotation = isThisTypeAnnotation; | |
| exports.isTupleTypeAnnotation = isTupleTypeAnnotation; | |
| exports.isTypeofTypeAnnotation = isTypeofTypeAnnotation; | |
| exports.isTypeAlias = isTypeAlias; | |
| exports.isTypeAnnotation = isTypeAnnotation; | |
| exports.isTypeCastExpression = isTypeCastExpression; | |
| exports.isTypeParameter = isTypeParameter; | |
| exports.isTypeParameterDeclaration = isTypeParameterDeclaration; | |
| exports.isTypeParameterInstantiation = isTypeParameterInstantiation; | |
| exports.isUnionTypeAnnotation = isUnionTypeAnnotation; | |
| exports.isVariance = isVariance; | |
| exports.isVoidTypeAnnotation = isVoidTypeAnnotation; | |
| exports.isJSXAttribute = isJSXAttribute; | |
| exports.isJSXClosingElement = isJSXClosingElement; | |
| exports.isJSXElement = isJSXElement; | |
| exports.isJSXEmptyExpression = isJSXEmptyExpression; | |
| exports.isJSXExpressionContainer = isJSXExpressionContainer; | |
| exports.isJSXSpreadChild = isJSXSpreadChild; | |
| exports.isJSXIdentifier = isJSXIdentifier; | |
| exports.isJSXMemberExpression = isJSXMemberExpression; | |
| exports.isJSXNamespacedName = isJSXNamespacedName; | |
| exports.isJSXOpeningElement = isJSXOpeningElement; | |
| exports.isJSXSpreadAttribute = isJSXSpreadAttribute; | |
| exports.isJSXText = isJSXText; | |
| exports.isJSXFragment = isJSXFragment; | |
| exports.isJSXOpeningFragment = isJSXOpeningFragment; | |
| exports.isJSXClosingFragment = isJSXClosingFragment; | |
| exports.isNoop = isNoop; | |
| exports.isPlaceholder = isPlaceholder; | |
| exports.isArgumentPlaceholder = isArgumentPlaceholder; | |
| exports.isAwaitExpression = isAwaitExpression; | |
| exports.isBindExpression = isBindExpression; | |
| exports.isClassProperty = isClassProperty; | |
| exports.isOptionalMemberExpression = isOptionalMemberExpression; | |
| exports.isPipelineTopicExpression = isPipelineTopicExpression; | |
| exports.isPipelineBareFunction = isPipelineBareFunction; | |
| exports.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference; | |
| exports.isOptionalCallExpression = isOptionalCallExpression; | |
| exports.isClassPrivateProperty = isClassPrivateProperty; | |
| exports.isClassPrivateMethod = isClassPrivateMethod; | |
| exports.isImport = isImport; | |
| exports.isDecorator = isDecorator; | |
| exports.isDoExpression = isDoExpression; | |
| exports.isExportDefaultSpecifier = isExportDefaultSpecifier; | |
| exports.isExportNamespaceSpecifier = isExportNamespaceSpecifier; | |
| exports.isPrivateName = isPrivateName; | |
| exports.isBigIntLiteral = isBigIntLiteral; | |
| exports.isTSParameterProperty = isTSParameterProperty; | |
| exports.isTSDeclareFunction = isTSDeclareFunction; | |
| exports.isTSDeclareMethod = isTSDeclareMethod; | |
| exports.isTSQualifiedName = isTSQualifiedName; | |
| exports.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration; | |
| exports.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration; | |
| exports.isTSPropertySignature = isTSPropertySignature; | |
| exports.isTSMethodSignature = isTSMethodSignature; | |
| exports.isTSIndexSignature = isTSIndexSignature; | |
| exports.isTSAnyKeyword = isTSAnyKeyword; | |
| exports.isTSUnknownKeyword = isTSUnknownKeyword; | |
| exports.isTSNumberKeyword = isTSNumberKeyword; | |
| exports.isTSObjectKeyword = isTSObjectKeyword; | |
| exports.isTSBooleanKeyword = isTSBooleanKeyword; | |
| exports.isTSStringKeyword = isTSStringKeyword; | |
| exports.isTSSymbolKeyword = isTSSymbolKeyword; | |
| exports.isTSVoidKeyword = isTSVoidKeyword; | |
| exports.isTSUndefinedKeyword = isTSUndefinedKeyword; | |
| exports.isTSNullKeyword = isTSNullKeyword; | |
| exports.isTSNeverKeyword = isTSNeverKeyword; | |
| exports.isTSThisType = isTSThisType; | |
| exports.isTSFunctionType = isTSFunctionType; | |
| exports.isTSConstructorType = isTSConstructorType; | |
| exports.isTSTypeReference = isTSTypeReference; | |
| exports.isTSTypePredicate = isTSTypePredicate; | |
| exports.isTSTypeQuery = isTSTypeQuery; | |
| exports.isTSTypeLiteral = isTSTypeLiteral; | |
| exports.isTSArrayType = isTSArrayType; | |
| exports.isTSTupleType = isTSTupleType; | |
| exports.isTSOptionalType = isTSOptionalType; | |
| exports.isTSRestType = isTSRestType; | |
| exports.isTSUnionType = isTSUnionType; | |
| exports.isTSIntersectionType = isTSIntersectionType; | |
| exports.isTSConditionalType = isTSConditionalType; | |
| exports.isTSInferType = isTSInferType; | |
| exports.isTSParenthesizedType = isTSParenthesizedType; | |
| exports.isTSTypeOperator = isTSTypeOperator; | |
| exports.isTSIndexedAccessType = isTSIndexedAccessType; | |
| exports.isTSMappedType = isTSMappedType; | |
| exports.isTSLiteralType = isTSLiteralType; | |
| exports.isTSExpressionWithTypeArguments = isTSExpressionWithTypeArguments; | |
| exports.isTSInterfaceDeclaration = isTSInterfaceDeclaration; | |
| exports.isTSInterfaceBody = isTSInterfaceBody; | |
| exports.isTSTypeAliasDeclaration = isTSTypeAliasDeclaration; | |
| exports.isTSAsExpression = isTSAsExpression; | |
| exports.isTSTypeAssertion = isTSTypeAssertion; | |
| exports.isTSEnumDeclaration = isTSEnumDeclaration; | |
| exports.isTSEnumMember = isTSEnumMember; | |
| exports.isTSModuleDeclaration = isTSModuleDeclaration; | |
| exports.isTSModuleBlock = isTSModuleBlock; | |
| exports.isTSImportType = isTSImportType; | |
| exports.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration; | |
| exports.isTSExternalModuleReference = isTSExternalModuleReference; | |
| exports.isTSNonNullExpression = isTSNonNullExpression; | |
| exports.isTSExportAssignment = isTSExportAssignment; | |
| exports.isTSNamespaceExportDeclaration = isTSNamespaceExportDeclaration; | |
| exports.isTSTypeAnnotation = isTSTypeAnnotation; | |
| exports.isTSTypeParameterInstantiation = isTSTypeParameterInstantiation; | |
| exports.isTSTypeParameterDeclaration = isTSTypeParameterDeclaration; | |
| exports.isTSTypeParameter = isTSTypeParameter; | |
| exports.isExpression = isExpression; | |
| exports.isBinary = isBinary; | |
| exports.isScopable = isScopable; | |
| exports.isBlockParent = isBlockParent; | |
| exports.isBlock = isBlock; | |
| exports.isStatement = isStatement; | |
| exports.isTerminatorless = isTerminatorless; | |
| exports.isCompletionStatement = isCompletionStatement; | |
| exports.isConditional = isConditional; | |
| exports.isLoop = isLoop; | |
| exports.isWhile = isWhile; | |
| exports.isExpressionWrapper = isExpressionWrapper; | |
| exports.isFor = isFor; | |
| exports.isForXStatement = isForXStatement; | |
| exports.isFunction = isFunction; | |
| exports.isFunctionParent = isFunctionParent; | |
| exports.isPureish = isPureish; | |
| exports.isDeclaration = isDeclaration; | |
| exports.isPatternLike = isPatternLike; | |
| exports.isLVal = isLVal; | |
| exports.isTSEntityName = isTSEntityName; | |
| exports.isLiteral = isLiteral; | |
| exports.isImmutable = isImmutable; | |
| exports.isUserWhitespacable = isUserWhitespacable; | |
| exports.isMethod = isMethod; | |
| exports.isObjectMember = isObjectMember; | |
| exports.isProperty = isProperty; | |
| exports.isUnaryLike = isUnaryLike; | |
| exports.isPattern = isPattern; | |
| exports.isClass = isClass; | |
| exports.isModuleDeclaration = isModuleDeclaration; | |
| exports.isExportDeclaration = isExportDeclaration; | |
| exports.isModuleSpecifier = isModuleSpecifier; | |
| exports.isFlow = isFlow; | |
| exports.isFlowType = isFlowType; | |
| exports.isFlowBaseAnnotation = isFlowBaseAnnotation; | |
| exports.isFlowDeclaration = isFlowDeclaration; | |
| exports.isFlowPredicate = isFlowPredicate; | |
| exports.isJSX = isJSX; | |
| exports.isPrivate = isPrivate; | |
| exports.isTSTypeElement = isTSTypeElement; | |
| exports.isTSType = isTSType; | |
| exports.isNumberLiteral = isNumberLiteral; | |
| exports.isRegexLiteral = isRegexLiteral; | |
| exports.isRestProperty = isRestProperty; | |
| exports.isSpreadProperty = isSpreadProperty; | |
| var _shallowEqual = _interopRequireDefault(__webpack_require__(/*! ../../utils/shallowEqual */ "../babel-generator/node_modules/@babel/types/lib/utils/shallowEqual.js")); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function isArrayExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ArrayExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isAssignmentExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "AssignmentExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isBinaryExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "BinaryExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isInterpreterDirective(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "InterpreterDirective") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDirective(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Directive") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDirectiveLiteral(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DirectiveLiteral") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isBlockStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "BlockStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isBreakStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "BreakStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isCallExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "CallExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isCatchClause(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "CatchClause") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isConditionalExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ConditionalExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isContinueStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ContinueStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDebuggerStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DebuggerStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDoWhileStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DoWhileStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isEmptyStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "EmptyStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isExpressionStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ExpressionStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isFile(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "File") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isForInStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ForInStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isForStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ForStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isFunctionDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "FunctionDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isFunctionExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "FunctionExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isIdentifier(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Identifier") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isIfStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "IfStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isLabeledStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "LabeledStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isStringLiteral(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "StringLiteral") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isNumericLiteral(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "NumericLiteral") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isNullLiteral(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "NullLiteral") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isBooleanLiteral(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "BooleanLiteral") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isRegExpLiteral(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "RegExpLiteral") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isLogicalExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "LogicalExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isMemberExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "MemberExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isNewExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "NewExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isProgram(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Program") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isObjectExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ObjectExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isObjectMethod(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ObjectMethod") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isObjectProperty(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ObjectProperty") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isRestElement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "RestElement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isReturnStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ReturnStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isSequenceExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "SequenceExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isParenthesizedExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ParenthesizedExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isSwitchCase(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "SwitchCase") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isSwitchStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "SwitchStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isThisExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ThisExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isThrowStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ThrowStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTryStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TryStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isUnaryExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "UnaryExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isUpdateExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "UpdateExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isVariableDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "VariableDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isVariableDeclarator(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "VariableDeclarator") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isWhileStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "WhileStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isWithStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "WithStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isAssignmentPattern(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "AssignmentPattern") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isArrayPattern(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ArrayPattern") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isArrowFunctionExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ArrowFunctionExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isClassBody(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ClassBody") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isClassDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ClassDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isClassExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ClassExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isExportAllDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ExportAllDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isExportDefaultDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ExportDefaultDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isExportNamedDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ExportNamedDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isExportSpecifier(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ExportSpecifier") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isForOfStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ForOfStatement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isImportDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ImportDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isImportDefaultSpecifier(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ImportDefaultSpecifier") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isImportNamespaceSpecifier(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ImportNamespaceSpecifier") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isImportSpecifier(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ImportSpecifier") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isMetaProperty(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "MetaProperty") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isClassMethod(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ClassMethod") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isObjectPattern(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ObjectPattern") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isSpreadElement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "SpreadElement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isSuper(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Super") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTaggedTemplateExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TaggedTemplateExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTemplateElement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TemplateElement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTemplateLiteral(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TemplateLiteral") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isYieldExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "YieldExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isAnyTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "AnyTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isArrayTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ArrayTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isBooleanTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "BooleanTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isBooleanLiteralTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "BooleanLiteralTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isNullLiteralTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "NullLiteralTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isClassImplements(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ClassImplements") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDeclareClass(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DeclareClass") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDeclareFunction(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DeclareFunction") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDeclareInterface(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DeclareInterface") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDeclareModule(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DeclareModule") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDeclareModuleExports(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DeclareModuleExports") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDeclareTypeAlias(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DeclareTypeAlias") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDeclareOpaqueType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DeclareOpaqueType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDeclareVariable(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DeclareVariable") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDeclareExportDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DeclareExportDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDeclareExportAllDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DeclareExportAllDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDeclaredPredicate(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DeclaredPredicate") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isExistsTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ExistsTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isFunctionTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "FunctionTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isFunctionTypeParam(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "FunctionTypeParam") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isGenericTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "GenericTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isInferredPredicate(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "InferredPredicate") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isInterfaceExtends(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "InterfaceExtends") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isInterfaceDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "InterfaceDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isInterfaceTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "InterfaceTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isIntersectionTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "IntersectionTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isMixedTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "MixedTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isEmptyTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "EmptyTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isNullableTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "NullableTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isNumberLiteralTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "NumberLiteralTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isNumberTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "NumberTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isObjectTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ObjectTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isObjectTypeInternalSlot(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ObjectTypeInternalSlot") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isObjectTypeCallProperty(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ObjectTypeCallProperty") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isObjectTypeIndexer(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ObjectTypeIndexer") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isObjectTypeProperty(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ObjectTypeProperty") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isObjectTypeSpreadProperty(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ObjectTypeSpreadProperty") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isOpaqueType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "OpaqueType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isQualifiedTypeIdentifier(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "QualifiedTypeIdentifier") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isStringLiteralTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "StringLiteralTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isStringTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "StringTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isThisTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ThisTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTupleTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TupleTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTypeofTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TypeofTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTypeAlias(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TypeAlias") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTypeCastExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TypeCastExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTypeParameter(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TypeParameter") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTypeParameterDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TypeParameterDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTypeParameterInstantiation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TypeParameterInstantiation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isUnionTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "UnionTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isVariance(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Variance") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isVoidTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "VoidTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXAttribute(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXAttribute") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXClosingElement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXClosingElement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXElement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXElement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXEmptyExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXEmptyExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXExpressionContainer(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXExpressionContainer") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXSpreadChild(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXSpreadChild") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXIdentifier(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXIdentifier") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXMemberExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXMemberExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXNamespacedName(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXNamespacedName") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXOpeningElement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXOpeningElement") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXSpreadAttribute(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXSpreadAttribute") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXText(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXText") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXFragment(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXFragment") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXOpeningFragment(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXOpeningFragment") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isJSXClosingFragment(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "JSXClosingFragment") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isNoop(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Noop") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isPlaceholder(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Placeholder") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isArgumentPlaceholder(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ArgumentPlaceholder") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isAwaitExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "AwaitExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isBindExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "BindExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isClassProperty(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ClassProperty") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isOptionalMemberExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "OptionalMemberExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isPipelineTopicExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "PipelineTopicExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isPipelineBareFunction(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "PipelineBareFunction") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isPipelinePrimaryTopicReference(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "PipelinePrimaryTopicReference") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isOptionalCallExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "OptionalCallExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isClassPrivateProperty(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ClassPrivateProperty") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isClassPrivateMethod(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ClassPrivateMethod") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isImport(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Import") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDecorator(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Decorator") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isDoExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "DoExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isExportDefaultSpecifier(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ExportDefaultSpecifier") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isExportNamespaceSpecifier(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ExportNamespaceSpecifier") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isPrivateName(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "PrivateName") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isBigIntLiteral(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "BigIntLiteral") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSParameterProperty(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSParameterProperty") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSDeclareFunction(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSDeclareFunction") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSDeclareMethod(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSDeclareMethod") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSQualifiedName(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSQualifiedName") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSCallSignatureDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSCallSignatureDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSConstructSignatureDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSConstructSignatureDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSPropertySignature(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSPropertySignature") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSMethodSignature(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSMethodSignature") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSIndexSignature(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSIndexSignature") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSAnyKeyword(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSAnyKeyword") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSUnknownKeyword(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSUnknownKeyword") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSNumberKeyword(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSNumberKeyword") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSObjectKeyword(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSObjectKeyword") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSBooleanKeyword(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSBooleanKeyword") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSStringKeyword(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSStringKeyword") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSSymbolKeyword(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSSymbolKeyword") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSVoidKeyword(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSVoidKeyword") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSUndefinedKeyword(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSUndefinedKeyword") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSNullKeyword(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSNullKeyword") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSNeverKeyword(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSNeverKeyword") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSThisType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSThisType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSFunctionType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSFunctionType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSConstructorType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSConstructorType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSTypeReference(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSTypeReference") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSTypePredicate(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSTypePredicate") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSTypeQuery(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSTypeQuery") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSTypeLiteral(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSTypeLiteral") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSArrayType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSArrayType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSTupleType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSTupleType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSOptionalType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSOptionalType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSRestType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSRestType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSUnionType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSUnionType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSIntersectionType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSIntersectionType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSConditionalType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSConditionalType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSInferType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSInferType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSParenthesizedType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSParenthesizedType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSTypeOperator(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSTypeOperator") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSIndexedAccessType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSIndexedAccessType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSMappedType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSMappedType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSLiteralType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSLiteralType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSExpressionWithTypeArguments(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSExpressionWithTypeArguments") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSInterfaceDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSInterfaceDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSInterfaceBody(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSInterfaceBody") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSTypeAliasDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSTypeAliasDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSAsExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSAsExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSTypeAssertion(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSTypeAssertion") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSEnumDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSEnumDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSEnumMember(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSEnumMember") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSModuleDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSModuleDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSModuleBlock(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSModuleBlock") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSImportType(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSImportType") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSImportEqualsDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSImportEqualsDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSExternalModuleReference(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSExternalModuleReference") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSNonNullExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSNonNullExpression") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSExportAssignment(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSExportAssignment") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSNamespaceExportDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSNamespaceExportDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSTypeAnnotation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSTypeAnnotation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSTypeParameterInstantiation(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSTypeParameterInstantiation") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSTypeParameterDeclaration(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSTypeParameterDeclaration") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTSTypeParameter(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "TSTypeParameter") { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isExpression(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Expression" || "ArrayExpression" === nodeType || "AssignmentExpression" === nodeType || "BinaryExpression" === nodeType || "CallExpression" === nodeType || "ConditionalExpression" === nodeType || "FunctionExpression" === nodeType || "Identifier" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "LogicalExpression" === nodeType || "MemberExpression" === nodeType || "NewExpression" === nodeType || "ObjectExpression" === nodeType || "SequenceExpression" === nodeType || "ParenthesizedExpression" === nodeType || "ThisExpression" === nodeType || "UnaryExpression" === nodeType || "UpdateExpression" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "MetaProperty" === nodeType || "Super" === nodeType || "TaggedTemplateExpression" === nodeType || "TemplateLiteral" === nodeType || "YieldExpression" === nodeType || "TypeCastExpression" === nodeType || "JSXElement" === nodeType || "JSXFragment" === nodeType || "AwaitExpression" === nodeType || "BindExpression" === nodeType || "OptionalMemberExpression" === nodeType || "PipelinePrimaryTopicReference" === nodeType || "OptionalCallExpression" === nodeType || "Import" === nodeType || "DoExpression" === nodeType || "BigIntLiteral" === nodeType || "TSAsExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType || nodeType === "Placeholder" && ("Expression" === node.expectedNode || "Identifier" === node.expectedNode || "StringLiteral" === node.expectedNode)) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isBinary(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Binary" || "BinaryExpression" === nodeType || "LogicalExpression" === nodeType) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isScopable(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Scopable" || "BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassDeclaration" === nodeType || "ClassExpression" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isBlockParent(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "BlockParent" || "BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isBlock(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Block" || "BlockStatement" === nodeType || "Program" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Statement" || "BlockStatement" === nodeType || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "DebuggerStatement" === nodeType || "DoWhileStatement" === nodeType || "EmptyStatement" === nodeType || "ExpressionStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "IfStatement" === nodeType || "LabeledStatement" === nodeType || "ReturnStatement" === nodeType || "SwitchStatement" === nodeType || "ThrowStatement" === nodeType || "TryStatement" === nodeType || "VariableDeclaration" === nodeType || "WhileStatement" === nodeType || "WithStatement" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ForOfStatement" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType || "TSImportEqualsDeclaration" === nodeType || "TSExportAssignment" === nodeType || "TSNamespaceExportDeclaration" === nodeType || nodeType === "Placeholder" && ("Statement" === node.expectedNode || "Declaration" === node.expectedNode || "BlockStatement" === node.expectedNode)) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isTerminatorless(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Terminatorless" || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isCompletionStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "CompletionStatement" || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isConditional(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Conditional" || "ConditionalExpression" === nodeType || "IfStatement" === nodeType) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isLoop(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Loop" || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "WhileStatement" === nodeType || "ForOfStatement" === nodeType) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isWhile(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "While" || "DoWhileStatement" === nodeType || "WhileStatement" === nodeType) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isExpressionWrapper(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ExpressionWrapper" || "ExpressionStatement" === nodeType || "ParenthesizedExpression" === nodeType || "TypeCastExpression" === nodeType) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isFor(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "For" || "ForInStatement" === nodeType || "ForStatement" === nodeType || "ForOfStatement" === nodeType) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isForXStatement(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "ForXStatement" || "ForInStatement" === nodeType || "ForOfStatement" === nodeType) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isFunction(node, opts) { | |
| if (!node) return false; | |
| const nodeType = node.type; | |
| if (nodeType === "Function" || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) { | |
| if (typeof opts === "undefined") { | |
| return true; | |
| } else { | |
| return (0, _shallowEqual.default)(node, opts); | |
| } | |
| } | |
| return false; | |
| } | |
| function isFunctionParent(node, opts) { | |
| if (!node) return false; | |