Initial commit: n8n Strike API node

- Add Strike API credentials configuration
- Implement Strike node with 9 resources (Account, Balance, Currency Exchange, Deposit, Invoice, Payment, Payment Method, Payout, Rates)
- Add comprehensive operation descriptions for all resources
- Include CLAUDE.MD documentation
- Set up build configuration with TypeScript, ESLint, and Prettier

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

node_modules/recast/.editorconfig

@@ -0,0 +1,13 @@
+[*]
+insert_final_newline = true
+
+[{package.json}]
+indent_style = space
+indent_size = 2
+
+[{*.js, *.ts}]
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+end_of_line = lf
+charset = utf-8

node_modules/recast/.eslintrc.js

@@ -0,0 +1,16 @@
+module.exports = {
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    ecmaVersion: 6,
+    sourceType: "module",
+    ecmaFeatures: {
+      jsx: true,
+    },
+  },
+  rules: {
+    "no-var": "error",
+    "no-case-declarations": "error",
+    "no-fallthrough": "error",
+  },
+  ignorePatterns: ["test/data"],
+};

node_modules/recast/.github/dependabot.yml

@@ -0,0 +1,9 @@
+# Please see the documentation for all configuration options:
+# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "npm" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "daily"

node_modules/recast/.github/workflows/main.yml

@@ -0,0 +1,29 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+    name: Test on node ${{ matrix.node_version }} and ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        node_version: ['10.x', '12.x', '14.x', '15.x', '16.x']
+        os: [ubuntu-latest]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node_version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node_version }}
+
+    - name: npm install, build and test
+      run: |
+        npm install
+        npm run build --if-present
+        npm test

node_modules/recast/.prettierignore

@@ -0,0 +1,3 @@
+*.d.ts
+test/data/
+/example

node_modules/recast/.prettierrc.js

@@ -0,0 +1,16 @@
+module.exports = {
+  printWidth: 80,
+  trailingComma: "all",
+  singleQuote: false,
+
+  overrides: [
+    {
+      files: "*.md",
+      options: {
+        printWidth: 60,
+        // Don't reformat code examples in README
+        embeddedLanguageFormatting: "off",
+      },
+    },
+  ],
+};

node_modules/recast/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Ben Newman <bn@cs.stanford.edu>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/recast/README.md

@@ -0,0 +1,221 @@
+# recast, _v_. ![CI](https://github.com/benjamn/recast/workflows/CI/badge.svg) [![Join the chat at https://gitter.im/benjamn/recast](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/benjamn/recast?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+1. to give (a metal object) a different form by melting it down and reshaping it.
+1. to form, fashion, or arrange again.
+1. to remodel or reconstruct (a literary work, document, sentence, etc.).
+1. to supply (a theater or opera work) with a new cast.
+
+## Installation
+
+From npm:
+
+    npm install recast
+
+From GitHub:
+
+    cd path/to/node_modules
+    git clone git://github.com/benjamn/recast.git
+    cd recast
+    npm install .
+
+## Import style
+
+Recast is designed to be imported using **named** imports:
+
+```js
+import { parse, print } from "recast";
+console.log(print(parse(source)).code);
+
+import * as recast from "recast";
+console.log(recast.print(recast.parse(source)).code);
+```
+
+If you're using CommonJS:
+
+```js
+const { parse, print } = require("recast");
+console.log(print(parse(source)).code);
+
+const recast = require("recast");
+console.log(recast.print(recast.parse(source)).code);
+```
+
+## Usage
+
+Recast exposes two essential interfaces, one for parsing JavaScript code (`require("recast").parse`) and the other for reprinting modified syntax trees (`require("recast").print`).
+
+Here's a simple but non-trivial example of how you might use `.parse` and `.print`:
+
+```js
+import * as recast from "recast";
+
+// Let's turn this function declaration into a variable declaration.
+const code = [
+  "function add(a, b) {",
+  "  return a +",
+  "    // Weird formatting, huh?",
+  "    b;",
+  "}"
+].join("\n");
+
+// Parse the code using an interface similar to require("esprima").parse.
+const ast = recast.parse(code);
+```
+
+Now do _whatever_ you want to `ast`. Really, anything at all!
+
+See [ast-types](https://github.com/benjamn/ast-types) (especially the [def/core.ts](https://github.com/benjamn/ast-types/blob/master/def/core.ts)) module for a thorough overview of the `ast` API.
+
+```js
+// Grab a reference to the function declaration we just parsed.
+const add = ast.program.body[0];
+
+// Make sure it's a FunctionDeclaration (optional).
+const n = recast.types.namedTypes;
+n.FunctionDeclaration.assert(add);
+
+// If you choose to use recast.builders to construct new AST nodes, all builder
+// arguments will be dynamically type-checked against the Mozilla Parser API.
+const b = recast.types.builders;
+
+// This kind of manipulation should seem familiar if you've used Esprima or the
+// Mozilla Parser API before.
+ast.program.body[0] = b.variableDeclaration("var", [
+  b.variableDeclarator(add.id, b.functionExpression(
+    null, // Anonymize the function expression.
+    add.params,
+    add.body
+  ))
+]);
+
+// Just for fun, because addition is commutative:
+add.params.push(add.params.shift());
+```
+
+When you finish manipulating the AST, let `recast.print` work its magic:
+
+```js
+const output = recast.print(ast).code;
+```
+
+The `output` string now looks exactly like this, weird formatting and all:
+
+```js
+var add = function(b, a) {
+  return a +
+    // Weird formatting, huh?
+    b;
+}
+```
+
+The magic of Recast is that it reprints only those parts of the syntax tree that you modify. In other words, the following identity is guaranteed:
+
+```js
+recast.print(recast.parse(source)).code === source
+```
+
+Whenever Recast cannot reprint a modified node using the original source code, it falls back to using a generic pretty printer. So the worst that can happen is that your changes trigger some harmless reformatting of your code.
+
+If you really don't care about preserving the original formatting, you can access the pretty printer directly:
+
+```js
+var output = recast.prettyPrint(ast, { tabWidth: 2 }).code;
+```
+
+And here's the exact `output`:
+
+```js
+var add = function(b, a) {
+  return a + b;
+}
+```
+
+Note that the weird formatting was discarded, yet the behavior and abstract structure of the code remain the same.
+
+## Using a different parser
+
+By default, Recast uses the [Esprima JavaScript parser](https://www.npmjs.com/package/esprima) when you call `recast.parse(code)`. While Esprima supports almost all modern ECMAScript syntax, you may want to use a different parser to enable TypeScript or Flow syntax, or just because you want to match other compilation tools you might be using.
+
+In order to get any benefits from Recast's conservative pretty-printing, **it is very important that you continue to call `recast.parse`** (rather than parsing the AST yourself using a different parser), and simply instruct `recast.parse` to use a different parser:
+
+```js
+const acornAst = recast.parse(source, {
+  parser: require("acorn")
+});
+```
+
+Why is this so important? When you call `recast.parse`, it makes a shadow copy of the AST before returning it to you, giving every copied AST node a reference back to the original through a special `.original` property. This information is what enables `recast.print` to detect where the AST has been modified, so that it can preserve formatting for parts of the AST that were not modified.
+
+Any `parser` object that supports a `parser.parse(source)` method will work here; however, if your parser requires additional options, you can always implement your own `parse` method that invokes your parser with custom options:
+
+```js
+const acornAst = recast.parse(source, {
+  parser: {
+    parse(source) {
+      return require("acorn").parse(source, {
+        // additional options
+      });
+    }
+  }
+});
+```
+
+To take some of the guesswork out of configuring common parsers, Recast provides [several preconfigured parsers](https://github.com/benjamn/recast/tree/master/parsers), so you can parse TypeScript (for example) without worrying about the configuration details:
+
+```js
+const tsAst = recast.parse(source, {
+  parser: require("recast/parsers/typescript")
+});
+```
+
+**Note:** Some of these parsers import npm packages that Recast does not directly depend upon, so please be aware you may have to run `npm install @babel/parser` to use the `typescript`, `flow`, or `babel` parsers, or `npm install acorn` to use the `acorn` parser. Only Esprima is installed by default when Recast is installed.
+
+After calling `recast.parse`, if you're going to transform the AST, make sure that the `.original` property is preserved. With Babel, for instance, if you call `transformFromAST`, you must pass `cloneInputAst: false` in its options. ([More detail](https://github.com/babel/babel/issues/12882).
+
+## Source maps
+
+One of the coolest consequences of tracking and reusing original source code during reprinting is that it's pretty easy to generate a high-resolution mapping between the original code and the generated code—completely automatically!
+
+With every `slice`, `join`, and re-`indent`-ation, the reprinting process maintains exact knowledge of which character sequences are original, and where in the original source they came from.
+
+All you have to think about is how to manipulate the syntax tree, and Recast will give you a [source map](https://github.com/mozilla/source-map) in exchange for specifying the names of your source file(s) and the desired name of the map:
+
+```js
+var result = recast.print(transform(recast.parse(source, {
+  sourceFileName: "source.js"
+})), {
+  sourceMapName: "source.min.js"
+});
+
+console.log(result.code); // Resulting string of code.
+console.log(result.map); // JSON source map.
+
+var SourceMapConsumer = require("source-map").SourceMapConsumer;
+var smc = new SourceMapConsumer(result.map);
+console.log(smc.originalPositionFor({
+  line: 3,
+  column: 15
+})); // { source: 'source.js',
+     //   line: 2,
+     //   column: 10,
+     //   name: null }
+```
+
+Note that you are free to mix and match syntax trees parsed from different source files, and the resulting source map will automatically keep track of the separate file origins for you.
+
+Note also that the source maps generated by Recast are character-by-character maps, so meaningful identifier names are not recorded at this time. This approach leads to higher-resolution debugging in modern browsers, at the expense of somewhat larger map sizes. Striking the perfect balance here is an area for future exploration, but such improvements will not require any breaking changes to the interface demonstrated above.
+
+## Options
+
+All Recast API functions take second parameter with configuration options, documented in
+[options.ts](https://github.com/benjamn/recast/blob/master/lib/options.ts)
+
+## Motivation
+
+The more code you have, the harder it becomes to make big, sweeping changes quickly and confidently. Even if you trust yourself not to make too many mistakes, and no matter how proficient you are with your text editor, changing tens of thousands of lines of code takes precious, non-refundable time.
+
+Is there a better way? Not always! When a task requires you to alter the semantics of many different pieces of code in subtly different ways, your brain inevitably becomes the bottleneck, and there is little hope of completely automating the process. Your best bet is to plan carefully, buckle down, and get it right the first time. Love it or loathe it, that's the way programming goes sometimes.
+
+What I hope to eliminate are the brain-wasting tasks, the tasks that are bottlenecked by keystrokes, the tasks that can be expressed as operations on the _syntactic structure_ of your code. Specifically, my goal is to make it possible for you to run your code through a parser, manipulate the abstract syntax tree directly, subject only to the constraints of your imagination, and then automatically translate those modifications back into source code, without upsetting the formatting of unmodified code.
+
+And here's the best part: when you're done running a Recast script, if you're not completely satisfied with the results, blow them away with `git reset --hard`, tweak the script, and just run it again. Change your mind as many times as you like. Instead of typing yourself into a nasty case of [RSI](http://en.wikipedia.org/wiki/Repetitive_strain_injury), gaze upon your new wells of free time and ask yourself: what next?

node_modules/recast/example/add-braces

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+var recast = require("recast");
+var types = recast.types;
+var n = types.namedTypes;
+var b = types.builders;
+
+require("recast").run(function(ast, callback) {
+    recast.visit(ast, {
+        visitIfStatement: function(path) {
+            var stmt = path.node;
+            stmt.consequent = fix(stmt.consequent);
+
+            var alt = stmt.alternate;
+            if (!n.IfStatement.check(alt)) {
+                stmt.alternate = fix(alt);
+            }
+
+            this.traverse(path);
+        },
+
+        visitWhileStatement: visitLoop,
+        visitForStatement: visitLoop,
+        visitForInStatement: visitLoop
+    });
+
+    callback(ast);
+});
+
+function visitLoop(path) {
+    var loop = path.node;
+    loop.body = fix(loop.body);
+    this.traverse(path);
+}
+
+function fix(clause) {
+    if (clause) {
+        if (!n.BlockStatement.check(clause)) {
+            clause = b.blockStatement([clause]);
+        }
+    }
+
+    return clause;
+}

node_modules/recast/example/generic-identity

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+// This script should reprint the contents of the given file without
+// reusing the original source, but with identical AST structure.
+
+var recast = require("recast");
+
+recast.run(function(ast, callback) {
+    recast.visit(ast, {
+        visitNode: function(path) {
+            this.traverse(path);
+            path.node.original = null;
+        }
+    });
+
+    callback(ast);
+});

node_modules/recast/example/identity

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+// This script should echo the contents of the given file without
+// modification.
+
+require("recast").run(function(ast, callback) {
+    callback(ast);
+});

node_modules/recast/example/to-while

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+// This script converts for and do-while loops into equivalent while loops.
+// Note that for-in statements are left unmodified, as they do not have a
+// simple analogy to while loops. Also note that labeled continue statements
+// are not correctly handled at this point, and will trigger an assertion
+// failure if encountered.
+
+var assert = require("assert");
+var recast = require("recast");
+var types = recast.types;
+var n = types.namedTypes;
+var b = types.builders;
+
+recast.run(function(ast, callback) {
+    recast.visit(ast, {
+        visitForStatement: function(path) {
+            var fst = path.node;
+
+            path.replace(
+                fst.init,
+                b.whileStatement(
+                    fst.test,
+                    insertBeforeLoopback(fst, fst.update)
+                )
+            );
+
+            this.traverse(path);
+        },
+
+        visitDoWhileStatement: function(path) {
+            var dwst = path.node;
+            return b.whileStatement(
+                b.literal(true),
+                insertBeforeLoopback(
+                    dwst,
+                    b.ifStatement(
+                        dwst.test,
+                        b.breakStatement()
+                    )
+                )
+            );
+        }
+    });
+
+    callback(ast);
+});
+
+function insertBeforeLoopback(loop, toInsert) {
+    var body = loop.body;
+
+    if (!n.Statement.check(toInsert)) {
+        toInsert = b.expressionStatement(toInsert);
+    }
+
+    if (n.BlockStatement.check(body)) {
+        body.body.push(toInsert);
+    } else {
+        body = b.blockStatement([body, toInsert]);
+        loop.body = body;
+    }
+
+    recast.visit(body, {
+        visitContinueStatement: function(path) {
+            var cst = path.node;
+
+            assert.equal(
+                cst.label, null,
+                "Labeled continue statements are not yet supported."
+            );
+
+            path.replace(toInsert, path.node);
+            return false;
+        },
+
+        // Do not descend into nested loops.
+        visitWhileStatement: function() {},
+        visitForStatement: function() {},
+        visitForInStatement: function() {},
+        visitDoWhileStatement: function() {}
+    });
+
+    return body;
+}

node_modules/recast/lib/comments.d.ts

@@ -0,0 +1,2 @@
+export declare function attach(comments: any[], ast: any, lines: any): void;
+export declare function printComments(path: any, print: any): any;

node_modules/recast/lib/comments.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printComments = exports.attach = void 0;
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+var types = tslib_1.__importStar(require("ast-types"));
+var n = types.namedTypes;
+var isArray = types.builtInTypes.array;
+var isObject = types.builtInTypes.object;
+var lines_1 = require("./lines");
+var util_1 = require("./util");
+var childNodesCache = new WeakMap();
+// TODO Move a non-caching implementation of this function into ast-types,
+// and implement a caching wrapper function here.
+function getSortedChildNodes(node, lines, resultArray) {
+    if (!node) {
+        return resultArray;
+    }
+    // The .loc checks below are sensitive to some of the problems that
+    // are fixed by this utility function. Specifically, if it decides to
+    // set node.loc to null, indicating that the node's .loc information
+    // is unreliable, then we don't want to add node to the resultArray.
+    util_1.fixFaultyLocations(node, lines);
+    if (resultArray) {
+        if (n.Node.check(node) && n.SourceLocation.check(node.loc)) {
+            // This reverse insertion sort almost always takes constant
+            // time because we almost always (maybe always?) append the
+            // nodes in order anyway.
+            var i = resultArray.length - 1;
+            for (; i >= 0; --i) {
+                var child = resultArray[i];
+                if (child &&
+                    child.loc &&
+                    util_1.comparePos(child.loc.end, node.loc.start) <= 0) {
+                    break;
+                }
+            }
+            resultArray.splice(i + 1, 0, node);
+            return resultArray;
+        }
+    }
+    else {
+        var childNodes = childNodesCache.get(node);
+        if (childNodes) {
+            return childNodes;
+        }
+    }
+    var names;
+    if (isArray.check(node)) {
+        names = Object.keys(node);
+    }
+    else if (isObject.check(node)) {
+        names = types.getFieldNames(node);
+    }
+    else {
+        return resultArray;
+    }
+    if (!resultArray) {
+        childNodesCache.set(node, (resultArray = []));
+    }
+    for (var i = 0, nameCount = names.length; i < nameCount; ++i) {
+        getSortedChildNodes(node[names[i]], lines, resultArray);
+    }
+    return resultArray;
+}
+// As efficiently as possible, decorate the comment object with
+// .precedingNode, .enclosingNode, and/or .followingNode properties, at
+// least one of which is guaranteed to be defined.
+function decorateComment(node, comment, lines) {
+    var childNodes = getSortedChildNodes(node, lines);
+    // Time to dust off the old binary search robes and wizard hat.
+    var left = 0;
+    var right = childNodes && childNodes.length;
+    var precedingNode;
+    var followingNode;
+    while (typeof right === "number" && left < right) {
+        var middle = (left + right) >> 1;
+        var child = childNodes[middle];
+        if (util_1.comparePos(child.loc.start, comment.loc.start) <= 0 &&
+            util_1.comparePos(comment.loc.end, child.loc.end) <= 0) {
+            // The comment is completely contained by this child node.
+            decorateComment((comment.enclosingNode = child), comment, lines);
+            return; // Abandon the binary search at this level.
+        }
+        if (util_1.comparePos(child.loc.end, comment.loc.start) <= 0) {
+            // This child node falls completely before the comment.
+            // Because we will never consider this node or any nodes
+            // before it again, this node must be the closest preceding
+            // node we have encountered so far.
+            precedingNode = child;
+            left = middle + 1;
+            continue;
+        }
+        if (util_1.comparePos(comment.loc.end, child.loc.start) <= 0) {
+            // This child node falls completely after the comment.
+            // Because we will never consider this node or any nodes after
+            // it again, this node must be the closest following node we
+            // have encountered so far.
+            followingNode = child;
+            right = middle;
+            continue;
+        }
+        throw new Error("Comment location overlaps with node location");
+    }
+    if (precedingNode) {
+        comment.precedingNode = precedingNode;
+    }
+    if (followingNode) {
+        comment.followingNode = followingNode;
+    }
+}
+function attach(comments, ast, lines) {
+    if (!isArray.check(comments)) {
+        return;
+    }
+    var tiesToBreak = [];
+    comments.forEach(function (comment) {
+        comment.loc.lines = lines;
+        decorateComment(ast, comment, lines);
+        var pn = comment.precedingNode;
+        var en = comment.enclosingNode;
+        var fn = comment.followingNode;
+        if (pn && fn) {
+            var tieCount = tiesToBreak.length;
+            if (tieCount > 0) {
+                var lastTie = tiesToBreak[tieCount - 1];
+                assert_1.default.strictEqual(lastTie.precedingNode === comment.precedingNode, lastTie.followingNode === comment.followingNode);
+                if (lastTie.followingNode !== comment.followingNode) {
+                    breakTies(tiesToBreak, lines);
+                }
+            }
+            tiesToBreak.push(comment);
+        }
+        else if (pn) {
+            // No contest: we have a trailing comment.
+            breakTies(tiesToBreak, lines);
+            addTrailingComment(pn, comment);
+        }
+        else if (fn) {
+            // No contest: we have a leading comment.
+            breakTies(tiesToBreak, lines);
+            addLeadingComment(fn, comment);
+        }
+        else if (en) {
+            // The enclosing node has no child nodes at all, so what we
+            // have here is a dangling comment, e.g. [/* crickets */].
+            breakTies(tiesToBreak, lines);
+            addDanglingComment(en, comment);
+        }
+        else {
+            throw new Error("AST contains no nodes at all?");
+        }
+    });
+    breakTies(tiesToBreak, lines);
+    comments.forEach(function (comment) {
+        // These node references were useful for breaking ties, but we
+        // don't need them anymore, and they create cycles in the AST that
+        // may lead to infinite recursion if we don't delete them here.
+        delete comment.precedingNode;
+        delete comment.enclosingNode;
+        delete comment.followingNode;
+    });
+}
+exports.attach = attach;
+function breakTies(tiesToBreak, lines) {
+    var tieCount = tiesToBreak.length;
+    if (tieCount === 0) {
+        return;
+    }
+    var pn = tiesToBreak[0].precedingNode;
+    var fn = tiesToBreak[0].followingNode;
+    var gapEndPos = fn.loc.start;
+    // Iterate backwards through tiesToBreak, examining the gaps
+    // between the tied comments. In order to qualify as leading, a
+    // comment must be separated from fn by an unbroken series of
+    // whitespace-only gaps (or other comments).
+    var indexOfFirstLeadingComment = tieCount;
+    var comment;
+    for (; indexOfFirstLeadingComment > 0; --indexOfFirstLeadingComment) {
+        comment = tiesToBreak[indexOfFirstLeadingComment - 1];
+        assert_1.default.strictEqual(comment.precedingNode, pn);
+        assert_1.default.strictEqual(comment.followingNode, fn);
+        var gap = lines.sliceString(comment.loc.end, gapEndPos);
+        if (/\S/.test(gap)) {
+            // The gap string contained something other than whitespace.
+            break;
+        }
+        gapEndPos = comment.loc.start;
+    }
+    while (indexOfFirstLeadingComment <= tieCount &&
+        (comment = tiesToBreak[indexOfFirstLeadingComment]) &&
+        // If the comment is a //-style comment and indented more
+        // deeply than the node itself, reconsider it as trailing.
+        (comment.type === "Line" || comment.type === "CommentLine") &&
+        comment.loc.start.column > fn.loc.start.column) {
+        ++indexOfFirstLeadingComment;
+    }
+    tiesToBreak.forEach(function (comment, i) {
+        if (i < indexOfFirstLeadingComment) {
+            addTrailingComment(pn, comment);
+        }
+        else {
+            addLeadingComment(fn, comment);
+        }
+    });
+    tiesToBreak.length = 0;
+}
+function addCommentHelper(node, comment) {
+    var comments = node.comments || (node.comments = []);
+    comments.push(comment);
+}
+function addLeadingComment(node, comment) {
+    comment.leading = true;
+    comment.trailing = false;
+    addCommentHelper(node, comment);
+}
+function addDanglingComment(node, comment) {
+    comment.leading = false;
+    comment.trailing = false;
+    addCommentHelper(node, comment);
+}
+function addTrailingComment(node, comment) {
+    comment.leading = false;
+    comment.trailing = true;
+    addCommentHelper(node, comment);
+}
+function printLeadingComment(commentPath, print) {
+    var comment = commentPath.getValue();
+    n.Comment.assert(comment);
+    var loc = comment.loc;
+    var lines = loc && loc.lines;
+    var parts = [print(commentPath)];
+    if (comment.trailing) {
+        // When we print trailing comments as leading comments, we don't
+        // want to bring any trailing spaces along.
+        parts.push("\n");
+    }
+    else if (lines instanceof lines_1.Lines) {
+        var trailingSpace = lines.slice(loc.end, lines.skipSpaces(loc.end) || lines.lastPos());
+        if (trailingSpace.length === 1) {
+            // If the trailing space contains no newlines, then we want to
+            // preserve it exactly as we found it.
+            parts.push(trailingSpace);
+        }
+        else {
+            // If the trailing space contains newlines, then replace it
+            // with just that many newlines, with all other spaces removed.
+            parts.push(new Array(trailingSpace.length).join("\n"));
+        }
+    }
+    else {
+        parts.push("\n");
+    }
+    return lines_1.concat(parts);
+}
+function printTrailingComment(commentPath, print) {
+    var comment = commentPath.getValue(commentPath);
+    n.Comment.assert(comment);
+    var loc = comment.loc;
+    var lines = loc && loc.lines;
+    var parts = [];
+    if (lines instanceof lines_1.Lines) {
+        var fromPos = lines.skipSpaces(loc.start, true) || lines.firstPos();
+        var leadingSpace = lines.slice(fromPos, loc.start);
+        if (leadingSpace.length === 1) {
+            // If the leading space contains no newlines, then we want to
+            // preserve it exactly as we found it.
+            parts.push(leadingSpace);
+        }
+        else {
+            // If the leading space contains newlines, then replace it
+            // with just that many newlines, sans all other spaces.
+            parts.push(new Array(leadingSpace.length).join("\n"));
+        }
+    }
+    parts.push(print(commentPath));
+    return lines_1.concat(parts);
+}
+function printComments(path, print) {
+    var value = path.getValue();
+    var innerLines = print(path);
+    var comments = n.Node.check(value) && types.getFieldValue(value, "comments");
+    if (!comments || comments.length === 0) {
+        return innerLines;
+    }
+    var leadingParts = [];
+    var trailingParts = [innerLines];
+    path.each(function (commentPath) {
+        var comment = commentPath.getValue();
+        var leading = types.getFieldValue(comment, "leading");
+        var trailing = types.getFieldValue(comment, "trailing");
+        if (leading ||
+            (trailing &&
+                !(n.Statement.check(value) ||
+                    comment.type === "Block" ||
+                    comment.type === "CommentBlock"))) {
+            leadingParts.push(printLeadingComment(commentPath, print));
+        }
+        else if (trailing) {
+            trailingParts.push(printTrailingComment(commentPath, print));
+        }
+    }, "comments");
+    leadingParts.push.apply(leadingParts, trailingParts);
+    return lines_1.concat(leadingParts);
+}
+exports.printComments = printComments;

node_modules/recast/lib/fast-path.d.ts

@@ -0,0 +1,25 @@
+interface FastPathType {
+    stack: any[];
+    copy(): any;
+    getName(): any;
+    getValue(): any;
+    valueIsDuplicate(): any;
+    getNode(count?: number): any;
+    getParentNode(count?: number): any;
+    getRootValue(): any;
+    call(callback: any, ...names: any[]): any;
+    each(callback: any, ...names: any[]): any;
+    map(callback: any, ...names: any[]): any;
+    hasParens(): any;
+    getPrevToken(node: any): any;
+    getNextToken(node: any): any;
+    needsParens(assumeExpressionContext?: boolean): any;
+    canBeFirstInStatement(): any;
+    firstInStatement(): any;
+}
+interface FastPathConstructor {
+    new (value: any): FastPathType;
+    from(obj: any): any;
+}
+declare const FastPath: FastPathConstructor;
+export default FastPath;

node_modules/recast/lib/fast-path.js

@@ -0,0 +1,533 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+var types = tslib_1.__importStar(require("ast-types"));
+var util = tslib_1.__importStar(require("./util"));
+var n = types.namedTypes;
+var isArray = types.builtInTypes.array;
+var isNumber = types.builtInTypes.number;
+var PRECEDENCE = {};
+[
+    ["??"],
+    ["||"],
+    ["&&"],
+    ["|"],
+    ["^"],
+    ["&"],
+    ["==", "===", "!=", "!=="],
+    ["<", ">", "<=", ">=", "in", "instanceof"],
+    [">>", "<<", ">>>"],
+    ["+", "-"],
+    ["*", "/", "%"],
+    ["**"],
+].forEach(function (tier, i) {
+    tier.forEach(function (op) {
+        PRECEDENCE[op] = i;
+    });
+});
+var FastPath = function FastPath(value) {
+    assert_1.default.ok(this instanceof FastPath);
+    this.stack = [value];
+};
+var FPp = FastPath.prototype;
+// Static convenience function for coercing a value to a FastPath.
+FastPath.from = function (obj) {
+    if (obj instanceof FastPath) {
+        // Return a defensive copy of any existing FastPath instances.
+        return obj.copy();
+    }
+    if (obj instanceof types.NodePath) {
+        // For backwards compatibility, unroll NodePath instances into
+        // lightweight FastPath [..., name, value] stacks.
+        var copy = Object.create(FastPath.prototype);
+        var stack = [obj.value];
+        for (var pp = void 0; (pp = obj.parentPath); obj = pp)
+            stack.push(obj.name, pp.value);
+        copy.stack = stack.reverse();
+        return copy;
+    }
+    // Otherwise use obj as the value of the new FastPath instance.
+    return new FastPath(obj);
+};
+FPp.copy = function copy() {
+    var copy = Object.create(FastPath.prototype);
+    copy.stack = this.stack.slice(0);
+    return copy;
+};
+// The name of the current property is always the penultimate element of
+// this.stack, and always a String.
+FPp.getName = function getName() {
+    var s = this.stack;
+    var len = s.length;
+    if (len > 1) {
+        return s[len - 2];
+    }
+    // Since the name is always a string, null is a safe sentinel value to
+    // return if we do not know the name of the (root) value.
+    return null;
+};
+// The value of the current property is always the final element of
+// this.stack.
+FPp.getValue = function getValue() {
+    var s = this.stack;
+    return s[s.length - 1];
+};
+FPp.valueIsDuplicate = function () {
+    var s = this.stack;
+    var valueIndex = s.length - 1;
+    return s.lastIndexOf(s[valueIndex], valueIndex - 1) >= 0;
+};
+function getNodeHelper(path, count) {
+    var s = path.stack;
+    for (var i = s.length - 1; i >= 0; i -= 2) {
+        var value = s[i];
+        if (n.Node.check(value) && --count < 0) {
+            return value;
+        }
+    }
+    return null;
+}
+FPp.getNode = function getNode(count) {
+    if (count === void 0) { count = 0; }
+    return getNodeHelper(this, ~~count);
+};
+FPp.getParentNode = function getParentNode(count) {
+    if (count === void 0) { count = 0; }
+    return getNodeHelper(this, ~~count + 1);
+};
+// The length of the stack can be either even or odd, depending on whether
+// or not we have a name for the root value. The difference between the
+// index of the root value and the index of the final value is always
+// even, though, which allows us to return the root value in constant time
+// (i.e. without iterating backwards through the stack).
+FPp.getRootValue = function getRootValue() {
+    var s = this.stack;
+    if (s.length % 2 === 0) {
+        return s[1];
+    }
+    return s[0];
+};
+// Temporarily push properties named by string arguments given after the
+// callback function onto this.stack, then call the callback with a
+// reference to this (modified) FastPath object. Note that the stack will
+// be restored to its original state after the callback is finished, so it
+// is probably a mistake to retain a reference to the path.
+FPp.call = function call(callback /*, name1, name2, ... */) {
+    var s = this.stack;
+    var origLen = s.length;
+    var value = s[origLen - 1];
+    var argc = arguments.length;
+    for (var i = 1; i < argc; ++i) {
+        var name = arguments[i];
+        value = value[name];
+        s.push(name, value);
+    }
+    var result = callback(this);
+    s.length = origLen;
+    return result;
+};
+// Similar to FastPath.prototype.call, except that the value obtained by
+// accessing this.getValue()[name1][name2]... should be array-like. The
+// callback will be called with a reference to this path object for each
+// element of the array.
+FPp.each = function each(callback /*, name1, name2, ... */) {
+    var s = this.stack;
+    var origLen = s.length;
+    var value = s[origLen - 1];
+    var argc = arguments.length;
+    for (var i = 1; i < argc; ++i) {
+        var name = arguments[i];
+        value = value[name];
+        s.push(name, value);
+    }
+    for (var i = 0; i < value.length; ++i) {
+        if (i in value) {
+            s.push(i, value[i]);
+            // If the callback needs to know the value of i, call
+            // path.getName(), assuming path is the parameter name.
+            callback(this);
+            s.length -= 2;
+        }
+    }
+    s.length = origLen;
+};
+// Similar to FastPath.prototype.each, except that the results of the
+// callback function invocations are stored in an array and returned at
+// the end of the iteration.
+FPp.map = function map(callback /*, name1, name2, ... */) {
+    var s = this.stack;
+    var origLen = s.length;
+    var value = s[origLen - 1];
+    var argc = arguments.length;
+    for (var i = 1; i < argc; ++i) {
+        var name = arguments[i];
+        value = value[name];
+        s.push(name, value);
+    }
+    var result = new Array(value.length);
+    for (var i = 0; i < value.length; ++i) {
+        if (i in value) {
+            s.push(i, value[i]);
+            result[i] = callback(this, i);
+            s.length -= 2;
+        }
+    }
+    s.length = origLen;
+    return result;
+};
+// Returns true if the node at the tip of the path is wrapped with
+// parentheses, OR if the only reason the node needed parentheses was that
+// it couldn't be the first expression in the enclosing statement (see
+// FastPath#canBeFirstInStatement), and it has an opening `(` character.
+// For example, the FunctionExpression in `(function(){}())` appears to
+// need parentheses only because it's the first expression in the AST, but
+// since it happens to be preceded by a `(` (which is not apparent from
+// the AST but can be determined using FastPath#getPrevToken), there is no
+// ambiguity about how to parse it, so it counts as having parentheses,
+// even though it is not immediately followed by a `)`.
+FPp.hasParens = function () {
+    var node = this.getNode();
+    var prevToken = this.getPrevToken(node);
+    if (!prevToken) {
+        return false;
+    }
+    var nextToken = this.getNextToken(node);
+    if (!nextToken) {
+        return false;
+    }
+    if (prevToken.value === "(") {
+        if (nextToken.value === ")") {
+            // If the node preceded by a `(` token and followed by a `)` token,
+            // then of course it has parentheses.
+            return true;
+        }
+        // If this is one of the few Expression types that can't come first in
+        // the enclosing statement because of parsing ambiguities (namely,
+        // FunctionExpression, ObjectExpression, and ClassExpression) and
+        // this.firstInStatement() returns true, and the node would not need
+        // parentheses in an expression context because this.needsParens(true)
+        // returns false, then it just needs an opening parenthesis to resolve
+        // the parsing ambiguity that made it appear to need parentheses.
+        var justNeedsOpeningParen = !this.canBeFirstInStatement() &&
+            this.firstInStatement() &&
+            !this.needsParens(true);
+        if (justNeedsOpeningParen) {
+            return true;
+        }
+    }
+    return false;
+};
+FPp.getPrevToken = function (node) {
+    node = node || this.getNode();
+    var loc = node && node.loc;
+    var tokens = loc && loc.tokens;
+    if (tokens && loc.start.token > 0) {
+        var token = tokens[loc.start.token - 1];
+        if (token) {
+            // Do not return tokens that fall outside the root subtree.
+            var rootLoc = this.getRootValue().loc;
+            if (util.comparePos(rootLoc.start, token.loc.start) <= 0) {
+                return token;
+            }
+        }
+    }
+    return null;
+};
+FPp.getNextToken = function (node) {
+    node = node || this.getNode();
+    var loc = node && node.loc;
+    var tokens = loc && loc.tokens;
+    if (tokens && loc.end.token < tokens.length) {
+        var token = tokens[loc.end.token];
+        if (token) {
+            // Do not return tokens that fall outside the root subtree.
+            var rootLoc = this.getRootValue().loc;
+            if (util.comparePos(token.loc.end, rootLoc.end) <= 0) {
+                return token;
+            }
+        }
+    }
+    return null;
+};
+// Inspired by require("ast-types").NodePath.prototype.needsParens, but
+// more efficient because we're iterating backwards through a stack.
+FPp.needsParens = function (assumeExpressionContext) {
+    var node = this.getNode();
+    // This needs to come before `if (!parent) { return false }` because
+    // an object destructuring assignment requires parens for
+    // correctness even when it's the topmost expression.
+    if (node.type === "AssignmentExpression" &&
+        node.left.type === "ObjectPattern") {
+        return true;
+    }
+    var parent = this.getParentNode();
+    var name = this.getName();
+    // If the value of this path is some child of a Node and not a Node
+    // itself, then it doesn't need parentheses. Only Node objects (in fact,
+    // only Expression nodes) need parentheses.
+    if (this.getValue() !== node) {
+        return false;
+    }
+    // Only statements don't need parentheses.
+    if (n.Statement.check(node)) {
+        return false;
+    }
+    // Identifiers never need parentheses.
+    if (node.type === "Identifier") {
+        return false;
+    }
+    if (parent && parent.type === "ParenthesizedExpression") {
+        return false;
+    }
+    if (node.extra && node.extra.parenthesized) {
+        return true;
+    }
+    if (!parent)
+        return false;
+    switch (node.type) {
+        case "UnaryExpression":
+        case "SpreadElement":
+        case "SpreadProperty":
+            return (parent.type === "MemberExpression" &&
+                name === "object" &&
+                parent.object === node);
+        case "BinaryExpression":
+        case "LogicalExpression":
+            switch (parent.type) {
+                case "CallExpression":
+                    return name === "callee" && parent.callee === node;
+                case "UnaryExpression":
+                case "SpreadElement":
+                case "SpreadProperty":
+                    return true;
+                case "MemberExpression":
+                    return name === "object" && parent.object === node;
+                case "BinaryExpression":
+                case "LogicalExpression": {
+                    var po = parent.operator;
+                    var pp = PRECEDENCE[po];
+                    var no = node.operator;
+                    var np = PRECEDENCE[no];
+                    if (pp > np) {
+                        return true;
+                    }
+                    if (pp === np && name === "right") {
+                        assert_1.default.strictEqual(parent.right, node);
+                        return true;
+                    }
+                    break;
+                }
+                default:
+                    return false;
+            }
+            break;
+        case "SequenceExpression":
+            switch (parent.type) {
+                case "ReturnStatement":
+                    return false;
+                case "ForStatement":
+                    // Although parentheses wouldn't hurt around sequence expressions in
+                    // the head of for loops, traditional style dictates that e.g. i++,
+                    // j++ should not be wrapped with parentheses.
+                    return false;
+                case "ExpressionStatement":
+                    return name !== "expression";
+                default:
+                    // Otherwise err on the side of overparenthesization, adding
+                    // explicit exceptions above if this proves overzealous.
+                    return true;
+            }
+        case "OptionalIndexedAccessType":
+            return node.optional && parent.type === "IndexedAccessType";
+        case "IntersectionTypeAnnotation":
+        case "UnionTypeAnnotation":
+            return parent.type === "NullableTypeAnnotation";
+        case "Literal":
+            return (parent.type === "MemberExpression" &&
+                isNumber.check(node.value) &&
+                name === "object" &&
+                parent.object === node);
+        // Babel 6 Literal split
+        case "NumericLiteral":
+            return (parent.type === "MemberExpression" &&
+                name === "object" &&
+                parent.object === node);
+        case "YieldExpression":
+        case "AwaitExpression":
+        case "AssignmentExpression":
+        case "ConditionalExpression":
+            switch (parent.type) {
+                case "UnaryExpression":
+                case "SpreadElement":
+                case "SpreadProperty":
+                case "BinaryExpression":
+                case "LogicalExpression":
+                    return true;
+                case "CallExpression":
+                case "NewExpression":
+                    return name === "callee" && parent.callee === node;
+                case "ConditionalExpression":
+                    return name === "test" && parent.test === node;
+                case "MemberExpression":
+                    return name === "object" && parent.object === node;
+                default:
+                    return false;
+            }
+        case "ArrowFunctionExpression":
+            if (n.CallExpression.check(parent) &&
+                name === "callee" &&
+                parent.callee === node) {
+                return true;
+            }
+            if (n.MemberExpression.check(parent) &&
+                name === "object" &&
+                parent.object === node) {
+                return true;
+            }
+            if (n.TSAsExpression &&
+                n.TSAsExpression.check(parent) &&
+                name === "expression" &&
+                parent.expression === node) {
+                return true;
+            }
+            return isBinary(parent);
+        case "ObjectExpression":
+            if (parent.type === "ArrowFunctionExpression" &&
+                name === "body" &&
+                parent.body === node) {
+                return true;
+            }
+            break;
+        case "TSAsExpression":
+            if (parent.type === "ArrowFunctionExpression" &&
+                name === "body" &&
+                parent.body === node &&
+                node.expression.type === "ObjectExpression") {
+                return true;
+            }
+            break;
+        case "CallExpression":
+            if (name === "declaration" &&
+                n.ExportDefaultDeclaration.check(parent) &&
+                n.FunctionExpression.check(node.callee)) {
+                return true;
+            }
+    }
+    if (parent.type === "NewExpression" &&
+        name === "callee" &&
+        parent.callee === node) {
+        return containsCallExpression(node);
+    }
+    if (assumeExpressionContext !== true &&
+        !this.canBeFirstInStatement() &&
+        this.firstInStatement()) {
+        return true;
+    }
+    return false;
+};
+function isBinary(node) {
+    return n.BinaryExpression.check(node) || n.LogicalExpression.check(node);
+}
+// @ts-ignore 'isUnaryLike' is declared but its value is never read. [6133]
+function isUnaryLike(node) {
+    return (n.UnaryExpression.check(node) ||
+        // I considered making SpreadElement and SpreadProperty subtypes of
+        // UnaryExpression, but they're not really Expression nodes.
+        (n.SpreadElement && n.SpreadElement.check(node)) ||
+        (n.SpreadProperty && n.SpreadProperty.check(node)));
+}
+function containsCallExpression(node) {
+    if (n.CallExpression.check(node)) {
+        return true;
+    }
+    if (isArray.check(node)) {
+        return node.some(containsCallExpression);
+    }
+    if (n.Node.check(node)) {
+        return types.someField(node, function (_name, child) {
+            return containsCallExpression(child);
+        });
+    }
+    return false;
+}
+FPp.canBeFirstInStatement = function () {
+    var node = this.getNode();
+    if (n.FunctionExpression.check(node)) {
+        return false;
+    }
+    if (n.ObjectExpression.check(node)) {
+        return false;
+    }
+    if (n.ClassExpression.check(node)) {
+        return false;
+    }
+    return true;
+};
+FPp.firstInStatement = function () {
+    var s = this.stack;
+    var parentName, parent;
+    var childName, child;
+    for (var i = s.length - 1; i >= 0; i -= 2) {
+        if (n.Node.check(s[i])) {
+            childName = parentName;
+            child = parent;
+            parentName = s[i - 1];
+            parent = s[i];
+        }
+        if (!parent || !child) {
+            continue;
+        }
+        if (n.BlockStatement.check(parent) &&
+            parentName === "body" &&
+            childName === 0) {
+            assert_1.default.strictEqual(parent.body[0], child);
+            return true;
+        }
+        if (n.ExpressionStatement.check(parent) && childName === "expression") {
+            assert_1.default.strictEqual(parent.expression, child);
+            return true;
+        }
+        if (n.AssignmentExpression.check(parent) && childName === "left") {
+            assert_1.default.strictEqual(parent.left, child);
+            return true;
+        }
+        if (n.ArrowFunctionExpression.check(parent) && childName === "body") {
+            assert_1.default.strictEqual(parent.body, child);
+            return true;
+        }
+        // s[i + 1] and s[i + 2] represent the array between the parent
+        // SequenceExpression node and its child nodes
+        if (n.SequenceExpression.check(parent) &&
+            s[i + 1] === "expressions" &&
+            childName === 0) {
+            assert_1.default.strictEqual(parent.expressions[0], child);
+            continue;
+        }
+        if (n.CallExpression.check(parent) && childName === "callee") {
+            assert_1.default.strictEqual(parent.callee, child);
+            continue;
+        }
+        if (n.MemberExpression.check(parent) && childName === "object") {
+            assert_1.default.strictEqual(parent.object, child);
+            continue;
+        }
+        if (n.ConditionalExpression.check(parent) && childName === "test") {
+            assert_1.default.strictEqual(parent.test, child);
+            continue;
+        }
+        if (isBinary(parent) && childName === "left") {
+            assert_1.default.strictEqual(parent.left, child);
+            continue;
+        }
+        if (n.UnaryExpression.check(parent) &&
+            !parent.prefix &&
+            childName === "argument") {
+            assert_1.default.strictEqual(parent.argument, child);
+            continue;
+        }
+        return false;
+    }
+    return true;
+};
+exports.default = FastPath;

node_modules/recast/lib/lines.d.ts

@@ -0,0 +1,62 @@
+import { Options } from "./options";
+import { namedTypes } from "ast-types";
+declare type Pos = namedTypes.Position;
+declare type LineInfo = {
+    readonly line: string;
+    readonly indent: number;
+    readonly locked: boolean;
+    readonly sliceStart: number;
+    readonly sliceEnd: number;
+};
+export declare class Lines {
+    private infos;
+    readonly length: number;
+    readonly name: string | null;
+    private mappings;
+    private cachedSourceMap;
+    private cachedTabWidth;
+    constructor(infos: LineInfo[], sourceFileName?: string | null);
+    toString(options?: Options): string;
+    getSourceMap(sourceMapName: string, sourceRoot?: string): any;
+    bootstrapCharAt(pos: Pos): string;
+    charAt(pos: Pos): string;
+    stripMargin(width: number, skipFirstLine: boolean): Lines;
+    indent(by: number): Lines;
+    indentTail(by: number): Lines;
+    lockIndentTail(): Lines;
+    getIndentAt(line: number): number;
+    guessTabWidth(): number;
+    startsWithComment(): boolean;
+    isOnlyWhitespace(): boolean;
+    isPrecededOnlyByWhitespace(pos: Pos): boolean;
+    getLineLength(line: number): number;
+    nextPos(pos: Pos, skipSpaces?: boolean): boolean;
+    prevPos(pos: Pos, skipSpaces?: boolean): boolean;
+    firstPos(): {
+        line: number;
+        column: number;
+    };
+    lastPos(): {
+        line: number;
+        column: number;
+    };
+    skipSpaces(pos: Pos, backward?: boolean, modifyInPlace?: boolean): namedTypes.Position | null;
+    trimLeft(): Lines;
+    trimRight(): Lines;
+    trim(): Lines;
+    eachPos(callback: (pos: Pos) => any, startPos?: Pos, skipSpaces?: boolean): void;
+    bootstrapSlice(start: Pos, end: Pos): Lines;
+    slice(start?: Pos, end?: Pos): Lines;
+    bootstrapSliceString(start: Pos, end: Pos, options?: Options): string;
+    sliceString(start?: Pos, end?: Pos, options?: Options): string;
+    isEmpty(): boolean;
+    join(elements: (string | Lines)[]): Lines;
+    concat(...args: (string | Lines)[]): Lines;
+}
+export declare function countSpaces(spaces: any, tabWidth?: number): number;
+/**
+ * @param {Object} options - Options object that configures printing.
+ */
+export declare function fromString(string: string | Lines, options?: Options): Lines;
+export declare function concat(elements: any): Lines;
+export {};

node_modules/recast/lib/lines.js

@@ -0,0 +1,654 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concat = exports.fromString = exports.countSpaces = exports.Lines = void 0;
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+var source_map_1 = tslib_1.__importDefault(require("source-map"));
+var options_1 = require("./options");
+var util_1 = require("./util");
+var mapping_1 = tslib_1.__importDefault(require("./mapping"));
+var Lines = /** @class */ (function () {
+    function Lines(infos, sourceFileName) {
+        if (sourceFileName === void 0) { sourceFileName = null; }
+        this.infos = infos;
+        this.mappings = [];
+        this.cachedSourceMap = null;
+        this.cachedTabWidth = void 0;
+        assert_1.default.ok(infos.length > 0);
+        this.length = infos.length;
+        this.name = sourceFileName || null;
+        if (this.name) {
+            this.mappings.push(new mapping_1.default(this, {
+                start: this.firstPos(),
+                end: this.lastPos(),
+            }));
+        }
+    }
+    Lines.prototype.toString = function (options) {
+        return this.sliceString(this.firstPos(), this.lastPos(), options);
+    };
+    Lines.prototype.getSourceMap = function (sourceMapName, sourceRoot) {
+        if (!sourceMapName) {
+            // Although we could make up a name or generate an anonymous
+            // source map, instead we assume that any consumer who does not
+            // provide a name does not actually want a source map.
+            return null;
+        }
+        var targetLines = this;
+        function updateJSON(json) {
+            json = json || {};
+            json.file = sourceMapName;
+            if (sourceRoot) {
+                json.sourceRoot = sourceRoot;
+            }
+            return json;
+        }
+        if (targetLines.cachedSourceMap) {
+            // Since Lines objects are immutable, we can reuse any source map
+            // that was previously generated. Nevertheless, we return a new
+            // JSON object here to protect the cached source map from outside
+            // modification.
+            return updateJSON(targetLines.cachedSourceMap.toJSON());
+        }
+        var smg = new source_map_1.default.SourceMapGenerator(updateJSON());
+        var sourcesToContents = {};
+        targetLines.mappings.forEach(function (mapping) {
+            var sourceCursor = mapping.sourceLines.skipSpaces(mapping.sourceLoc.start) ||
+                mapping.sourceLines.lastPos();
+            var targetCursor = targetLines.skipSpaces(mapping.targetLoc.start) ||
+                targetLines.lastPos();
+            while (util_1.comparePos(sourceCursor, mapping.sourceLoc.end) < 0 &&
+                util_1.comparePos(targetCursor, mapping.targetLoc.end) < 0) {
+                var sourceChar = mapping.sourceLines.charAt(sourceCursor);
+                var targetChar = targetLines.charAt(targetCursor);
+                assert_1.default.strictEqual(sourceChar, targetChar);
+                var sourceName = mapping.sourceLines.name;
+                // Add mappings one character at a time for maximum resolution.
+                smg.addMapping({
+                    source: sourceName,
+                    original: { line: sourceCursor.line, column: sourceCursor.column },
+                    generated: { line: targetCursor.line, column: targetCursor.column },
+                });
+                if (!hasOwn.call(sourcesToContents, sourceName)) {
+                    var sourceContent = mapping.sourceLines.toString();
+                    smg.setSourceContent(sourceName, sourceContent);
+                    sourcesToContents[sourceName] = sourceContent;
+                }
+                targetLines.nextPos(targetCursor, true);
+                mapping.sourceLines.nextPos(sourceCursor, true);
+            }
+        });
+        targetLines.cachedSourceMap = smg;
+        return smg.toJSON();
+    };
+    Lines.prototype.bootstrapCharAt = function (pos) {
+        assert_1.default.strictEqual(typeof pos, "object");
+        assert_1.default.strictEqual(typeof pos.line, "number");
+        assert_1.default.strictEqual(typeof pos.column, "number");
+        var line = pos.line, column = pos.column, strings = this.toString().split(lineTerminatorSeqExp), string = strings[line - 1];
+        if (typeof string === "undefined")
+            return "";
+        if (column === string.length && line < strings.length)
+            return "\n";
+        if (column >= string.length)
+            return "";
+        return string.charAt(column);
+    };
+    Lines.prototype.charAt = function (pos) {
+        assert_1.default.strictEqual(typeof pos, "object");
+        assert_1.default.strictEqual(typeof pos.line, "number");
+        assert_1.default.strictEqual(typeof pos.column, "number");
+        var line = pos.line, column = pos.column, secret = this, infos = secret.infos, info = infos[line - 1], c = column;
+        if (typeof info === "undefined" || c < 0)
+            return "";
+        var indent = this.getIndentAt(line);
+        if (c < indent)
+            return " ";
+        c += info.sliceStart - indent;
+        if (c === info.sliceEnd && line < this.length)
+            return "\n";
+        if (c >= info.sliceEnd)
+            return "";
+        return info.line.charAt(c);
+    };
+    Lines.prototype.stripMargin = function (width, skipFirstLine) {
+        if (width === 0)
+            return this;
+        assert_1.default.ok(width > 0, "negative margin: " + width);
+        if (skipFirstLine && this.length === 1)
+            return this;
+        var lines = new Lines(this.infos.map(function (info, i) {
+            if (info.line && (i > 0 || !skipFirstLine)) {
+                info = tslib_1.__assign(tslib_1.__assign({}, info), { indent: Math.max(0, info.indent - width) });
+            }
+            return info;
+        }));
+        if (this.mappings.length > 0) {
+            var newMappings_1 = lines.mappings;
+            assert_1.default.strictEqual(newMappings_1.length, 0);
+            this.mappings.forEach(function (mapping) {
+                newMappings_1.push(mapping.indent(width, skipFirstLine, true));
+            });
+        }
+        return lines;
+    };
+    Lines.prototype.indent = function (by) {
+        if (by === 0) {
+            return this;
+        }
+        var lines = new Lines(this.infos.map(function (info) {
+            if (info.line && !info.locked) {
+                info = tslib_1.__assign(tslib_1.__assign({}, info), { indent: info.indent + by });
+            }
+            return info;
+        }));
+        if (this.mappings.length > 0) {
+            var newMappings_2 = lines.mappings;
+            assert_1.default.strictEqual(newMappings_2.length, 0);
+            this.mappings.forEach(function (mapping) {
+                newMappings_2.push(mapping.indent(by));
+            });
+        }
+        return lines;
+    };
+    Lines.prototype.indentTail = function (by) {
+        if (by === 0) {
+            return this;
+        }
+        if (this.length < 2) {
+            return this;
+        }
+        var lines = new Lines(this.infos.map(function (info, i) {
+            if (i > 0 && info.line && !info.locked) {
+                info = tslib_1.__assign(tslib_1.__assign({}, info), { indent: info.indent + by });
+            }
+            return info;
+        }));
+        if (this.mappings.length > 0) {
+            var newMappings_3 = lines.mappings;
+            assert_1.default.strictEqual(newMappings_3.length, 0);
+            this.mappings.forEach(function (mapping) {
+                newMappings_3.push(mapping.indent(by, true));
+            });
+        }
+        return lines;
+    };
+    Lines.prototype.lockIndentTail = function () {
+        if (this.length < 2) {
+            return this;
+        }
+        return new Lines(this.infos.map(function (info, i) { return (tslib_1.__assign(tslib_1.__assign({}, info), { locked: i > 0 })); }));
+    };
+    Lines.prototype.getIndentAt = function (line) {
+        assert_1.default.ok(line >= 1, "no line " + line + " (line numbers start from 1)");
+        return Math.max(this.infos[line - 1].indent, 0);
+    };
+    Lines.prototype.guessTabWidth = function () {
+        if (typeof this.cachedTabWidth === "number") {
+            return this.cachedTabWidth;
+        }
+        var counts = []; // Sparse array.
+        var lastIndent = 0;
+        for (var line = 1, last = this.length; line <= last; ++line) {
+            var info = this.infos[line - 1];
+            var sliced = info.line.slice(info.sliceStart, info.sliceEnd);
+            // Whitespace-only lines don't tell us much about the likely tab
+            // width of this code.
+            if (isOnlyWhitespace(sliced)) {
+                continue;
+            }
+            var diff = Math.abs(info.indent - lastIndent);
+            counts[diff] = ~~counts[diff] + 1;
+            lastIndent = info.indent;
+        }
+        var maxCount = -1;
+        var result = 2;
+        for (var tabWidth = 1; tabWidth < counts.length; tabWidth += 1) {
+            if (hasOwn.call(counts, tabWidth) && counts[tabWidth] > maxCount) {
+                maxCount = counts[tabWidth];
+                result = tabWidth;
+            }
+        }
+        return (this.cachedTabWidth = result);
+    };
+    // Determine if the list of lines has a first line that starts with a //
+    // or /* comment. If this is the case, the code may need to be wrapped in
+    // parens to avoid ASI issues.
+    Lines.prototype.startsWithComment = function () {
+        if (this.infos.length === 0) {
+            return false;
+        }
+        var firstLineInfo = this.infos[0], sliceStart = firstLineInfo.sliceStart, sliceEnd = firstLineInfo.sliceEnd, firstLine = firstLineInfo.line.slice(sliceStart, sliceEnd).trim();
+        return (firstLine.length === 0 ||
+            firstLine.slice(0, 2) === "//" ||
+            firstLine.slice(0, 2) === "/*");
+    };
+    Lines.prototype.isOnlyWhitespace = function () {
+        return isOnlyWhitespace(this.toString());
+    };
+    Lines.prototype.isPrecededOnlyByWhitespace = function (pos) {
+        var info = this.infos[pos.line - 1];
+        var indent = Math.max(info.indent, 0);
+        var diff = pos.column - indent;
+        if (diff <= 0) {
+            // If pos.column does not exceed the indentation amount, then
+            // there must be only whitespace before it.
+            return true;
+        }
+        var start = info.sliceStart;
+        var end = Math.min(start + diff, info.sliceEnd);
+        var prefix = info.line.slice(start, end);
+        return isOnlyWhitespace(prefix);
+    };
+    Lines.prototype.getLineLength = function (line) {
+        var info = this.infos[line - 1];
+        return this.getIndentAt(line) + info.sliceEnd - info.sliceStart;
+    };
+    Lines.prototype.nextPos = function (pos, skipSpaces) {
+        if (skipSpaces === void 0) { skipSpaces = false; }
+        var l = Math.max(pos.line, 0), c = Math.max(pos.column, 0);
+        if (c < this.getLineLength(l)) {
+            pos.column += 1;
+            return skipSpaces ? !!this.skipSpaces(pos, false, true) : true;
+        }
+        if (l < this.length) {
+            pos.line += 1;
+            pos.column = 0;
+            return skipSpaces ? !!this.skipSpaces(pos, false, true) : true;
+        }
+        return false;
+    };
+    Lines.prototype.prevPos = function (pos, skipSpaces) {
+        if (skipSpaces === void 0) { skipSpaces = false; }
+        var l = pos.line, c = pos.column;
+        if (c < 1) {
+            l -= 1;
+            if (l < 1)
+                return false;
+            c = this.getLineLength(l);
+        }
+        else {
+            c = Math.min(c - 1, this.getLineLength(l));
+        }
+        pos.line = l;
+        pos.column = c;
+        return skipSpaces ? !!this.skipSpaces(pos, true, true) : true;
+    };
+    Lines.prototype.firstPos = function () {
+        // Trivial, but provided for completeness.
+        return { line: 1, column: 0 };
+    };
+    Lines.prototype.lastPos = function () {
+        return {
+            line: this.length,
+            column: this.getLineLength(this.length),
+        };
+    };
+    Lines.prototype.skipSpaces = function (pos, backward, modifyInPlace) {
+        if (backward === void 0) { backward = false; }
+        if (modifyInPlace === void 0) { modifyInPlace = false; }
+        if (pos) {
+            pos = modifyInPlace
+                ? pos
+                : {
+                    line: pos.line,
+                    column: pos.column,
+                };
+        }
+        else if (backward) {
+            pos = this.lastPos();
+        }
+        else {
+            pos = this.firstPos();
+        }
+        if (backward) {
+            while (this.prevPos(pos)) {
+                if (!isOnlyWhitespace(this.charAt(pos)) && this.nextPos(pos)) {
+                    return pos;
+                }
+            }
+            return null;
+        }
+        else {
+            while (isOnlyWhitespace(this.charAt(pos))) {
+                if (!this.nextPos(pos)) {
+                    return null;
+                }
+            }
+            return pos;
+        }
+    };
+    Lines.prototype.trimLeft = function () {
+        var pos = this.skipSpaces(this.firstPos(), false, true);
+        return pos ? this.slice(pos) : emptyLines;
+    };
+    Lines.prototype.trimRight = function () {
+        var pos = this.skipSpaces(this.lastPos(), true, true);
+        return pos ? this.slice(this.firstPos(), pos) : emptyLines;
+    };
+    Lines.prototype.trim = function () {
+        var start = this.skipSpaces(this.firstPos(), false, true);
+        if (start === null) {
+            return emptyLines;
+        }
+        var end = this.skipSpaces(this.lastPos(), true, true);
+        if (end === null) {
+            return emptyLines;
+        }
+        return this.slice(start, end);
+    };
+    Lines.prototype.eachPos = function (callback, startPos, skipSpaces) {
+        if (startPos === void 0) { startPos = this.firstPos(); }
+        if (skipSpaces === void 0) { skipSpaces = false; }
+        var pos = this.firstPos();
+        if (startPos) {
+            (pos.line = startPos.line), (pos.column = startPos.column);
+        }
+        if (skipSpaces && !this.skipSpaces(pos, false, true)) {
+            return; // Encountered nothing but spaces.
+        }
+        do
+            callback.call(this, pos);
+        while (this.nextPos(pos, skipSpaces));
+    };
+    Lines.prototype.bootstrapSlice = function (start, end) {
+        var strings = this.toString()
+            .split(lineTerminatorSeqExp)
+            .slice(start.line - 1, end.line);
+        if (strings.length > 0) {
+            strings.push(strings.pop().slice(0, end.column));
+            strings[0] = strings[0].slice(start.column);
+        }
+        return fromString(strings.join("\n"));
+    };
+    Lines.prototype.slice = function (start, end) {
+        if (!end) {
+            if (!start) {
+                // The client seems to want a copy of this Lines object, but
+                // Lines objects are immutable, so it's perfectly adequate to
+                // return the same object.
+                return this;
+            }
+            // Slice to the end if no end position was provided.
+            end = this.lastPos();
+        }
+        if (!start) {
+            throw new Error("cannot slice with end but not start");
+        }
+        var sliced = this.infos.slice(start.line - 1, end.line);
+        if (start.line === end.line) {
+            sliced[0] = sliceInfo(sliced[0], start.column, end.column);
+        }
+        else {
+            assert_1.default.ok(start.line < end.line);
+            sliced[0] = sliceInfo(sliced[0], start.column);
+            sliced.push(sliceInfo(sliced.pop(), 0, end.column));
+        }
+        var lines = new Lines(sliced);
+        if (this.mappings.length > 0) {
+            var newMappings_4 = lines.mappings;
+            assert_1.default.strictEqual(newMappings_4.length, 0);
+            this.mappings.forEach(function (mapping) {
+                var sliced = mapping.slice(this, start, end);
+                if (sliced) {
+                    newMappings_4.push(sliced);
+                }
+            }, this);
+        }
+        return lines;
+    };
+    Lines.prototype.bootstrapSliceString = function (start, end, options) {
+        return this.slice(start, end).toString(options);
+    };
+    Lines.prototype.sliceString = function (start, end, options) {
+        if (start === void 0) { start = this.firstPos(); }
+        if (end === void 0) { end = this.lastPos(); }
+        var _a = options_1.normalize(options), tabWidth = _a.tabWidth, useTabs = _a.useTabs, reuseWhitespace = _a.reuseWhitespace, lineTerminator = _a.lineTerminator;
+        var parts = [];
+        for (var line = start.line; line <= end.line; ++line) {
+            var info = this.infos[line - 1];
+            if (line === start.line) {
+                if (line === end.line) {
+                    info = sliceInfo(info, start.column, end.column);
+                }
+                else {
+                    info = sliceInfo(info, start.column);
+                }
+            }
+            else if (line === end.line) {
+                info = sliceInfo(info, 0, end.column);
+            }
+            var indent = Math.max(info.indent, 0);
+            var before_1 = info.line.slice(0, info.sliceStart);
+            if (reuseWhitespace &&
+                isOnlyWhitespace(before_1) &&
+                countSpaces(before_1, tabWidth) === indent) {
+                // Reuse original spaces if the indentation is correct.
+                parts.push(info.line.slice(0, info.sliceEnd));
+                continue;
+            }
+            var tabs = 0;
+            var spaces = indent;
+            if (useTabs) {
+                tabs = Math.floor(indent / tabWidth);
+                spaces -= tabs * tabWidth;
+            }
+            var result = "";
+            if (tabs > 0) {
+                result += new Array(tabs + 1).join("\t");
+            }
+            if (spaces > 0) {
+                result += new Array(spaces + 1).join(" ");
+            }
+            result += info.line.slice(info.sliceStart, info.sliceEnd);
+            parts.push(result);
+        }
+        return parts.join(lineTerminator);
+    };
+    Lines.prototype.isEmpty = function () {
+        return this.length < 2 && this.getLineLength(1) < 1;
+    };
+    Lines.prototype.join = function (elements) {
+        var separator = this;
+        var infos = [];
+        var mappings = [];
+        var prevInfo;
+        function appendLines(linesOrNull) {
+            if (linesOrNull === null) {
+                return;
+            }
+            if (prevInfo) {
+                var info = linesOrNull.infos[0];
+                var indent = new Array(info.indent + 1).join(" ");
+                var prevLine_1 = infos.length;
+                var prevColumn_1 = Math.max(prevInfo.indent, 0) +
+                    prevInfo.sliceEnd -
+                    prevInfo.sliceStart;
+                prevInfo.line =
+                    prevInfo.line.slice(0, prevInfo.sliceEnd) +
+                        indent +
+                        info.line.slice(info.sliceStart, info.sliceEnd);
+                // If any part of a line is indentation-locked, the whole line
+                // will be indentation-locked.
+                prevInfo.locked = prevInfo.locked || info.locked;
+                prevInfo.sliceEnd = prevInfo.line.length;
+                if (linesOrNull.mappings.length > 0) {
+                    linesOrNull.mappings.forEach(function (mapping) {
+                        mappings.push(mapping.add(prevLine_1, prevColumn_1));
+                    });
+                }
+            }
+            else if (linesOrNull.mappings.length > 0) {
+                mappings.push.apply(mappings, linesOrNull.mappings);
+            }
+            linesOrNull.infos.forEach(function (info, i) {
+                if (!prevInfo || i > 0) {
+                    prevInfo = tslib_1.__assign({}, info);
+                    infos.push(prevInfo);
+                }
+            });
+        }
+        function appendWithSeparator(linesOrNull, i) {
+            if (i > 0)
+                appendLines(separator);
+            appendLines(linesOrNull);
+        }
+        elements
+            .map(function (elem) {
+            var lines = fromString(elem);
+            if (lines.isEmpty())
+                return null;
+            return lines;
+        })
+            .forEach(function (linesOrNull, i) {
+            if (separator.isEmpty()) {
+                appendLines(linesOrNull);
+            }
+            else {
+                appendWithSeparator(linesOrNull, i);
+            }
+        });
+        if (infos.length < 1)
+            return emptyLines;
+        var lines = new Lines(infos);
+        lines.mappings = mappings;
+        return lines;
+    };
+    Lines.prototype.concat = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var list = [this];
+        list.push.apply(list, args);
+        assert_1.default.strictEqual(list.length, args.length + 1);
+        return emptyLines.join(list);
+    };
+    return Lines;
+}());
+exports.Lines = Lines;
+var fromStringCache = {};
+var hasOwn = fromStringCache.hasOwnProperty;
+var maxCacheKeyLen = 10;
+function countSpaces(spaces, tabWidth) {
+    var count = 0;
+    var len = spaces.length;
+    for (var i = 0; i < len; ++i) {
+        switch (spaces.charCodeAt(i)) {
+            case 9: {
+                // '\t'
+                assert_1.default.strictEqual(typeof tabWidth, "number");
+                assert_1.default.ok(tabWidth > 0);
+                var next = Math.ceil(count / tabWidth) * tabWidth;
+                if (next === count) {
+                    count += tabWidth;
+                }
+                else {
+                    count = next;
+                }
+                break;
+            }
+            case 11: // '\v'
+            case 12: // '\f'
+            case 13: // '\r'
+            case 0xfeff: // zero-width non-breaking space
+                // These characters contribute nothing to indentation.
+                break;
+            case 32: // ' '
+            default:
+                // Treat all other whitespace like ' '.
+                count += 1;
+                break;
+        }
+    }
+    return count;
+}
+exports.countSpaces = countSpaces;
+var leadingSpaceExp = /^\s*/;
+// As specified here: http://www.ecma-international.org/ecma-262/6.0/#sec-line-terminators
+var lineTerminatorSeqExp = /\u000D\u000A|\u000D(?!\u000A)|\u000A|\u2028|\u2029/;
+/**
+ * @param {Object} options - Options object that configures printing.
+ */
+function fromString(string, options) {
+    if (string instanceof Lines)
+        return string;
+    string += "";
+    var tabWidth = options && options.tabWidth;
+    var tabless = string.indexOf("\t") < 0;
+    var cacheable = !options && tabless && string.length <= maxCacheKeyLen;
+    assert_1.default.ok(tabWidth || tabless, "No tab width specified but encountered tabs in string\n" + string);
+    if (cacheable && hasOwn.call(fromStringCache, string))
+        return fromStringCache[string];
+    var lines = new Lines(string.split(lineTerminatorSeqExp).map(function (line) {
+        // TODO: handle null exec result
+        var spaces = leadingSpaceExp.exec(line)[0];
+        return {
+            line: line,
+            indent: countSpaces(spaces, tabWidth),
+            // Boolean indicating whether this line can be reindented.
+            locked: false,
+            sliceStart: spaces.length,
+            sliceEnd: line.length,
+        };
+    }), options_1.normalize(options).sourceFileName);
+    if (cacheable)
+        fromStringCache[string] = lines;
+    return lines;
+}
+exports.fromString = fromString;
+function isOnlyWhitespace(string) {
+    return !/\S/.test(string);
+}
+function sliceInfo(info, startCol, endCol) {
+    var sliceStart = info.sliceStart;
+    var sliceEnd = info.sliceEnd;
+    var indent = Math.max(info.indent, 0);
+    var lineLength = indent + sliceEnd - sliceStart;
+    if (typeof endCol === "undefined") {
+        endCol = lineLength;
+    }
+    startCol = Math.max(startCol, 0);
+    endCol = Math.min(endCol, lineLength);
+    endCol = Math.max(endCol, startCol);
+    if (endCol < indent) {
+        indent = endCol;
+        sliceEnd = sliceStart;
+    }
+    else {
+        sliceEnd -= lineLength - endCol;
+    }
+    lineLength = endCol;
+    lineLength -= startCol;
+    if (startCol < indent) {
+        indent -= startCol;
+    }
+    else {
+        startCol -= indent;
+        indent = 0;
+        sliceStart += startCol;
+    }
+    assert_1.default.ok(indent >= 0);
+    assert_1.default.ok(sliceStart <= sliceEnd);
+    assert_1.default.strictEqual(lineLength, indent + sliceEnd - sliceStart);
+    if (info.indent === indent &&
+        info.sliceStart === sliceStart &&
+        info.sliceEnd === sliceEnd) {
+        return info;
+    }
+    return {
+        line: info.line,
+        indent: indent,
+        // A destructive slice always unlocks indentation.
+        locked: false,
+        sliceStart: sliceStart,
+        sliceEnd: sliceEnd,
+    };
+}
+function concat(elements) {
+    return emptyLines.join(elements);
+}
+exports.concat = concat;
+// The emptyLines object needs to be created all the way down here so that
+// Lines.prototype will be fully populated.
+var emptyLines = fromString("");

node_modules/recast/lib/mapping.d.ts

@@ -0,0 +1,15 @@
+import { namedTypes } from "ast-types";
+import { Lines } from "./lines";
+declare type Pos = namedTypes.Position;
+declare type Loc = namedTypes.SourceLocation;
+export default class Mapping {
+    sourceLines: Lines;
+    sourceLoc: Loc;
+    targetLoc: Loc;
+    constructor(sourceLines: Lines, sourceLoc: Loc, targetLoc?: Loc);
+    slice(lines: Lines, start: Pos, end?: Pos): Mapping | null;
+    add(line: number, column: number): Mapping;
+    subtract(line: number, column: number): Mapping;
+    indent(by: number, skipFirstLine?: boolean, noNegativeColumns?: boolean): Mapping;
+}
+export {};

node_modules/recast/lib/mapping.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+var util_1 = require("./util");
+var Mapping = /** @class */ (function () {
+    function Mapping(sourceLines, sourceLoc, targetLoc) {
+        if (targetLoc === void 0) { targetLoc = sourceLoc; }
+        this.sourceLines = sourceLines;
+        this.sourceLoc = sourceLoc;
+        this.targetLoc = targetLoc;
+    }
+    Mapping.prototype.slice = function (lines, start, end) {
+        if (end === void 0) { end = lines.lastPos(); }
+        var sourceLines = this.sourceLines;
+        var sourceLoc = this.sourceLoc;
+        var targetLoc = this.targetLoc;
+        function skip(name) {
+            var sourceFromPos = sourceLoc[name];
+            var targetFromPos = targetLoc[name];
+            var targetToPos = start;
+            if (name === "end") {
+                targetToPos = end;
+            }
+            else {
+                assert_1.default.strictEqual(name, "start");
+            }
+            return skipChars(sourceLines, sourceFromPos, lines, targetFromPos, targetToPos);
+        }
+        if (util_1.comparePos(start, targetLoc.start) <= 0) {
+            if (util_1.comparePos(targetLoc.end, end) <= 0) {
+                targetLoc = {
+                    start: subtractPos(targetLoc.start, start.line, start.column),
+                    end: subtractPos(targetLoc.end, start.line, start.column),
+                };
+                // The sourceLoc can stay the same because the contents of the
+                // targetLoc have not changed.
+            }
+            else if (util_1.comparePos(end, targetLoc.start) <= 0) {
+                return null;
+            }
+            else {
+                sourceLoc = {
+                    start: sourceLoc.start,
+                    end: skip("end"),
+                };
+                targetLoc = {
+                    start: subtractPos(targetLoc.start, start.line, start.column),
+                    end: subtractPos(end, start.line, start.column),
+                };
+            }
+        }
+        else {
+            if (util_1.comparePos(targetLoc.end, start) <= 0) {
+                return null;
+            }
+            if (util_1.comparePos(targetLoc.end, end) <= 0) {
+                sourceLoc = {
+                    start: skip("start"),
+                    end: sourceLoc.end,
+                };
+                targetLoc = {
+                    // Same as subtractPos(start, start.line, start.column):
+                    start: { line: 1, column: 0 },
+                    end: subtractPos(targetLoc.end, start.line, start.column),
+                };
+            }
+            else {
+                sourceLoc = {
+                    start: skip("start"),
+                    end: skip("end"),
+                };
+                targetLoc = {
+                    // Same as subtractPos(start, start.line, start.column):
+                    start: { line: 1, column: 0 },
+                    end: subtractPos(end, start.line, start.column),
+                };
+            }
+        }
+        return new Mapping(this.sourceLines, sourceLoc, targetLoc);
+    };
+    Mapping.prototype.add = function (line, column) {
+        return new Mapping(this.sourceLines, this.sourceLoc, {
+            start: addPos(this.targetLoc.start, line, column),
+            end: addPos(this.targetLoc.end, line, column),
+        });
+    };
+    Mapping.prototype.subtract = function (line, column) {
+        return new Mapping(this.sourceLines, this.sourceLoc, {
+            start: subtractPos(this.targetLoc.start, line, column),
+            end: subtractPos(this.targetLoc.end, line, column),
+        });
+    };
+    Mapping.prototype.indent = function (by, skipFirstLine, noNegativeColumns) {
+        if (skipFirstLine === void 0) { skipFirstLine = false; }
+        if (noNegativeColumns === void 0) { noNegativeColumns = false; }
+        if (by === 0) {
+            return this;
+        }
+        var targetLoc = this.targetLoc;
+        var startLine = targetLoc.start.line;
+        var endLine = targetLoc.end.line;
+        if (skipFirstLine && startLine === 1 && endLine === 1) {
+            return this;
+        }
+        targetLoc = {
+            start: targetLoc.start,
+            end: targetLoc.end,
+        };
+        if (!skipFirstLine || startLine > 1) {
+            var startColumn = targetLoc.start.column + by;
+            targetLoc.start = {
+                line: startLine,
+                column: noNegativeColumns ? Math.max(0, startColumn) : startColumn,
+            };
+        }
+        if (!skipFirstLine || endLine > 1) {
+            var endColumn = targetLoc.end.column + by;
+            targetLoc.end = {
+                line: endLine,
+                column: noNegativeColumns ? Math.max(0, endColumn) : endColumn,
+            };
+        }
+        return new Mapping(this.sourceLines, this.sourceLoc, targetLoc);
+    };
+    return Mapping;
+}());
+exports.default = Mapping;
+function addPos(toPos, line, column) {
+    return {
+        line: toPos.line + line - 1,
+        column: toPos.line === 1 ? toPos.column + column : toPos.column,
+    };
+}
+function subtractPos(fromPos, line, column) {
+    return {
+        line: fromPos.line - line + 1,
+        column: fromPos.line === line ? fromPos.column - column : fromPos.column,
+    };
+}
+function skipChars(sourceLines, sourceFromPos, targetLines, targetFromPos, targetToPos) {
+    var targetComparison = util_1.comparePos(targetFromPos, targetToPos);
+    if (targetComparison === 0) {
+        // Trivial case: no characters to skip.
+        return sourceFromPos;
+    }
+    var sourceCursor, targetCursor;
+    if (targetComparison < 0) {
+        // Skipping forward.
+        sourceCursor =
+            sourceLines.skipSpaces(sourceFromPos) || sourceLines.lastPos();
+        targetCursor =
+            targetLines.skipSpaces(targetFromPos) || targetLines.lastPos();
+        var lineDiff = targetToPos.line - targetCursor.line;
+        sourceCursor.line += lineDiff;
+        targetCursor.line += lineDiff;
+        if (lineDiff > 0) {
+            // If jumping to later lines, reset columns to the beginnings
+            // of those lines.
+            sourceCursor.column = 0;
+            targetCursor.column = 0;
+        }
+        else {
+            assert_1.default.strictEqual(lineDiff, 0);
+        }
+        while (util_1.comparePos(targetCursor, targetToPos) < 0 &&
+            targetLines.nextPos(targetCursor, true)) {
+            assert_1.default.ok(sourceLines.nextPos(sourceCursor, true));
+            assert_1.default.strictEqual(sourceLines.charAt(sourceCursor), targetLines.charAt(targetCursor));
+        }
+    }
+    else {
+        // Skipping backward.
+        sourceCursor =
+            sourceLines.skipSpaces(sourceFromPos, true) || sourceLines.firstPos();
+        targetCursor =
+            targetLines.skipSpaces(targetFromPos, true) || targetLines.firstPos();
+        var lineDiff = targetToPos.line - targetCursor.line;
+        sourceCursor.line += lineDiff;
+        targetCursor.line += lineDiff;
+        if (lineDiff < 0) {
+            // If jumping to earlier lines, reset columns to the ends of
+            // those lines.
+            sourceCursor.column = sourceLines.getLineLength(sourceCursor.line);
+            targetCursor.column = targetLines.getLineLength(targetCursor.line);
+        }
+        else {
+            assert_1.default.strictEqual(lineDiff, 0);
+        }
+        while (util_1.comparePos(targetToPos, targetCursor) < 0 &&
+            targetLines.prevPos(targetCursor, true)) {
+            assert_1.default.ok(sourceLines.prevPos(sourceCursor, true));
+            assert_1.default.strictEqual(sourceLines.charAt(sourceCursor), targetLines.charAt(targetCursor));
+        }
+    }
+    return sourceCursor;
+}

node_modules/recast/lib/options.d.ts

@@ -0,0 +1,148 @@
+import { Omit } from "ast-types/types";
+/**
+ * All Recast API functions take second parameter with configuration options,
+ * documented in options.js
+ */
+export interface Options extends DeprecatedOptions {
+    /**
+     * If you want to use a different branch of esprima, or any other module
+     * that supports a .parse function, pass that module object to
+     * recast.parse as options.parser (legacy synonym: options.esprima).
+     * @default require("recast/parsers/esprima")
+     */
+    parser?: any;
+    /**
+     * Number of spaces the pretty-printer should use per tab for
+     * indentation. If you do not pass this option explicitly, it will be
+     * (quite reliably!) inferred from the original code.
+     * @default 4
+     */
+    tabWidth?: number;
+    /**
+     * If you really want the pretty-printer to use tabs instead of spaces,
+     * make this option true.
+     * @default false
+     */
+    useTabs?: boolean;
+    /**
+     * The reprinting code leaves leading whitespace untouched unless it has
+     * to reindent a line, or you pass false for this option.
+     * @default true
+     */
+    reuseWhitespace?: boolean;
+    /**
+     * Override this option to use a different line terminator, e.g. \r\n.
+     * @default require("os").EOL || "\n"
+     */
+    lineTerminator?: string;
+    /**
+     * Some of the pretty-printer code (such as that for printing function
+     * parameter lists) makes a valiant attempt to prevent really long
+     * lines. You can adjust the limit by changing this option; however,
+     * there is no guarantee that line length will fit inside this limit.
+     * @default 74
+     */
+    wrapColumn?: number;
+    /**
+     * Pass a string as options.sourceFileName to recast.parse to tell the
+     * reprinter to keep track of reused code so that it can construct a
+     * source map automatically.
+     * @default null
+     */
+    sourceFileName?: string | null;
+    /**
+     * Pass a string as options.sourceMapName to recast.print, and (provided
+     * you passed options.sourceFileName earlier) the PrintResult of
+     * recast.print will have a .map property for the generated source map.
+     * @default null
+     */
+    sourceMapName?: string | null;
+    /**
+     * If provided, this option will be passed along to the source map
+     * generator as a root directory for relative source file paths.
+     * @default null
+     */
+    sourceRoot?: string | null;
+    /**
+     * If you provide a source map that was generated from a previous call
+     * to recast.print as options.inputSourceMap, the old source map will be
+     * composed with the new source map.
+     * @default null
+     */
+    inputSourceMap?: string | null;
+    /**
+     * If you want esprima to generate .range information (recast only uses
+     * .loc internally), pass true for this option.
+     * @default false
+     */
+    range?: boolean;
+    /**
+     * If you want esprima not to throw exceptions when it encounters
+     * non-fatal errors, keep this option true.
+     * @default true
+     */
+    tolerant?: boolean;
+    /**
+     * If you want to override the quotes used in string literals, specify
+     * either "single", "double", or "auto" here ("auto" will select the one
+     * which results in the shorter literal) Otherwise, use double quotes.
+     * @default null
+     */
+    quote?: "single" | "double" | "auto" | null;
+    /**
+     * Controls the printing of trailing commas in object literals, array
+     * expressions and function parameters.
+     *
+     * This option could either be:
+     * * Boolean - enable/disable in all contexts (objects, arrays and function params).
+     * * Object - enable/disable per context.
+     *
+     * Example:
+     * trailingComma: {
+     *   objects: true,
+     *   arrays: true,
+     *   parameters: false,
+     * }
+     *
+     * @default false
+     */
+    trailingComma?: boolean;
+    /**
+     * Controls the printing of spaces inside array brackets.
+     * See: http://eslint.org/docs/rules/array-bracket-spacing
+     * @default false
+     */
+    arrayBracketSpacing?: boolean;
+    /**
+     * Controls the printing of spaces inside object literals,
+     * destructuring assignments, and import/export specifiers.
+     * See: http://eslint.org/docs/rules/object-curly-spacing
+     * @default true
+     */
+    objectCurlySpacing?: boolean;
+    /**
+     * If you want parenthesis to wrap single-argument arrow function
+     * parameter lists, pass true for this option.
+     * @default false
+     */
+    arrowParensAlways?: boolean;
+    /**
+     * There are 2 supported syntaxes (`,` and `;`) in Flow Object Types;
+     * The use of commas is in line with the more popular style and matches
+     * how objects are defined in JS, making it a bit more natural to write.
+     * @default true
+     */
+    flowObjectCommas?: boolean;
+    /**
+     * Whether to return an array of .tokens on the root AST node.
+     * @default true
+     */
+    tokens?: boolean;
+}
+interface DeprecatedOptions {
+    /** @deprecated */
+    esprima?: any;
+}
+export declare type NormalizedOptions = Required<Omit<Options, keyof DeprecatedOptions>>;
+export declare function normalize(opts?: Options): NormalizedOptions;
+export {};

node_modules/recast/lib/options.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize = void 0;
+var util_1 = require("./util");
+var defaults = {
+    parser: require("../parsers/esprima"),
+    tabWidth: 4,
+    useTabs: false,
+    reuseWhitespace: true,
+    lineTerminator: util_1.getLineTerminator(),
+    wrapColumn: 74,
+    sourceFileName: null,
+    sourceMapName: null,
+    sourceRoot: null,
+    inputSourceMap: null,
+    range: false,
+    tolerant: true,
+    quote: null,
+    trailingComma: false,
+    arrayBracketSpacing: false,
+    objectCurlySpacing: true,
+    arrowParensAlways: false,
+    flowObjectCommas: true,
+    tokens: true,
+};
+var hasOwn = defaults.hasOwnProperty;
+// Copy options and fill in default values.
+function normalize(opts) {
+    var options = opts || defaults;
+    function get(key) {
+        return hasOwn.call(options, key) ? options[key] : defaults[key];
+    }
+    return {
+        tabWidth: +get("tabWidth"),
+        useTabs: !!get("useTabs"),
+        reuseWhitespace: !!get("reuseWhitespace"),
+        lineTerminator: get("lineTerminator"),
+        wrapColumn: Math.max(get("wrapColumn"), 0),
+        sourceFileName: get("sourceFileName"),
+        sourceMapName: get("sourceMapName"),
+        sourceRoot: get("sourceRoot"),
+        inputSourceMap: get("inputSourceMap"),
+        parser: get("esprima") || get("parser"),
+        range: get("range"),
+        tolerant: get("tolerant"),
+        quote: get("quote"),
+        trailingComma: get("trailingComma"),
+        arrayBracketSpacing: get("arrayBracketSpacing"),
+        objectCurlySpacing: get("objectCurlySpacing"),
+        arrowParensAlways: get("arrowParensAlways"),
+        flowObjectCommas: get("flowObjectCommas"),
+        tokens: !!get("tokens"),
+    };
+}
+exports.normalize = normalize;

node_modules/recast/lib/parser.d.ts

@@ -0,0 +1,2 @@
+import { Options } from "./options";
+export declare function parse(source: string, options?: Partial<Options>): any;

node_modules/recast/lib/parser.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+var types = tslib_1.__importStar(require("ast-types"));
+var b = types.builders;
+var isObject = types.builtInTypes.object;
+var isArray = types.builtInTypes.array;
+var options_1 = require("./options");
+var lines_1 = require("./lines");
+var comments_1 = require("./comments");
+var util = tslib_1.__importStar(require("./util"));
+function parse(source, options) {
+    options = options_1.normalize(options);
+    var lines = lines_1.fromString(source, options);
+    var sourceWithoutTabs = lines.toString({
+        tabWidth: options.tabWidth,
+        reuseWhitespace: false,
+        useTabs: false,
+    });
+    var comments = [];
+    var ast = options.parser.parse(sourceWithoutTabs, {
+        jsx: true,
+        loc: true,
+        locations: true,
+        range: options.range,
+        comment: true,
+        onComment: comments,
+        tolerant: util.getOption(options, "tolerant", true),
+        ecmaVersion: 6,
+        sourceType: util.getOption(options, "sourceType", "module"),
+    });
+    // Use ast.tokens if possible, and otherwise fall back to the Esprima
+    // tokenizer. All the preconfigured ../parsers/* expose ast.tokens
+    // automatically, but custom parsers might need additional configuration
+    // to avoid this fallback.
+    var tokens = Array.isArray(ast.tokens)
+        ? ast.tokens
+        : require("esprima").tokenize(sourceWithoutTabs, {
+            loc: true,
+        });
+    // We will reattach the tokens array to the file object below.
+    delete ast.tokens;
+    // Make sure every token has a token.value string.
+    tokens.forEach(function (token) {
+        if (typeof token.value !== "string") {
+            token.value = lines.sliceString(token.loc.start, token.loc.end);
+        }
+    });
+    if (Array.isArray(ast.comments)) {
+        comments = ast.comments;
+        delete ast.comments;
+    }
+    if (ast.loc) {
+        // If the source was empty, some parsers give loc.{start,end}.line
+        // values of 0, instead of the minimum of 1.
+        util.fixFaultyLocations(ast, lines);
+    }
+    else {
+        ast.loc = {
+            start: lines.firstPos(),
+            end: lines.lastPos(),
+        };
+    }
+    ast.loc.lines = lines;
+    ast.loc.indent = 0;
+    var file;
+    var program;
+    if (ast.type === "Program") {
+        program = ast;
+        // In order to ensure we reprint leading and trailing program
+        // comments, wrap the original Program node with a File node. Only
+        // ESTree parsers (Acorn and Esprima) return a Program as the root AST
+        // node. Most other (Babylon-like) parsers return a File.
+        file = b.file(ast, options.sourceFileName || null);
+        file.loc = {
+            start: lines.firstPos(),
+            end: lines.lastPos(),
+            lines: lines,
+            indent: 0,
+        };
+    }
+    else if (ast.type === "File") {
+        file = ast;
+        program = file.program;
+    }
+    // Expose file.tokens unless the caller passed false for options.tokens.
+    if (options.tokens) {
+        file.tokens = tokens;
+    }
+    // Expand the Program's .loc to include all comments (not just those
+    // attached to the Program node, as its children may have comments as
+    // well), since sometimes program.loc.{start,end} will coincide with the
+    // .loc.{start,end} of the first and last *statements*, mistakenly
+    // excluding comments that fall outside that region.
+    var trueProgramLoc = util.getTrueLoc({
+        type: program.type,
+        loc: program.loc,
+        body: [],
+        comments: comments,
+    }, lines);
+    program.loc.start = trueProgramLoc.start;
+    program.loc.end = trueProgramLoc.end;
+    // Passing file.program here instead of just file means that initial
+    // comments will be attached to program.body[0] instead of program.
+    comments_1.attach(comments, program.body.length ? file.program : file, lines);
+    // Return a copy of the original AST so that any changes made may be
+    // compared to the original.
+    return new TreeCopier(lines, tokens).copy(file);
+}
+exports.parse = parse;
+var TreeCopier = function TreeCopier(lines, tokens) {
+    assert_1.default.ok(this instanceof TreeCopier);
+    this.lines = lines;
+    this.tokens = tokens;
+    this.startTokenIndex = 0;
+    this.endTokenIndex = tokens.length;
+    this.indent = 0;
+    this.seen = new Map();
+};
+var TCp = TreeCopier.prototype;
+TCp.copy = function (node) {
+    if (this.seen.has(node)) {
+        return this.seen.get(node);
+    }
+    if (isArray.check(node)) {
+        var copy_1 = new Array(node.length);
+        this.seen.set(node, copy_1);
+        node.forEach(function (item, i) {
+            copy_1[i] = this.copy(item);
+        }, this);
+        return copy_1;
+    }
+    if (!isObject.check(node)) {
+        return node;
+    }
+    util.fixFaultyLocations(node, this.lines);
+    var copy = Object.create(Object.getPrototypeOf(node), {
+        original: {
+            // Provide a link from the copy to the original.
+            value: node,
+            configurable: false,
+            enumerable: false,
+            writable: true,
+        },
+    });
+    this.seen.set(node, copy);
+    var loc = node.loc;
+    var oldIndent = this.indent;
+    var newIndent = oldIndent;
+    var oldStartTokenIndex = this.startTokenIndex;
+    var oldEndTokenIndex = this.endTokenIndex;
+    if (loc) {
+        // When node is a comment, we set node.loc.indent to
+        // node.loc.start.column so that, when/if we print the comment by
+        // itself, we can strip that much whitespace from the left margin of
+        // the comment. This only really matters for multiline Block comments,
+        // but it doesn't hurt for Line comments.
+        if (node.type === "Block" ||
+            node.type === "Line" ||
+            node.type === "CommentBlock" ||
+            node.type === "CommentLine" ||
+            this.lines.isPrecededOnlyByWhitespace(loc.start)) {
+            newIndent = this.indent = loc.start.column;
+        }
+        // Every node.loc has a reference to the original source lines as well
+        // as a complete list of source tokens.
+        loc.lines = this.lines;
+        loc.tokens = this.tokens;
+        loc.indent = newIndent;
+        // Set loc.start.token and loc.end.token such that
+        // loc.tokens.slice(loc.start.token, loc.end.token) returns a list of
+        // all the tokens that make up this node.
+        this.findTokenRange(loc);
+    }
+    var keys = Object.keys(node);
+    var keyCount = keys.length;
+    for (var i = 0; i < keyCount; ++i) {
+        var key = keys[i];
+        if (key === "loc") {
+            copy[key] = node[key];
+        }
+        else if (key === "tokens" && node.type === "File") {
+            // Preserve file.tokens (uncopied) in case client code cares about
+            // it, even though Recast ignores it when reprinting.
+            copy[key] = node[key];
+        }
+        else {
+            copy[key] = this.copy(node[key]);
+        }
+    }
+    this.indent = oldIndent;
+    this.startTokenIndex = oldStartTokenIndex;
+    this.endTokenIndex = oldEndTokenIndex;
+    return copy;
+};
+// If we didn't have any idea where in loc.tokens to look for tokens
+// contained by this loc, a binary search would be appropriate, but
+// because we maintain this.startTokenIndex and this.endTokenIndex as we
+// traverse the AST, we only need to make small (linear) adjustments to
+// those indexes with each recursive iteration.
+TCp.findTokenRange = function (loc) {
+    // In the unlikely event that loc.tokens[this.startTokenIndex] starts
+    // *after* loc.start, we need to rewind this.startTokenIndex first.
+    while (this.startTokenIndex > 0) {
+        var token = loc.tokens[this.startTokenIndex];
+        if (util.comparePos(loc.start, token.loc.start) < 0) {
+            --this.startTokenIndex;
+        }
+        else
+            break;
+    }
+    // In the unlikely event that loc.tokens[this.endTokenIndex - 1] ends
+    // *before* loc.end, we need to fast-forward this.endTokenIndex first.
+    while (this.endTokenIndex < loc.tokens.length) {
+        var token = loc.tokens[this.endTokenIndex];
+        if (util.comparePos(token.loc.end, loc.end) < 0) {
+            ++this.endTokenIndex;
+        }
+        else
+            break;
+    }
+    // Increment this.startTokenIndex until we've found the first token
+    // contained by this node.
+    while (this.startTokenIndex < this.endTokenIndex) {
+        var token = loc.tokens[this.startTokenIndex];
+        if (util.comparePos(token.loc.start, loc.start) < 0) {
+            ++this.startTokenIndex;
+        }
+        else
+            break;
+    }
+    // Index into loc.tokens of the first token within this node.
+    loc.start.token = this.startTokenIndex;
+    // Decrement this.endTokenIndex until we've found the first token after
+    // this node (not contained by the node).
+    while (this.endTokenIndex > this.startTokenIndex) {
+        var token = loc.tokens[this.endTokenIndex - 1];
+        if (util.comparePos(loc.end, token.loc.end) < 0) {
+            --this.endTokenIndex;
+        }
+        else
+            break;
+    }
+    // Index into loc.tokens of the first token *after* this node.
+    // If loc.start.token === loc.end.token, the node contains no tokens,
+    // and the index is that of the next token following this node.
+    loc.end.token = this.endTokenIndex;
+};

node_modules/recast/lib/patcher.d.ts

@@ -0,0 +1,12 @@
+interface PatcherType {
+    replace(loc: any, lines: any): any;
+    get(loc?: any): any;
+    tryToReprintComments(newNode: any, oldNode: any, print: any): any;
+    deleteComments(node: any): any;
+}
+interface PatcherConstructor {
+    new (lines: any): PatcherType;
+}
+declare const Patcher: PatcherConstructor;
+export { Patcher };
+export declare function getReprinter(path: any): ((print: any) => any) | undefined;

node_modules/recast/lib/patcher.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReprinter = exports.Patcher = void 0;
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+var linesModule = tslib_1.__importStar(require("./lines"));
+var types = tslib_1.__importStar(require("ast-types"));
+var Printable = types.namedTypes.Printable;
+var Expression = types.namedTypes.Expression;
+var ReturnStatement = types.namedTypes.ReturnStatement;
+var SourceLocation = types.namedTypes.SourceLocation;
+var util_1 = require("./util");
+var fast_path_1 = tslib_1.__importDefault(require("./fast-path"));
+var isObject = types.builtInTypes.object;
+var isArray = types.builtInTypes.array;
+var isString = types.builtInTypes.string;
+var riskyAdjoiningCharExp = /[0-9a-z_$]/i;
+var Patcher = function Patcher(lines) {
+    assert_1.default.ok(this instanceof Patcher);
+    assert_1.default.ok(lines instanceof linesModule.Lines);
+    var self = this, replacements = [];
+    self.replace = function (loc, lines) {
+        if (isString.check(lines))
+            lines = linesModule.fromString(lines);
+        replacements.push({
+            lines: lines,
+            start: loc.start,
+            end: loc.end,
+        });
+    };
+    self.get = function (loc) {
+        // If no location is provided, return the complete Lines object.
+        loc = loc || {
+            start: { line: 1, column: 0 },
+            end: { line: lines.length, column: lines.getLineLength(lines.length) },
+        };
+        var sliceFrom = loc.start, toConcat = [];
+        function pushSlice(from, to) {
+            assert_1.default.ok(util_1.comparePos(from, to) <= 0);
+            toConcat.push(lines.slice(from, to));
+        }
+        replacements
+            .sort(function (a, b) { return util_1.comparePos(a.start, b.start); })
+            .forEach(function (rep) {
+            if (util_1.comparePos(sliceFrom, rep.start) > 0) {
+                // Ignore nested replacement ranges.
+            }
+            else {
+                pushSlice(sliceFrom, rep.start);
+                toConcat.push(rep.lines);
+                sliceFrom = rep.end;
+            }
+        });
+        pushSlice(sliceFrom, loc.end);
+        return linesModule.concat(toConcat);
+    };
+};
+exports.Patcher = Patcher;
+var Pp = Patcher.prototype;
+Pp.tryToReprintComments = function (newNode, oldNode, print) {
+    var patcher = this;
+    if (!newNode.comments && !oldNode.comments) {
+        // We were (vacuously) able to reprint all the comments!
+        return true;
+    }
+    var newPath = fast_path_1.default.from(newNode);
+    var oldPath = fast_path_1.default.from(oldNode);
+    newPath.stack.push("comments", getSurroundingComments(newNode));
+    oldPath.stack.push("comments", getSurroundingComments(oldNode));
+    var reprints = [];
+    var ableToReprintComments = findArrayReprints(newPath, oldPath, reprints);
+    // No need to pop anything from newPath.stack or oldPath.stack, since
+    // newPath and oldPath are fresh local variables.
+    if (ableToReprintComments && reprints.length > 0) {
+        reprints.forEach(function (reprint) {
+            var oldComment = reprint.oldPath.getValue();
+            assert_1.default.ok(oldComment.leading || oldComment.trailing);
+            patcher.replace(oldComment.loc, 
+            // Comments can't have .comments, so it doesn't matter whether we
+            // print with comments or without.
+            print(reprint.newPath).indentTail(oldComment.loc.indent));
+        });
+    }
+    return ableToReprintComments;
+};
+// Get all comments that are either leading or trailing, ignoring any
+// comments that occur inside node.loc. Returns an empty array for nodes
+// with no leading or trailing comments.
+function getSurroundingComments(node) {
+    var result = [];
+    if (node.comments && node.comments.length > 0) {
+        node.comments.forEach(function (comment) {
+            if (comment.leading || comment.trailing) {
+                result.push(comment);
+            }
+        });
+    }
+    return result;
+}
+Pp.deleteComments = function (node) {
+    if (!node.comments) {
+        return;
+    }
+    var patcher = this;
+    node.comments.forEach(function (comment) {
+        if (comment.leading) {
+            // Delete leading comments along with any trailing whitespace they
+            // might have.
+            patcher.replace({
+                start: comment.loc.start,
+                end: node.loc.lines.skipSpaces(comment.loc.end, false, false),
+            }, "");
+        }
+        else if (comment.trailing) {
+            // Delete trailing comments along with any leading whitespace they
+            // might have.
+            patcher.replace({
+                start: node.loc.lines.skipSpaces(comment.loc.start, true, false),
+                end: comment.loc.end,
+            }, "");
+        }
+    });
+};
+function getReprinter(path) {
+    assert_1.default.ok(path instanceof fast_path_1.default);
+    // Make sure that this path refers specifically to a Node, rather than
+    // some non-Node subproperty of a Node.
+    var node = path.getValue();
+    if (!Printable.check(node))
+        return;
+    var orig = node.original;
+    var origLoc = orig && orig.loc;
+    var lines = origLoc && origLoc.lines;
+    var reprints = [];
+    if (!lines || !findReprints(path, reprints))
+        return;
+    return function (print) {
+        var patcher = new Patcher(lines);
+        reprints.forEach(function (reprint) {
+            var newNode = reprint.newPath.getValue();
+            var oldNode = reprint.oldPath.getValue();
+            SourceLocation.assert(oldNode.loc, true);
+            var needToPrintNewPathWithComments = !patcher.tryToReprintComments(newNode, oldNode, print);
+            if (needToPrintNewPathWithComments) {
+                // Since we were not able to preserve all leading/trailing
+                // comments, we delete oldNode's comments, print newPath with
+                // comments, and then patch the resulting lines where oldNode used
+                // to be.
+                patcher.deleteComments(oldNode);
+            }
+            var newLines = print(reprint.newPath, {
+                includeComments: needToPrintNewPathWithComments,
+                // If the oldNode we're replacing already had parentheses, we may
+                // not need to print the new node with any extra parentheses,
+                // because the existing parentheses will suffice. However, if the
+                // newNode has a different type than the oldNode, let the printer
+                // decide if reprint.newPath needs parentheses, as usual.
+                avoidRootParens: oldNode.type === newNode.type && reprint.oldPath.hasParens(),
+            }).indentTail(oldNode.loc.indent);
+            var nls = needsLeadingSpace(lines, oldNode.loc, newLines);
+            var nts = needsTrailingSpace(lines, oldNode.loc, newLines);
+            // If we try to replace the argument of a ReturnStatement like
+            // return"asdf" with e.g. a literal null expression, we run the risk
+            // of ending up with returnnull, so we need to add an extra leading
+            // space in situations where that might happen. Likewise for
+            // "asdf"in obj. See #170.
+            if (nls || nts) {
+                var newParts = [];
+                nls && newParts.push(" ");
+                newParts.push(newLines);
+                nts && newParts.push(" ");
+                newLines = linesModule.concat(newParts);
+            }
+            patcher.replace(oldNode.loc, newLines);
+        });
+        // Recall that origLoc is the .loc of an ancestor node that is
+        // guaranteed to contain all the reprinted nodes and comments.
+        var patchedLines = patcher.get(origLoc).indentTail(-orig.loc.indent);
+        if (path.needsParens()) {
+            return linesModule.concat(["(", patchedLines, ")"]);
+        }
+        return patchedLines;
+    };
+}
+exports.getReprinter = getReprinter;
+// If the last character before oldLoc and the first character of newLines
+// are both identifier characters, they must be separated by a space,
+// otherwise they will most likely get fused together into a single token.
+function needsLeadingSpace(oldLines, oldLoc, newLines) {
+    var posBeforeOldLoc = util_1.copyPos(oldLoc.start);
+    // The character just before the location occupied by oldNode.
+    var charBeforeOldLoc = oldLines.prevPos(posBeforeOldLoc) && oldLines.charAt(posBeforeOldLoc);
+    // First character of the reprinted node.
+    var newFirstChar = newLines.charAt(newLines.firstPos());
+    return (charBeforeOldLoc &&
+        riskyAdjoiningCharExp.test(charBeforeOldLoc) &&
+        newFirstChar &&
+        riskyAdjoiningCharExp.test(newFirstChar));
+}
+// If the last character of newLines and the first character after oldLoc
+// are both identifier characters, they must be separated by a space,
+// otherwise they will most likely get fused together into a single token.
+function needsTrailingSpace(oldLines, oldLoc, newLines) {
+    // The character just after the location occupied by oldNode.
+    var charAfterOldLoc = oldLines.charAt(oldLoc.end);
+    var newLastPos = newLines.lastPos();
+    // Last character of the reprinted node.
+    var newLastChar = newLines.prevPos(newLastPos) && newLines.charAt(newLastPos);
+    return (newLastChar &&
+        riskyAdjoiningCharExp.test(newLastChar) &&
+        charAfterOldLoc &&
+        riskyAdjoiningCharExp.test(charAfterOldLoc));
+}
+function findReprints(newPath, reprints) {
+    var newNode = newPath.getValue();
+    Printable.assert(newNode);
+    var oldNode = newNode.original;
+    Printable.assert(oldNode);
+    assert_1.default.deepEqual(reprints, []);
+    if (newNode.type !== oldNode.type) {
+        return false;
+    }
+    var oldPath = new fast_path_1.default(oldNode);
+    var canReprint = findChildReprints(newPath, oldPath, reprints);
+    if (!canReprint) {
+        // Make absolutely sure the calling code does not attempt to reprint
+        // any nodes.
+        reprints.length = 0;
+    }
+    return canReprint;
+}
+function findAnyReprints(newPath, oldPath, reprints) {
+    var newNode = newPath.getValue();
+    var oldNode = oldPath.getValue();
+    if (newNode === oldNode)
+        return true;
+    if (isArray.check(newNode))
+        return findArrayReprints(newPath, oldPath, reprints);
+    if (isObject.check(newNode))
+        return findObjectReprints(newPath, oldPath, reprints);
+    return false;
+}
+function findArrayReprints(newPath, oldPath, reprints) {
+    var newNode = newPath.getValue();
+    var oldNode = oldPath.getValue();
+    if (newNode === oldNode ||
+        newPath.valueIsDuplicate() ||
+        oldPath.valueIsDuplicate()) {
+        return true;
+    }
+    isArray.assert(newNode);
+    var len = newNode.length;
+    if (!(isArray.check(oldNode) && oldNode.length === len))
+        return false;
+    for (var i = 0; i < len; ++i) {
+        newPath.stack.push(i, newNode[i]);
+        oldPath.stack.push(i, oldNode[i]);
+        var canReprint = findAnyReprints(newPath, oldPath, reprints);
+        newPath.stack.length -= 2;
+        oldPath.stack.length -= 2;
+        if (!canReprint) {
+            return false;
+        }
+    }
+    return true;
+}
+function findObjectReprints(newPath, oldPath, reprints) {
+    var newNode = newPath.getValue();
+    isObject.assert(newNode);
+    if (newNode.original === null) {
+        // If newNode.original node was set to null, reprint the node.
+        return false;
+    }
+    var oldNode = oldPath.getValue();
+    if (!isObject.check(oldNode))
+        return false;
+    if (newNode === oldNode ||
+        newPath.valueIsDuplicate() ||
+        oldPath.valueIsDuplicate()) {
+        return true;
+    }
+    if (Printable.check(newNode)) {
+        if (!Printable.check(oldNode)) {
+            return false;
+        }
+        var newParentNode = newPath.getParentNode();
+        var oldParentNode = oldPath.getParentNode();
+        if (oldParentNode !== null &&
+            oldParentNode.type === "FunctionTypeAnnotation" &&
+            newParentNode !== null &&
+            newParentNode.type === "FunctionTypeAnnotation") {
+            var oldNeedsParens = oldParentNode.params.length !== 1 || !!oldParentNode.params[0].name;
+            var newNeedParens = newParentNode.params.length !== 1 || !!newParentNode.params[0].name;
+            if (!oldNeedsParens && newNeedParens) {
+                return false;
+            }
+        }
+        // Here we need to decide whether the reprinted code for newNode is
+        // appropriate for patching into the location of oldNode.
+        if (newNode.type === oldNode.type) {
+            var childReprints = [];
+            if (findChildReprints(newPath, oldPath, childReprints)) {
+                reprints.push.apply(reprints, childReprints);
+            }
+            else if (oldNode.loc) {
+                // If we have no .loc information for oldNode, then we won't be
+                // able to reprint it.
+                reprints.push({
+                    oldPath: oldPath.copy(),
+                    newPath: newPath.copy(),
+                });
+            }
+            else {
+                return false;
+            }
+            return true;
+        }
+        if (Expression.check(newNode) &&
+            Expression.check(oldNode) &&
+            // If we have no .loc information for oldNode, then we won't be
+            // able to reprint it.
+            oldNode.loc) {
+            // If both nodes are subtypes of Expression, then we should be able
+            // to fill the location occupied by the old node with code printed
+            // for the new node with no ill consequences.
+            reprints.push({
+                oldPath: oldPath.copy(),
+                newPath: newPath.copy(),
+            });
+            return true;
+        }
+        // The nodes have different types, and at least one of the types is
+        // not a subtype of the Expression type, so we cannot safely assume
+        // the nodes are syntactically interchangeable.
+        return false;
+    }
+    return findChildReprints(newPath, oldPath, reprints);
+}
+function findChildReprints(newPath, oldPath, reprints) {
+    var newNode = newPath.getValue();
+    var oldNode = oldPath.getValue();
+    isObject.assert(newNode);
+    isObject.assert(oldNode);
+    if (newNode.original === null) {
+        // If newNode.original node was set to null, reprint the node.
+        return false;
+    }
+    // If this node needs parentheses and will not be wrapped with
+    // parentheses when reprinted, then return false to skip reprinting and
+    // let it be printed generically.
+    if (newPath.needsParens() && !oldPath.hasParens()) {
+        return false;
+    }
+    var keys = util_1.getUnionOfKeys(oldNode, newNode);
+    if (oldNode.type === "File" || newNode.type === "File") {
+        // Don't bother traversing file.tokens, an often very large array
+        // returned by Babylon, and useless for our purposes.
+        delete keys.tokens;
+    }
+    // Don't bother traversing .loc objects looking for reprintable nodes.
+    delete keys.loc;
+    var originalReprintCount = reprints.length;
+    for (var k in keys) {
+        if (k.charAt(0) === "_") {
+            // Ignore "private" AST properties added by e.g. Babel plugins and
+            // parsers like Babylon.
+            continue;
+        }
+        newPath.stack.push(k, types.getFieldValue(newNode, k));
+        oldPath.stack.push(k, types.getFieldValue(oldNode, k));
+        var canReprint = findAnyReprints(newPath, oldPath, reprints);
+        newPath.stack.length -= 2;
+        oldPath.stack.length -= 2;
+        if (!canReprint) {
+            return false;
+        }
+    }
+    // Return statements might end up running into ASI issues due to
+    // comments inserted deep within the tree, so reprint them if anything
+    // changed within them.
+    if (ReturnStatement.check(newPath.getNode()) &&
+        reprints.length > originalReprintCount) {
+        return false;
+    }
+    return true;
+}

node_modules/recast/lib/printer.d.ts

@@ -0,0 +1,14 @@
+export interface PrintResultType {
+    code: string;
+    map?: any;
+    toString(): string;
+}
+interface PrinterType {
+    print(ast: any): PrintResultType;
+    printGenerically(ast: any): PrintResultType;
+}
+interface PrinterConstructor {
+    new (config?: any): PrinterType;
+}
+declare const Printer: PrinterConstructor;
+export { Printer };

node_modules/recast/lib/util.d.ts

@@ -0,0 +1,18 @@
+export declare function getLineTerminator(): any;
+export declare function isBrowser(): boolean;
+export declare function getOption(options: any, key: any, defaultValue: any): any;
+export declare function getUnionOfKeys(...args: any[]): any;
+export declare function comparePos(pos1: any, pos2: any): number;
+export declare function copyPos(pos: any): {
+    line: any;
+    column: any;
+};
+export declare function composeSourceMaps(formerMap: any, latterMap: any): any;
+export declare function getTrueLoc(node: any, lines: any): {
+    start: any;
+    end: any;
+} | null;
+export declare function fixFaultyLocations(node: any, lines: any): void;
+export declare function isExportDeclaration(node: any): boolean;
+export declare function getParentExportDeclaration(path: any): any;
+export declare function isTrailingCommaEnabled(options: any, context: any): boolean;

node_modules/recast/lib/util.js

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTrailingCommaEnabled = exports.getParentExportDeclaration = exports.isExportDeclaration = exports.fixFaultyLocations = exports.getTrueLoc = exports.composeSourceMaps = exports.copyPos = exports.comparePos = exports.getUnionOfKeys = exports.getOption = exports.isBrowser = exports.getLineTerminator = void 0;
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+var types = tslib_1.__importStar(require("ast-types"));
+var n = types.namedTypes;
+var source_map_1 = tslib_1.__importDefault(require("source-map"));
+var SourceMapConsumer = source_map_1.default.SourceMapConsumer;
+var SourceMapGenerator = source_map_1.default.SourceMapGenerator;
+var hasOwn = Object.prototype.hasOwnProperty;
+function getLineTerminator() {
+    return isBrowser() ? "\n" : require("os").EOL || "\n";
+}
+exports.getLineTerminator = getLineTerminator;
+function isBrowser() {
+    return (typeof window !== "undefined" && typeof window.document !== "undefined");
+}
+exports.isBrowser = isBrowser;
+function getOption(options, key, defaultValue) {
+    if (options && hasOwn.call(options, key)) {
+        return options[key];
+    }
+    return defaultValue;
+}
+exports.getOption = getOption;
+function getUnionOfKeys() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var result = {};
+    var argc = args.length;
+    for (var i = 0; i < argc; ++i) {
+        var keys = Object.keys(args[i]);
+        var keyCount = keys.length;
+        for (var j = 0; j < keyCount; ++j) {
+            result[keys[j]] = true;
+        }
+    }
+    return result;
+}
+exports.getUnionOfKeys = getUnionOfKeys;
+function comparePos(pos1, pos2) {
+    return pos1.line - pos2.line || pos1.column - pos2.column;
+}
+exports.comparePos = comparePos;
+function copyPos(pos) {
+    return {
+        line: pos.line,
+        column: pos.column,
+    };
+}
+exports.copyPos = copyPos;
+function composeSourceMaps(formerMap, latterMap) {
+    if (formerMap) {
+        if (!latterMap) {
+            return formerMap;
+        }
+    }
+    else {
+        return latterMap || null;
+    }
+    var smcFormer = new SourceMapConsumer(formerMap);
+    var smcLatter = new SourceMapConsumer(latterMap);
+    var smg = new SourceMapGenerator({
+        file: latterMap.file,
+        sourceRoot: latterMap.sourceRoot,
+    });
+    var sourcesToContents = {};
+    smcLatter.eachMapping(function (mapping) {
+        var origPos = smcFormer.originalPositionFor({
+            line: mapping.originalLine,
+            column: mapping.originalColumn,
+        });
+        var sourceName = origPos.source;
+        if (sourceName === null) {
+            return;
+        }
+        smg.addMapping({
+            source: sourceName,
+            original: copyPos(origPos),
+            generated: {
+                line: mapping.generatedLine,
+                column: mapping.generatedColumn,
+            },
+            name: mapping.name,
+        });
+        var sourceContent = smcFormer.sourceContentFor(sourceName);
+        if (sourceContent && !hasOwn.call(sourcesToContents, sourceName)) {
+            sourcesToContents[sourceName] = sourceContent;
+            smg.setSourceContent(sourceName, sourceContent);
+        }
+    });
+    return smg.toJSON();
+}
+exports.composeSourceMaps = composeSourceMaps;
+function getTrueLoc(node, lines) {
+    // It's possible that node is newly-created (not parsed by Esprima),
+    // in which case it probably won't have a .loc property (or an
+    // .original property for that matter). That's fine; we'll just
+    // pretty-print it as usual.
+    if (!node.loc) {
+        return null;
+    }
+    var result = {
+        start: node.loc.start,
+        end: node.loc.end,
+    };
+    function include(node) {
+        expandLoc(result, node.loc);
+    }
+    // If the node is an export declaration and its .declaration has any
+    // decorators, their locations might contribute to the true start/end
+    // positions of the export declaration node.
+    if (node.declaration &&
+        node.declaration.decorators &&
+        isExportDeclaration(node)) {
+        node.declaration.decorators.forEach(include);
+    }
+    if (comparePos(result.start, result.end) < 0) {
+        // Trim leading whitespace.
+        result.start = copyPos(result.start);
+        lines.skipSpaces(result.start, false, true);
+        if (comparePos(result.start, result.end) < 0) {
+            // Trim trailing whitespace, if the end location is not already the
+            // same as the start location.
+            result.end = copyPos(result.end);
+            lines.skipSpaces(result.end, true, true);
+        }
+    }
+    // If the node has any comments, their locations might contribute to
+    // the true start/end positions of the node.
+    if (node.comments) {
+        node.comments.forEach(include);
+    }
+    return result;
+}
+exports.getTrueLoc = getTrueLoc;
+function expandLoc(parentLoc, childLoc) {
+    if (parentLoc && childLoc) {
+        if (comparePos(childLoc.start, parentLoc.start) < 0) {
+            parentLoc.start = childLoc.start;
+        }
+        if (comparePos(parentLoc.end, childLoc.end) < 0) {
+            parentLoc.end = childLoc.end;
+        }
+    }
+}
+function fixFaultyLocations(node, lines) {
+    var loc = node.loc;
+    if (loc) {
+        if (loc.start.line < 1) {
+            loc.start.line = 1;
+        }
+        if (loc.end.line < 1) {
+            loc.end.line = 1;
+        }
+    }
+    if (node.type === "File") {
+        // Babylon returns File nodes whose .loc.{start,end} do not include
+        // leading or trailing whitespace.
+        loc.start = lines.firstPos();
+        loc.end = lines.lastPos();
+    }
+    fixForLoopHead(node, lines);
+    fixTemplateLiteral(node, lines);
+    if (loc && node.decorators) {
+        // Expand the .loc of the node responsible for printing the decorators
+        // (here, the decorated node) so that it includes node.decorators.
+        node.decorators.forEach(function (decorator) {
+            expandLoc(loc, decorator.loc);
+        });
+    }
+    else if (node.declaration && isExportDeclaration(node)) {
+        // Nullify .loc information for the child declaration so that we never
+        // try to reprint it without also reprinting the export declaration.
+        node.declaration.loc = null;
+        // Expand the .loc of the node responsible for printing the decorators
+        // (here, the export declaration) so that it includes node.decorators.
+        var decorators = node.declaration.decorators;
+        if (decorators) {
+            decorators.forEach(function (decorator) {
+                expandLoc(loc, decorator.loc);
+            });
+        }
+    }
+    else if ((n.MethodDefinition && n.MethodDefinition.check(node)) ||
+        (n.Property.check(node) && (node.method || node.shorthand))) {
+        // If the node is a MethodDefinition or a .method or .shorthand
+        // Property, then the location information stored in
+        // node.value.loc is very likely untrustworthy (just the {body}
+        // part of a method, or nothing in the case of shorthand
+        // properties), so we null out that information to prevent
+        // accidental reuse of bogus source code during reprinting.
+        node.value.loc = null;
+        if (n.FunctionExpression.check(node.value)) {
+            // FunctionExpression method values should be anonymous,
+            // because their .id fields are ignored anyway.
+            node.value.id = null;
+        }
+    }
+    else if (node.type === "ObjectTypeProperty") {
+        var loc_1 = node.loc;
+        var end = loc_1 && loc_1.end;
+        if (end) {
+            end = copyPos(end);
+            if (lines.prevPos(end) && lines.charAt(end) === ",") {
+                // Some parsers accidentally include trailing commas in the
+                // .loc.end information for ObjectTypeProperty nodes.
+                if ((end = lines.skipSpaces(end, true, true))) {
+                    loc_1.end = end;
+                }
+            }
+        }
+    }
+}
+exports.fixFaultyLocations = fixFaultyLocations;
+function fixForLoopHead(node, lines) {
+    if (node.type !== "ForStatement") {
+        return;
+    }
+    function fix(child) {
+        var loc = child && child.loc;
+        var start = loc && loc.start;
+        var end = loc && copyPos(loc.end);
+        while (start && end && comparePos(start, end) < 0) {
+            lines.prevPos(end);
+            if (lines.charAt(end) === ";") {
+                // Update child.loc.end to *exclude* the ';' character.
+                loc.end.line = end.line;
+                loc.end.column = end.column;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    fix(node.init);
+    fix(node.test);
+    fix(node.update);
+}
+function fixTemplateLiteral(node, lines) {
+    if (node.type !== "TemplateLiteral") {
+        return;
+    }
+    if (node.quasis.length === 0) {
+        // If there are no quasi elements, then there is nothing to fix.
+        return;
+    }
+    // node.loc is not present when using export default with a template literal
+    if (node.loc) {
+        // First we need to exclude the opening ` from the .loc of the first
+        // quasi element, in case the parser accidentally decided to include it.
+        var afterLeftBackTickPos = copyPos(node.loc.start);
+        assert_1.default.strictEqual(lines.charAt(afterLeftBackTickPos), "`");
+        assert_1.default.ok(lines.nextPos(afterLeftBackTickPos));
+        var firstQuasi = node.quasis[0];
+        if (comparePos(firstQuasi.loc.start, afterLeftBackTickPos) < 0) {
+            firstQuasi.loc.start = afterLeftBackTickPos;
+        }
+        // Next we need to exclude the closing ` from the .loc of the last quasi
+        // element, in case the parser accidentally decided to include it.
+        var rightBackTickPos = copyPos(node.loc.end);
+        assert_1.default.ok(lines.prevPos(rightBackTickPos));
+        assert_1.default.strictEqual(lines.charAt(rightBackTickPos), "`");
+        var lastQuasi = node.quasis[node.quasis.length - 1];
+        if (comparePos(rightBackTickPos, lastQuasi.loc.end) < 0) {
+            lastQuasi.loc.end = rightBackTickPos;
+        }
+    }
+    // Now we need to exclude ${ and } characters from the .loc's of all
+    // quasi elements, since some parsers accidentally include them.
+    node.expressions.forEach(function (expr, i) {
+        // Rewind from expr.loc.start over any whitespace and the ${ that
+        // precedes the expression. The position of the $ should be the same
+        // as the .loc.end of the preceding quasi element, but some parsers
+        // accidentally include the ${ in the .loc of the quasi element.
+        var dollarCurlyPos = lines.skipSpaces(expr.loc.start, true, false);
+        if (lines.prevPos(dollarCurlyPos) &&
+            lines.charAt(dollarCurlyPos) === "{" &&
+            lines.prevPos(dollarCurlyPos) &&
+            lines.charAt(dollarCurlyPos) === "$") {
+            var quasiBefore = node.quasis[i];
+            if (comparePos(dollarCurlyPos, quasiBefore.loc.end) < 0) {
+                quasiBefore.loc.end = dollarCurlyPos;
+            }
+        }
+        // Likewise, some parsers accidentally include the } that follows
+        // the expression in the .loc of the following quasi element.
+        var rightCurlyPos = lines.skipSpaces(expr.loc.end, false, false);
+        if (lines.charAt(rightCurlyPos) === "}") {
+            assert_1.default.ok(lines.nextPos(rightCurlyPos));
+            // Now rightCurlyPos is technically the position just after the }.
+            var quasiAfter = node.quasis[i + 1];
+            if (comparePos(quasiAfter.loc.start, rightCurlyPos) < 0) {
+                quasiAfter.loc.start = rightCurlyPos;
+            }
+        }
+    });
+}
+function isExportDeclaration(node) {
+    if (node)
+        switch (node.type) {
+            case "ExportDeclaration":
+            case "ExportDefaultDeclaration":
+            case "ExportDefaultSpecifier":
+            case "DeclareExportDeclaration":
+            case "ExportNamedDeclaration":
+            case "ExportAllDeclaration":
+                return true;
+        }
+    return false;
+}
+exports.isExportDeclaration = isExportDeclaration;
+function getParentExportDeclaration(path) {
+    var parentNode = path.getParentNode();
+    if (path.getName() === "declaration" && isExportDeclaration(parentNode)) {
+        return parentNode;
+    }
+    return null;
+}
+exports.getParentExportDeclaration = getParentExportDeclaration;
+function isTrailingCommaEnabled(options, context) {
+    var trailingComma = options.trailingComma;
+    if (typeof trailingComma === "object") {
+        return !!trailingComma[context];
+    }
+    return !!trailingComma;
+}
+exports.isTrailingCommaEnabled = isTrailingCommaEnabled;

node_modules/recast/main.d.ts

@@ -0,0 +1,50 @@
+import * as types from "ast-types";
+import { parse } from "./lib/parser";
+import { Options } from "./lib/options";
+export { 
+/**
+ * Parse a string of code into an augmented syntax tree suitable for
+ * arbitrary modification and reprinting.
+ */
+parse, 
+/**
+ * Convenient shorthand for the ast-types package.
+ */
+types, };
+/**
+ * Traverse and potentially modify an abstract syntax tree using a
+ * convenient visitor syntax:
+ *
+ *   recast.visit(ast, {
+ *     names: [],
+ *     visitIdentifier: function(path) {
+ *       var node = path.value;
+ *       this.visitor.names.push(node.name);
+ *       this.traverse(path);
+ *     }
+ *   });
+ */
+export { visit } from "ast-types";
+/**
+ * Options shared between parsing and printing.
+ */
+export { Options } from "./lib/options";
+/**
+ * Reprint a modified syntax tree using as much of the original source
+ * code as possible.
+ */
+export declare function print(node: types.ASTNode, options?: Options): import("./lib/printer").PrintResultType;
+/**
+ * Print without attempting to reuse any original source code.
+ */
+export declare function prettyPrint(node: types.ASTNode, options?: Options): import("./lib/printer").PrintResultType;
+/**
+ * Convenient command-line interface (see e.g. example/add-braces).
+ */
+export declare function run(transformer: Transformer, options?: RunOptions): void;
+export interface Transformer {
+    (ast: types.ASTNode, callback: (ast: types.ASTNode) => void): void;
+}
+export interface RunOptions extends Options {
+    writeback?(code: string): void;
+}

node_modules/recast/main.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = exports.prettyPrint = exports.print = exports.visit = exports.types = exports.parse = void 0;
+var tslib_1 = require("tslib");
+var fs_1 = tslib_1.__importDefault(require("fs"));
+var types = tslib_1.__importStar(require("ast-types"));
+exports.types = types;
+var parser_1 = require("./lib/parser");
+Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parser_1.parse; } });
+var printer_1 = require("./lib/printer");
+/**
+ * Traverse and potentially modify an abstract syntax tree using a
+ * convenient visitor syntax:
+ *
+ *   recast.visit(ast, {
+ *     names: [],
+ *     visitIdentifier: function(path) {
+ *       var node = path.value;
+ *       this.visitor.names.push(node.name);
+ *       this.traverse(path);
+ *     }
+ *   });
+ */
+var ast_types_1 = require("ast-types");
+Object.defineProperty(exports, "visit", { enumerable: true, get: function () { return ast_types_1.visit; } });
+/**
+ * Reprint a modified syntax tree using as much of the original source
+ * code as possible.
+ */
+function print(node, options) {
+    return new printer_1.Printer(options).print(node);
+}
+exports.print = print;
+/**
+ * Print without attempting to reuse any original source code.
+ */
+function prettyPrint(node, options) {
+    return new printer_1.Printer(options).printGenerically(node);
+}
+exports.prettyPrint = prettyPrint;
+/**
+ * Convenient command-line interface (see e.g. example/add-braces).
+ */
+function run(transformer, options) {
+    return runFile(process.argv[2], transformer, options);
+}
+exports.run = run;
+function runFile(path, transformer, options) {
+    fs_1.default.readFile(path, "utf-8", function (err, code) {
+        if (err) {
+            console.error(err);
+            return;
+        }
+        runString(code, transformer, options);
+    });
+}
+function defaultWriteback(output) {
+    process.stdout.write(output);
+}
+function runString(code, transformer, options) {
+    var writeback = (options && options.writeback) || defaultWriteback;
+    transformer(parser_1.parse(code, options), function (node) {
+        writeback(print(node, options).code);
+    });
+}

node_modules/recast/node_modules/ast-types/.github/dependabot.yml

@@ -0,0 +1,9 @@
+# Please see the documentation for all configuration options:
+# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "daily"

node_modules/recast/node_modules/ast-types/.github/workflows/main.yml

@@ -0,0 +1,29 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+    name: Test on node ${{ matrix.node_version }} and ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        node_version: ['10', '12', '14', '15', '16', '17']
+        os: [ubuntu-latest]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node_version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node_version }}
+
+    - name: npm install, build and test
+      run: |
+        npm install
+        npm run build --if-present
+        npm test

node_modules/recast/node_modules/ast-types/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Ben Newman <bn@cs.stanford.edu>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/recast/node_modules/ast-types/README.md

@@ -0,0 +1,512 @@
+# AST Types ![CI](https://github.com/benjamn/ast-types/workflows/CI/badge.svg)
+
+This module provides an efficient, modular,
+[Esprima](https://github.com/ariya/esprima)-compatible implementation of
+the [abstract syntax
+tree](http://en.wikipedia.org/wiki/Abstract_syntax_tree) type hierarchy
+pioneered by the [Mozilla Parser
+API](https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API).
+
+Installation
+---
+
+From NPM:
+
+    npm install ast-types
+
+From GitHub:
+
+    cd path/to/node_modules
+    git clone git://github.com/benjamn/ast-types.git
+    cd ast-types
+    npm install .
+
+Basic Usage
+---
+```js
+import assert from "assert";
+import {
+  namedTypes as n,
+  builders as b,
+} from "ast-types";
+
+var fooId = b.identifier("foo");
+var ifFoo = b.ifStatement(fooId, b.blockStatement([
+  b.expressionStatement(b.callExpression(fooId, []))
+]));
+
+assert.ok(n.IfStatement.check(ifFoo));
+assert.ok(n.Statement.check(ifFoo));
+assert.ok(n.Node.check(ifFoo));
+
+assert.ok(n.BlockStatement.check(ifFoo.consequent));
+assert.strictEqual(
+  ifFoo.consequent.body[0].expression.arguments.length,
+  0,
+);
+
+assert.strictEqual(ifFoo.test, fooId);
+assert.ok(n.Expression.check(ifFoo.test));
+assert.ok(n.Identifier.check(ifFoo.test));
+assert.ok(!n.Statement.check(ifFoo.test));
+```
+
+AST Traversal
+---
+
+Because it understands the AST type system so thoroughly, this library
+is able to provide excellent node iteration and traversal mechanisms.
+
+If you want complete control over the traversal, and all you need is a way
+of enumerating the known fields of your AST nodes and getting their
+values, you may be interested in the primitives `getFieldNames` and
+`getFieldValue`:
+```js
+import {
+  getFieldNames,
+  getFieldValue,
+} from "ast-types";
+
+const partialFunExpr = { type: "FunctionExpression" };
+
+// Even though partialFunExpr doesn't actually contain all the fields that
+// are expected for a FunctionExpression, types.getFieldNames knows:
+console.log(getFieldNames(partialFunExpr));
+// [ 'type', 'id', 'params', 'body', 'generator', 'expression',
+//   'defaults', 'rest', 'async' ]
+
+// For fields that have default values, types.getFieldValue will return
+// the default if the field is not actually defined.
+console.log(getFieldValue(partialFunExpr, "generator"));
+// false
+```
+
+Two more low-level helper functions, `eachField` and `someField`, are
+defined in terms of `getFieldNames` and `getFieldValue`:
+```js
+// Iterate over all defined fields of an object, including those missing
+// or undefined, passing each field name and effective value (as returned
+// by getFieldValue) to the callback. If the object has no corresponding
+// Def, the callback will never be called.
+export function eachField(object, callback, context) {
+  getFieldNames(object).forEach(function(name) {
+    callback.call(this, name, getFieldValue(object, name));
+  }, context);
+}
+
+// Similar to eachField, except that iteration stops as soon as the
+// callback returns a truthy value. Like Array.prototype.some, the final
+// result is either true or false to indicates whether the callback
+// returned true for any element or not.
+export function someField(object, callback, context) {
+  return getFieldNames(object).some(function(name) {
+    return callback.call(this, name, getFieldValue(object, name));
+  }, context);
+}
+```
+
+So here's how you might make a copy of an AST node:
+```js
+import { eachField } from "ast-types";
+const copy = {};
+eachField(node, function(name, value) {
+  // Note that undefined fields will be visited too, according to
+  // the rules associated with node.type, and default field values
+  // will be substituted if appropriate.
+  copy[name] = value;
+})
+```
+
+But that's not all! You can also easily visit entire syntax trees using
+the powerful `types.visit` abstraction.
+
+Here's a trivial example of how you might assert that `arguments.callee`
+is never used in `ast`:
+```js
+import assert from "assert";
+import {
+  visit,
+  namedTypes as n,
+} from "ast-types";
+
+visit(ast, {
+  // This method will be called for any node with .type "MemberExpression":
+  visitMemberExpression(path) {
+    // Visitor methods receive a single argument, a NodePath object
+    // wrapping the node of interest.
+    var node = path.node;
+
+    if (
+      n.Identifier.check(node.object) &&
+      node.object.name === "arguments" &&
+      n.Identifier.check(node.property)
+    ) {
+      assert.notStrictEqual(node.property.name, "callee");
+    }
+
+    // It's your responsibility to call this.traverse with some
+    // NodePath object (usually the one passed into the visitor
+    // method) before the visitor method returns, or return false to
+    // indicate that the traversal need not continue any further down
+    // this subtree.
+    this.traverse(path);
+  }
+});
+```
+
+Here's a slightly more involved example of transforming `...rest`
+parameters into browser-runnable ES5 JavaScript:
+
+```js
+import { builders as b, visit } from "ast-types";
+
+// Reuse the same AST structure for Array.prototype.slice.call.
+var sliceExpr = b.memberExpression(
+  b.memberExpression(
+    b.memberExpression(
+      b.identifier("Array"),
+      b.identifier("prototype"),
+      false
+    ),
+    b.identifier("slice"),
+    false
+  ),
+  b.identifier("call"),
+  false
+);
+
+visit(ast, {
+  // This method will be called for any node whose type is a subtype of
+  // Function (e.g., FunctionDeclaration, FunctionExpression, and
+  // ArrowFunctionExpression). Note that types.visit precomputes a
+  // lookup table from every known type to the appropriate visitor
+  // method to call for nodes of that type, so the dispatch takes
+  // constant time.
+  visitFunction(path) {
+    // Visitor methods receive a single argument, a NodePath object
+    // wrapping the node of interest.
+    const node = path.node;
+
+    // It's your responsibility to call this.traverse with some
+    // NodePath object (usually the one passed into the visitor
+    // method) before the visitor method returns, or return false to
+    // indicate that the traversal need not continue any further down
+    // this subtree. An assertion will fail if you forget, which is
+    // awesome, because it means you will never again make the
+    // disastrous mistake of forgetting to traverse a subtree. Also
+    // cool: because you can call this method at any point in the
+    // visitor method, it's up to you whether your traversal is
+    // pre-order, post-order, or both!
+    this.traverse(path);
+
+    // This traversal is only concerned with Function nodes that have
+    // rest parameters.
+    if (!node.rest) {
+      return;
+    }
+
+    // For the purposes of this example, we won't worry about functions
+    // with Expression bodies.
+    n.BlockStatement.assert(node.body);
+
+    // Use types.builders to build a variable declaration of the form
+    //
+    //   var rest = Array.prototype.slice.call(arguments, n);
+    //
+    // where `rest` is the name of the rest parameter, and `n` is a
+    // numeric literal specifying the number of named parameters the
+    // function takes.
+    const restVarDecl = b.variableDeclaration("var", [
+      b.variableDeclarator(
+        node.rest,
+        b.callExpression(sliceExpr, [
+          b.identifier("arguments"),
+          b.literal(node.params.length)
+        ])
+      )
+    ]);
+
+    // Similar to doing node.body.body.unshift(restVarDecl), except
+    // that the other NodePath objects wrapping body statements will
+    // have their indexes updated to accommodate the new statement.
+    path.get("body", "body").unshift(restVarDecl);
+
+    // Nullify node.rest now that we have simulated the behavior of
+    // the rest parameter using ordinary JavaScript.
+    path.get("rest").replace(null);
+
+    // There's nothing wrong with doing node.rest = null, but I wanted
+    // to point out that the above statement has the same effect.
+    assert.strictEqual(node.rest, null);
+  }
+});
+```
+
+Here's how you might use `types.visit` to implement a function that
+determines if a given function node refers to `this`:
+
+```js
+function usesThis(funcNode) {
+  n.Function.assert(funcNode);
+  var result = false;
+
+  visit(funcNode, {
+    visitThisExpression(path) {
+      result = true;
+
+      // The quickest way to terminate the traversal is to call
+      // this.abort(), which throws a special exception (instanceof
+      // this.AbortRequest) that will be caught in the top-level
+      // types.visit method, so you don't have to worry about
+      // catching the exception yourself.
+      this.abort();
+    },
+
+    visitFunction(path) {
+      // ThisExpression nodes in nested scopes don't count as `this`
+      // references for the original function node, so we can safely
+      // avoid traversing this subtree.
+      return false;
+    },
+
+    visitCallExpression(path) {
+      const node = path.node;
+
+      // If the function contains CallExpression nodes involving
+      // super, those expressions will implicitly depend on the
+      // value of `this`, even though they do not explicitly contain
+      // any ThisExpression nodes.
+      if (this.isSuperCallExpression(node)) {
+        result = true;
+        this.abort(); // Throws AbortRequest exception.
+      }
+
+      this.traverse(path);
+    },
+
+    // Yes, you can define arbitrary helper methods.
+    isSuperCallExpression(callExpr) {
+      n.CallExpression.assert(callExpr);
+      return this.isSuperIdentifier(callExpr.callee)
+          || this.isSuperMemberExpression(callExpr.callee);
+    },
+
+    // And even helper helper methods!
+    isSuperIdentifier(node) {
+      return n.Identifier.check(node.callee)
+          && node.callee.name === "super";
+    },
+
+    isSuperMemberExpression(node) {
+      return n.MemberExpression.check(node.callee)
+          && n.Identifier.check(node.callee.object)
+          && node.callee.object.name === "super";
+    }
+  });
+
+  return result;
+}
+```
+
+As you might guess, when an `AbortRequest` is thrown from a subtree, the
+exception will propagate from the corresponding calls to `this.traverse`
+in the ancestor visitor methods. If you decide you want to cancel the
+request, simply catch the exception and call its `.cancel()` method. The
+rest of the subtree beneath the `try`-`catch` block will be abandoned, but
+the remaining siblings of the ancestor node will still be visited.
+
+NodePath
+---
+
+The `NodePath` object passed to visitor methods is a wrapper around an AST
+node, and it serves to provide access to the chain of ancestor objects
+(all the way back to the root of the AST) and scope information.
+
+In general, `path.node` refers to the wrapped node, `path.parent.node`
+refers to the nearest `Node` ancestor, `path.parent.parent.node` to the
+grandparent, and so on.
+
+Note that `path.node` may not be a direct property value of
+`path.parent.node`; for instance, it might be the case that `path.node` is
+an element of an array that is a direct child of the parent node:
+```js
+path.node === path.parent.node.elements[3]
+```
+in which case you should know that `path.parentPath` provides
+finer-grained access to the complete path of objects (not just the `Node`
+ones) from the root of the AST:
+```js
+// In reality, path.parent is the grandparent of path:
+path.parentPath.parentPath === path.parent
+
+// The path.parentPath object wraps the elements array (note that we use
+// .value because the elements array is not a Node):
+path.parentPath.value === path.parent.node.elements
+
+// The path.node object is the fourth element in that array:
+path.parentPath.value[3] === path.node
+
+// Unlike path.node and path.value, which are synonyms because path.node
+// is a Node object, path.parentPath.node is distinct from
+// path.parentPath.value, because the elements array is not a
+// Node. Instead, path.parentPath.node refers to the closest ancestor
+// Node, which happens to be the same as path.parent.node:
+path.parentPath.node === path.parent.node
+
+// The path is named for its index in the elements array:
+path.name === 3
+
+// Likewise, path.parentPath is named for the property by which
+// path.parent.node refers to it:
+path.parentPath.name === "elements"
+
+// Putting it all together, we can follow the chain of object references
+// from path.parent.node all the way to path.node by accessing each
+// property by name:
+path.parent.node[path.parentPath.name][path.name] === path.node
+```
+
+These `NodePath` objects are created during the traversal without
+modifying the AST nodes themselves, so it's not a problem if the same node
+appears more than once in the AST (like `Array.prototype.slice.call` in
+the example above), because it will be visited with a distict `NodePath`
+each time it appears.
+
+Child `NodePath` objects are created lazily, by calling the `.get` method
+of a parent `NodePath` object:
+```js
+// If a NodePath object for the elements array has never been created
+// before, it will be created here and cached in the future:
+path.get("elements").get(3).value === path.value.elements[3]
+
+// Alternatively, you can pass multiple property names to .get instead of
+// chaining multiple .get calls:
+path.get("elements", 0).value === path.value.elements[0]
+```
+
+`NodePath` objects support a number of useful methods:
+```js
+// Replace one node with another node:
+var fifth = path.get("elements", 4);
+fifth.replace(newNode);
+
+// Now do some stuff that might rearrange the list, and this replacement
+// remains safe:
+fifth.replace(newerNode);
+
+// Replace the third element in an array with two new nodes:
+path.get("elements", 2).replace(
+  b.identifier("foo"),
+  b.thisExpression()
+);
+
+// Remove a node and its parent if it would leave a redundant AST node:
+//e.g. var t = 1, y =2; removing the `t` and `y` declarators results in `var undefined`.
+path.prune(); //returns the closest parent `NodePath`.
+
+// Remove a node from a list of nodes:
+path.get("elements", 3).replace();
+
+// Add three new nodes to the beginning of a list of nodes:
+path.get("elements").unshift(a, b, c);
+
+// Remove and return the first node in a list of nodes:
+path.get("elements").shift();
+
+// Push two new nodes onto the end of a list of nodes:
+path.get("elements").push(d, e);
+
+// Remove and return the last node in a list of nodes:
+path.get("elements").pop();
+
+// Insert a new node before/after the seventh node in a list of nodes:
+var seventh = path.get("elements", 6);
+seventh.insertBefore(newNode);
+seventh.insertAfter(newNode);
+
+// Insert a new element at index 5 in a list of nodes:
+path.get("elements").insertAt(5, newNode);
+```
+
+Scope
+---
+
+The object exposed as `path.scope` during AST traversals provides
+information about variable and function declarations in the scope that
+contains `path.node`. See [scope.ts](lib/scope.ts) for its public
+interface, which currently includes `.isGlobal`, `.getGlobalScope()`,
+`.depth`, `.declares(name)`, `.lookup(name)`, and `.getBindings()`.
+
+Custom AST Node Types
+---
+
+The `ast-types` module was designed to be extended. To that end, it
+provides a readable, declarative syntax for specifying new AST node types,
+based primarily upon the `require("ast-types").Type.def` function:
+```js
+import {
+  Type,
+  builtInTypes,
+  builders as b,
+  finalize,
+} from "ast-types";
+
+const { def } = Type;
+const { string } = builtInTypes;
+
+// Suppose you need a named File type to wrap your Programs.
+def("File")
+  .bases("Node")
+  .build("name", "program")
+  .field("name", string)
+  .field("program", def("Program"));
+
+// Prevent further modifications to the File type (and any other
+// types newly introduced by def(...)).
+finalize();
+
+// The b.file builder function is now available. It expects two
+// arguments, as named by .build("name", "program") above.
+const main = b.file("main.js", b.program([
+  // Pointless program contents included for extra color.
+  b.functionDeclaration(b.identifier("succ"), [
+    b.identifier("x")
+  ], b.blockStatement([
+    b.returnStatement(
+      b.binaryExpression(
+        "+", b.identifier("x"), b.literal(1)
+      )
+    )
+  ]))
+]));
+
+assert.strictEqual(main.name, "main.js");
+assert.strictEqual(main.program.body[0].params[0].name, "x");
+// etc.
+
+// If you pass the wrong type of arguments, or fail to pass enough
+// arguments, an AssertionError will be thrown.
+
+b.file(b.blockStatement([]));
+// ==> AssertionError: {"body":[],"type":"BlockStatement","loc":null} does not match type string
+
+b.file("lib/types.js", b.thisExpression());
+// ==> AssertionError: {"type":"ThisExpression","loc":null} does not match type Program
+```
+
+The `def` syntax is used to define all the default AST node types found in
+[babel-core.ts](def/babel-core.ts),
+[babel.ts](def/babel.ts),
+[core.ts](def/core.ts),
+[es-proposals.ts](def/es-proposals.ts),
+[es6.ts](def/es6.ts),
+[es7.ts](def/es7.ts),
+[es2020.ts](def/es2020.ts),
+[esprima.ts](def/esprima.ts),
+[flow.ts](def/flow.ts),
+[jsx.ts](def/jsx.ts),
+[type-annotations.ts](def/type-annotations.ts),
+and
+[typescript.ts](def/typescript.ts),
+so you have
+no shortage of examples to learn from.

node_modules/recast/node_modules/ast-types/def/babel-core.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/babel-core.js

@@ -0,0 +1,222 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var es_proposals_1 = (0, tslib_1.__importDefault)(require("./es-proposals"));
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
+function default_1(fork) {
+    var _a, _b, _c, _d, _e;
+    fork.use(es_proposals_1.default);
+    var types = fork.use(types_1.default);
+    var defaults = fork.use(shared_1.default).defaults;
+    var def = types.Type.def;
+    var or = types.Type.or;
+    var isUndefined = types.builtInTypes.undefined;
+    def("Noop")
+        .bases("Statement")
+        .build();
+    def("DoExpression")
+        .bases("Expression")
+        .build("body")
+        .field("body", [def("Statement")]);
+    def("BindExpression")
+        .bases("Expression")
+        .build("object", "callee")
+        .field("object", or(def("Expression"), null))
+        .field("callee", def("Expression"));
+    def("ParenthesizedExpression")
+        .bases("Expression")
+        .build("expression")
+        .field("expression", def("Expression"));
+    def("ExportNamespaceSpecifier")
+        .bases("Specifier")
+        .build("exported")
+        .field("exported", def("Identifier"));
+    def("ExportDefaultSpecifier")
+        .bases("Specifier")
+        .build("exported")
+        .field("exported", def("Identifier"));
+    def("CommentBlock")
+        .bases("Comment")
+        .build("value", /*optional:*/ "leading", "trailing");
+    def("CommentLine")
+        .bases("Comment")
+        .build("value", /*optional:*/ "leading", "trailing");
+    def("Directive")
+        .bases("Node")
+        .build("value")
+        .field("value", def("DirectiveLiteral"));
+    def("DirectiveLiteral")
+        .bases("Node", "Expression")
+        .build("value")
+        .field("value", String, defaults["use strict"]);
+    def("InterpreterDirective")
+        .bases("Node")
+        .build("value")
+        .field("value", String);
+    def("BlockStatement")
+        .bases("Statement")
+        .build("body")
+        .field("body", [def("Statement")])
+        .field("directives", [def("Directive")], defaults.emptyArray);
+    def("Program")
+        .bases("Node")
+        .build("body")
+        .field("body", [def("Statement")])
+        .field("directives", [def("Directive")], defaults.emptyArray)
+        .field("interpreter", or(def("InterpreterDirective"), null), defaults["null"]);
+    function makeLiteralExtra(rawValueType, toRaw) {
+        if (rawValueType === void 0) { rawValueType = String; }
+        return [
+            "extra",
+            {
+                rawValue: rawValueType,
+                raw: String,
+            },
+            function getDefault() {
+                var value = types.getFieldValue(this, "value");
+                return {
+                    rawValue: value,
+                    raw: toRaw ? toRaw(value) : String(value),
+                };
+            },
+        ];
+    }
+    // Split Literal
+    (_a = def("StringLiteral")
+        .bases("Literal")
+        .build("value")
+        .field("value", String))
+        .field.apply(_a, makeLiteralExtra(String, function (val) { return JSON.stringify(val); }));
+    (_b = def("NumericLiteral")
+        .bases("Literal")
+        .build("value")
+        .field("value", Number)
+        .field("raw", or(String, null), defaults["null"]))
+        .field.apply(_b, makeLiteralExtra(Number));
+    (_c = def("BigIntLiteral")
+        .bases("Literal")
+        .build("value")
+        // Only String really seems appropriate here, since BigInt values
+        // often exceed the limits of JS numbers.
+        .field("value", or(String, Number)))
+        .field.apply(_c, makeLiteralExtra(String, function (val) { return val + "n"; }));
+    // https://github.com/tc39/proposal-decimal
+    // https://github.com/babel/babel/pull/11640
+    (_d = def("DecimalLiteral")
+        .bases("Literal")
+        .build("value")
+        .field("value", String))
+        .field.apply(_d, makeLiteralExtra(String, function (val) { return val + "m"; }));
+    def("NullLiteral")
+        .bases("Literal")
+        .build()
+        .field("value", null, defaults["null"]);
+    def("BooleanLiteral")
+        .bases("Literal")
+        .build("value")
+        .field("value", Boolean);
+    (_e = def("RegExpLiteral")
+        .bases("Literal")
+        .build("pattern", "flags")
+        .field("pattern", String)
+        .field("flags", String)
+        .field("value", RegExp, function () {
+        return new RegExp(this.pattern, this.flags);
+    }))
+        .field.apply(_e, makeLiteralExtra(or(RegExp, isUndefined), function (exp) { return "/".concat(exp.pattern, "/").concat(exp.flags || ""); })).field("regex", {
+        pattern: String,
+        flags: String
+    }, function () {
+        return {
+            pattern: this.pattern,
+            flags: this.flags,
+        };
+    });
+    var ObjectExpressionProperty = or(def("Property"), def("ObjectMethod"), def("ObjectProperty"), def("SpreadProperty"), def("SpreadElement"));
+    // Split Property -> ObjectProperty and ObjectMethod
+    def("ObjectExpression")
+        .bases("Expression")
+        .build("properties")
+        .field("properties", [ObjectExpressionProperty]);
+    // ObjectMethod hoist .value properties to own properties
+    def("ObjectMethod")
+        .bases("Node", "Function")
+        .build("kind", "key", "params", "body", "computed")
+        .field("kind", or("method", "get", "set"))
+        .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+        .field("params", [def("Pattern")])
+        .field("body", def("BlockStatement"))
+        .field("computed", Boolean, defaults["false"])
+        .field("generator", Boolean, defaults["false"])
+        .field("async", Boolean, defaults["false"])
+        .field("accessibility", // TypeScript
+    or(def("Literal"), null), defaults["null"])
+        .field("decorators", or([def("Decorator")], null), defaults["null"]);
+    def("ObjectProperty")
+        .bases("Node")
+        .build("key", "value")
+        .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+        .field("value", or(def("Expression"), def("Pattern")))
+        .field("accessibility", // TypeScript
+    or(def("Literal"), null), defaults["null"])
+        .field("computed", Boolean, defaults["false"]);
+    var ClassBodyElement = or(def("MethodDefinition"), def("VariableDeclarator"), def("ClassPropertyDefinition"), def("ClassProperty"), def("ClassPrivateProperty"), def("ClassMethod"), def("ClassPrivateMethod"));
+    // MethodDefinition -> ClassMethod
+    def("ClassBody")
+        .bases("Declaration")
+        .build("body")
+        .field("body", [ClassBodyElement]);
+    def("ClassMethod")
+        .bases("Declaration", "Function")
+        .build("kind", "key", "params", "body", "computed", "static")
+        .field("key", or(def("Literal"), def("Identifier"), def("Expression")));
+    def("ClassPrivateMethod")
+        .bases("Declaration", "Function")
+        .build("key", "params", "body", "kind", "computed", "static")
+        .field("key", def("PrivateName"));
+    ["ClassMethod",
+        "ClassPrivateMethod",
+    ].forEach(function (typeName) {
+        def(typeName)
+            .field("kind", or("get", "set", "method", "constructor"), function () { return "method"; })
+            .field("body", def("BlockStatement"))
+            .field("computed", Boolean, defaults["false"])
+            .field("static", or(Boolean, null), defaults["null"])
+            .field("abstract", or(Boolean, null), defaults["null"])
+            .field("access", or("public", "private", "protected", null), defaults["null"])
+            .field("accessibility", or("public", "private", "protected", null), defaults["null"])
+            .field("decorators", or([def("Decorator")], null), defaults["null"])
+            .field("optional", or(Boolean, null), defaults["null"]);
+    });
+    var ObjectPatternProperty = or(def("Property"), def("PropertyPattern"), def("SpreadPropertyPattern"), def("SpreadProperty"), // Used by Esprima
+    def("ObjectProperty"), // Babel 6
+    def("RestProperty") // Babel 6
+    );
+    // Split into RestProperty and SpreadProperty
+    def("ObjectPattern")
+        .bases("Pattern")
+        .build("properties")
+        .field("properties", [ObjectPatternProperty])
+        .field("decorators", or([def("Decorator")], null), defaults["null"]);
+    def("SpreadProperty")
+        .bases("Node")
+        .build("argument")
+        .field("argument", def("Expression"));
+    def("RestProperty")
+        .bases("Node")
+        .build("argument")
+        .field("argument", def("Expression"));
+    def("ForAwaitStatement")
+        .bases("Statement")
+        .build("left", "right", "body")
+        .field("left", or(def("VariableDeclaration"), def("Expression")))
+        .field("right", def("Expression"))
+        .field("body", def("Statement"));
+    // The callee node of a dynamic import(...) expression.
+    def("Import")
+        .bases("Expression")
+        .build();
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/babel.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/babel.js

@@ -0,0 +1,24 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var babel_core_1 = (0, tslib_1.__importDefault)(require("./babel-core"));
+var flow_1 = (0, tslib_1.__importDefault)(require("./flow"));
+function default_1(fork) {
+    var types = fork.use(types_1.default);
+    var def = types.Type.def;
+    fork.use(babel_core_1.default);
+    fork.use(flow_1.default);
+    // https://github.com/babel/babel/pull/10148
+    def("V8IntrinsicIdentifier")
+        .bases("Expression")
+        .build("name")
+        .field("name", String);
+    // https://github.com/babel/babel/pull/13191
+    // https://github.com/babel/website/pull/2541
+    def("TopicReference")
+        .bases("Expression")
+        .build();
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/core.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/core.js

@@ -0,0 +1,279 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var core_1 = (0, tslib_1.__importDefault)(require("./operators/core"));
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
+function default_1(fork) {
+    var types = fork.use(types_1.default);
+    var Type = types.Type;
+    var def = Type.def;
+    var or = Type.or;
+    var shared = fork.use(shared_1.default);
+    var defaults = shared.defaults;
+    var geq = shared.geq;
+    var _a = fork.use(core_1.default), BinaryOperators = _a.BinaryOperators, AssignmentOperators = _a.AssignmentOperators, LogicalOperators = _a.LogicalOperators;
+    // Abstract supertype of all syntactic entities that are allowed to have a
+    // .loc field.
+    def("Printable")
+        .field("loc", or(def("SourceLocation"), null), defaults["null"], true);
+    def("Node")
+        .bases("Printable")
+        .field("type", String)
+        .field("comments", or([def("Comment")], null), defaults["null"], true);
+    def("SourceLocation")
+        .field("start", def("Position"))
+        .field("end", def("Position"))
+        .field("source", or(String, null), defaults["null"]);
+    def("Position")
+        .field("line", geq(1))
+        .field("column", geq(0));
+    def("File")
+        .bases("Node")
+        .build("program", "name")
+        .field("program", def("Program"))
+        .field("name", or(String, null), defaults["null"]);
+    def("Program")
+        .bases("Node")
+        .build("body")
+        .field("body", [def("Statement")]);
+    def("Function")
+        .bases("Node")
+        .field("id", or(def("Identifier"), null), defaults["null"])
+        .field("params", [def("Pattern")])
+        .field("body", def("BlockStatement"))
+        .field("generator", Boolean, defaults["false"])
+        .field("async", Boolean, defaults["false"]);
+    def("Statement").bases("Node");
+    // The empty .build() here means that an EmptyStatement can be constructed
+    // (i.e. it's not abstract) but that it needs no arguments.
+    def("EmptyStatement").bases("Statement").build();
+    def("BlockStatement")
+        .bases("Statement")
+        .build("body")
+        .field("body", [def("Statement")]);
+    // TODO Figure out how to silently coerce Expressions to
+    // ExpressionStatements where a Statement was expected.
+    def("ExpressionStatement")
+        .bases("Statement")
+        .build("expression")
+        .field("expression", def("Expression"));
+    def("IfStatement")
+        .bases("Statement")
+        .build("test", "consequent", "alternate")
+        .field("test", def("Expression"))
+        .field("consequent", def("Statement"))
+        .field("alternate", or(def("Statement"), null), defaults["null"]);
+    def("LabeledStatement")
+        .bases("Statement")
+        .build("label", "body")
+        .field("label", def("Identifier"))
+        .field("body", def("Statement"));
+    def("BreakStatement")
+        .bases("Statement")
+        .build("label")
+        .field("label", or(def("Identifier"), null), defaults["null"]);
+    def("ContinueStatement")
+        .bases("Statement")
+        .build("label")
+        .field("label", or(def("Identifier"), null), defaults["null"]);
+    def("WithStatement")
+        .bases("Statement")
+        .build("object", "body")
+        .field("object", def("Expression"))
+        .field("body", def("Statement"));
+    def("SwitchStatement")
+        .bases("Statement")
+        .build("discriminant", "cases", "lexical")
+        .field("discriminant", def("Expression"))
+        .field("cases", [def("SwitchCase")])
+        .field("lexical", Boolean, defaults["false"]);
+    def("ReturnStatement")
+        .bases("Statement")
+        .build("argument")
+        .field("argument", or(def("Expression"), null));
+    def("ThrowStatement")
+        .bases("Statement")
+        .build("argument")
+        .field("argument", def("Expression"));
+    def("TryStatement")
+        .bases("Statement")
+        .build("block", "handler", "finalizer")
+        .field("block", def("BlockStatement"))
+        .field("handler", or(def("CatchClause"), null), function () {
+        return this.handlers && this.handlers[0] || null;
+    })
+        .field("handlers", [def("CatchClause")], function () {
+        return this.handler ? [this.handler] : [];
+    }, true) // Indicates this field is hidden from eachField iteration.
+        .field("guardedHandlers", [def("CatchClause")], defaults.emptyArray)
+        .field("finalizer", or(def("BlockStatement"), null), defaults["null"]);
+    def("CatchClause")
+        .bases("Node")
+        .build("param", "guard", "body")
+        .field("param", def("Pattern"))
+        .field("guard", or(def("Expression"), null), defaults["null"])
+        .field("body", def("BlockStatement"));
+    def("WhileStatement")
+        .bases("Statement")
+        .build("test", "body")
+        .field("test", def("Expression"))
+        .field("body", def("Statement"));
+    def("DoWhileStatement")
+        .bases("Statement")
+        .build("body", "test")
+        .field("body", def("Statement"))
+        .field("test", def("Expression"));
+    def("ForStatement")
+        .bases("Statement")
+        .build("init", "test", "update", "body")
+        .field("init", or(def("VariableDeclaration"), def("Expression"), null))
+        .field("test", or(def("Expression"), null))
+        .field("update", or(def("Expression"), null))
+        .field("body", def("Statement"));
+    def("ForInStatement")
+        .bases("Statement")
+        .build("left", "right", "body")
+        .field("left", or(def("VariableDeclaration"), def("Expression")))
+        .field("right", def("Expression"))
+        .field("body", def("Statement"));
+    def("DebuggerStatement").bases("Statement").build();
+    def("Declaration").bases("Statement");
+    def("FunctionDeclaration")
+        .bases("Function", "Declaration")
+        .build("id", "params", "body")
+        .field("id", def("Identifier"));
+    def("FunctionExpression")
+        .bases("Function", "Expression")
+        .build("id", "params", "body");
+    def("VariableDeclaration")
+        .bases("Declaration")
+        .build("kind", "declarations")
+        .field("kind", or("var", "let", "const"))
+        .field("declarations", [def("VariableDeclarator")]);
+    def("VariableDeclarator")
+        .bases("Node")
+        .build("id", "init")
+        .field("id", def("Pattern"))
+        .field("init", or(def("Expression"), null), defaults["null"]);
+    def("Expression").bases("Node");
+    def("ThisExpression").bases("Expression").build();
+    def("ArrayExpression")
+        .bases("Expression")
+        .build("elements")
+        .field("elements", [or(def("Expression"), null)]);
+    def("ObjectExpression")
+        .bases("Expression")
+        .build("properties")
+        .field("properties", [def("Property")]);
+    // TODO Not in the Mozilla Parser API, but used by Esprima.
+    def("Property")
+        .bases("Node") // Want to be able to visit Property Nodes.
+        .build("kind", "key", "value")
+        .field("kind", or("init", "get", "set"))
+        .field("key", or(def("Literal"), def("Identifier")))
+        .field("value", def("Expression"));
+    def("SequenceExpression")
+        .bases("Expression")
+        .build("expressions")
+        .field("expressions", [def("Expression")]);
+    var UnaryOperator = or("-", "+", "!", "~", "typeof", "void", "delete");
+    def("UnaryExpression")
+        .bases("Expression")
+        .build("operator", "argument", "prefix")
+        .field("operator", UnaryOperator)
+        .field("argument", def("Expression"))
+        // Esprima doesn't bother with this field, presumably because it's
+        // always true for unary operators.
+        .field("prefix", Boolean, defaults["true"]);
+    var BinaryOperator = or.apply(void 0, BinaryOperators);
+    def("BinaryExpression")
+        .bases("Expression")
+        .build("operator", "left", "right")
+        .field("operator", BinaryOperator)
+        .field("left", def("Expression"))
+        .field("right", def("Expression"));
+    var AssignmentOperator = or.apply(void 0, AssignmentOperators);
+    def("AssignmentExpression")
+        .bases("Expression")
+        .build("operator", "left", "right")
+        .field("operator", AssignmentOperator)
+        .field("left", or(def("Pattern"), def("MemberExpression")))
+        .field("right", def("Expression"));
+    var UpdateOperator = or("++", "--");
+    def("UpdateExpression")
+        .bases("Expression")
+        .build("operator", "argument", "prefix")
+        .field("operator", UpdateOperator)
+        .field("argument", def("Expression"))
+        .field("prefix", Boolean);
+    var LogicalOperator = or.apply(void 0, LogicalOperators);
+    def("LogicalExpression")
+        .bases("Expression")
+        .build("operator", "left", "right")
+        .field("operator", LogicalOperator)
+        .field("left", def("Expression"))
+        .field("right", def("Expression"));
+    def("ConditionalExpression")
+        .bases("Expression")
+        .build("test", "consequent", "alternate")
+        .field("test", def("Expression"))
+        .field("consequent", def("Expression"))
+        .field("alternate", def("Expression"));
+    def("NewExpression")
+        .bases("Expression")
+        .build("callee", "arguments")
+        .field("callee", def("Expression"))
+        // The Mozilla Parser API gives this type as [or(def("Expression"),
+        // null)], but null values don't really make sense at the call site.
+        // TODO Report this nonsense.
+        .field("arguments", [def("Expression")]);
+    def("CallExpression")
+        .bases("Expression")
+        .build("callee", "arguments")
+        .field("callee", def("Expression"))
+        // See comment for NewExpression above.
+        .field("arguments", [def("Expression")]);
+    def("MemberExpression")
+        .bases("Expression")
+        .build("object", "property", "computed")
+        .field("object", def("Expression"))
+        .field("property", or(def("Identifier"), def("Expression")))
+        .field("computed", Boolean, function () {
+        var type = this.property.type;
+        if (type === 'Literal' ||
+            type === 'MemberExpression' ||
+            type === 'BinaryExpression') {
+            return true;
+        }
+        return false;
+    });
+    def("Pattern").bases("Node");
+    def("SwitchCase")
+        .bases("Node")
+        .build("test", "consequent")
+        .field("test", or(def("Expression"), null))
+        .field("consequent", [def("Statement")]);
+    def("Identifier")
+        .bases("Expression", "Pattern")
+        .build("name")
+        .field("name", String)
+        .field("optional", Boolean, defaults["false"]);
+    def("Literal")
+        .bases("Expression")
+        .build("value")
+        .field("value", or(String, Boolean, null, Number, RegExp, BigInt));
+    // Abstract (non-buildable) comment supertype. Not a Node.
+    def("Comment")
+        .bases("Printable")
+        .field("value", String)
+        // A .leading comment comes before the node, whereas a .trailing
+        // comment comes after it. These two fields should not both be true,
+        // but they might both be false when the comment falls inside a node
+        // and the node has no children for the comment to lead or trail,
+        // e.g. { /*dangling*/ }.
+        .field("leading", Boolean, defaults["true"])
+        .field("trailing", Boolean, defaults["false"]);
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/es-proposals.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/es-proposals.js

@@ -0,0 +1,68 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
+var es2022_1 = (0, tslib_1.__importDefault)(require("./es2022"));
+function default_1(fork) {
+    fork.use(es2022_1.default);
+    var types = fork.use(types_1.default);
+    var Type = types.Type;
+    var def = types.Type.def;
+    var or = Type.or;
+    var shared = fork.use(shared_1.default);
+    var defaults = shared.defaults;
+    def("AwaitExpression")
+        .build("argument", "all")
+        .field("argument", or(def("Expression"), null))
+        .field("all", Boolean, defaults["false"]);
+    // Decorators
+    def("Decorator")
+        .bases("Node")
+        .build("expression")
+        .field("expression", def("Expression"));
+    def("Property")
+        .field("decorators", or([def("Decorator")], null), defaults["null"]);
+    def("MethodDefinition")
+        .field("decorators", or([def("Decorator")], null), defaults["null"]);
+    // Private names
+    def("PrivateName")
+        .bases("Expression", "Pattern")
+        .build("id")
+        .field("id", def("Identifier"));
+    def("ClassPrivateProperty")
+        .bases("ClassProperty")
+        .build("key", "value")
+        .field("key", def("PrivateName"))
+        .field("value", or(def("Expression"), null), defaults["null"]);
+    // https://github.com/tc39/proposal-import-assertions
+    def("ImportAttribute")
+        .bases("Node")
+        .build("key", "value")
+        .field("key", or(def("Identifier"), def("Literal")))
+        .field("value", def("Expression"));
+    ["ImportDeclaration",
+        "ExportAllDeclaration",
+        "ExportNamedDeclaration",
+    ].forEach(function (decl) {
+        def(decl).field("assertions", [def("ImportAttribute")], defaults.emptyArray);
+    });
+    // https://github.com/tc39/proposal-record-tuple
+    // https://github.com/babel/babel/pull/10865
+    def("RecordExpression")
+        .bases("Expression")
+        .build("properties")
+        .field("properties", [or(def("ObjectProperty"), def("ObjectMethod"), def("SpreadElement"))]);
+    def("TupleExpression")
+        .bases("Expression")
+        .build("elements")
+        .field("elements", [or(def("Expression"), def("SpreadElement"), null)]);
+    // https://github.com/tc39/proposal-js-module-blocks
+    // https://github.com/babel/babel/pull/12469
+    def("ModuleExpression")
+        .bases("Node")
+        .build("body")
+        .field("body", def("Program"));
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/es2016.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/es2016.js

@@ -0,0 +1,14 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var es2016_1 = (0, tslib_1.__importDefault)(require("./operators/es2016"));
+var es6_1 = (0, tslib_1.__importDefault)(require("./es6"));
+function default_1(fork) {
+    // The es2016OpsDef plugin comes before es6Def so BinaryOperators and
+    // AssignmentOperators will be appropriately augmented before they are first
+    // used in the core definitions for this fork.
+    fork.use(es2016_1.default);
+    fork.use(es6_1.default);
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/es2017.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/es2017.js

@@ -0,0 +1,20 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var es2016_1 = (0, tslib_1.__importDefault)(require("./es2016"));
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
+function default_1(fork) {
+    fork.use(es2016_1.default);
+    var types = fork.use(types_1.default);
+    var def = types.Type.def;
+    var defaults = fork.use(shared_1.default).defaults;
+    def("Function")
+        .field("async", Boolean, defaults["false"]);
+    def("AwaitExpression")
+        .bases("Expression")
+        .build("argument")
+        .field("argument", def("Expression"));
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/es2018.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/es2018.js

@@ -0,0 +1,34 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var es2017_1 = (0, tslib_1.__importDefault)(require("./es2017"));
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
+function default_1(fork) {
+    fork.use(es2017_1.default);
+    var types = fork.use(types_1.default);
+    var def = types.Type.def;
+    var or = types.Type.or;
+    var defaults = fork.use(shared_1.default).defaults;
+    def("ForOfStatement")
+        .field("await", Boolean, defaults["false"]);
+    // Legacy
+    def("SpreadProperty")
+        .bases("Node")
+        .build("argument")
+        .field("argument", def("Expression"));
+    def("ObjectExpression")
+        .field("properties", [or(def("Property"), def("SpreadProperty"), // Legacy
+        def("SpreadElement"))]);
+    def("TemplateElement")
+        .field("value", { "cooked": or(String, null), "raw": String });
+    // Legacy
+    def("SpreadPropertyPattern")
+        .bases("Pattern")
+        .build("argument")
+        .field("argument", def("Pattern"));
+    def("ObjectPattern")
+        .field("properties", [or(def("PropertyPattern"), def("Property"), def("RestElement"), def("SpreadPropertyPattern"))]);
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/es2019.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/es2019.js

@@ -0,0 +1,17 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var es2018_1 = (0, tslib_1.__importDefault)(require("./es2018"));
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
+function default_1(fork) {
+    fork.use(es2018_1.default);
+    var types = fork.use(types_1.default);
+    var def = types.Type.def;
+    var or = types.Type.or;
+    var defaults = fork.use(shared_1.default).defaults;
+    def("CatchClause")
+        .field("param", or(def("Pattern"), null), defaults["null"]);
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/es2020.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/es2020.js

@@ -0,0 +1,49 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var es2020_1 = (0, tslib_1.__importDefault)(require("./operators/es2020"));
+var es2019_1 = (0, tslib_1.__importDefault)(require("./es2019"));
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
+function default_1(fork) {
+    // The es2020OpsDef plugin comes before es2019Def so LogicalOperators will be
+    // appropriately augmented before first used.
+    fork.use(es2020_1.default);
+    fork.use(es2019_1.default);
+    var types = fork.use(types_1.default);
+    var def = types.Type.def;
+    var or = types.Type.or;
+    var shared = fork.use(shared_1.default);
+    var defaults = shared.defaults;
+    def("ImportExpression")
+        .bases("Expression")
+        .build("source")
+        .field("source", def("Expression"));
+    def("ExportAllDeclaration")
+        .build("source", "exported")
+        .field("source", def("Literal"))
+        .field("exported", or(def("Identifier"), null));
+    // Optional chaining
+    def("ChainElement")
+        .bases("Node")
+        .field("optional", Boolean, defaults["false"]);
+    def("CallExpression")
+        .bases("Expression", "ChainElement");
+    def("MemberExpression")
+        .bases("Expression", "ChainElement");
+    def("ChainExpression")
+        .bases("Expression")
+        .build("expression")
+        .field("expression", def("ChainElement"));
+    def("OptionalCallExpression")
+        .bases("CallExpression")
+        .build("callee", "arguments", "optional")
+        .field("optional", Boolean, defaults["true"]);
+    // Deprecated optional chaining type, doesn't work with babelParser@7.11.0 or newer
+    def("OptionalMemberExpression")
+        .bases("MemberExpression")
+        .build("object", "property", "computed", "optional")
+        .field("optional", Boolean, defaults["true"]);
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/es2021.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/es2021.js

@@ -0,0 +1,13 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var es2021_1 = (0, tslib_1.__importDefault)(require("./operators/es2021"));
+var es2020_1 = (0, tslib_1.__importDefault)(require("./es2020"));
+function default_1(fork) {
+    // The es2021OpsDef plugin comes before es2020Def so AssignmentOperators will
+    // be appropriately augmented before first used.
+    fork.use(es2021_1.default);
+    fork.use(es2020_1.default);
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/es2022.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/es2022.js

@@ -0,0 +1,16 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var es2021_1 = (0, tslib_1.__importDefault)(require("./es2021"));
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+function default_1(fork) {
+    fork.use(es2021_1.default);
+    var types = fork.use(types_1.default);
+    var def = types.Type.def;
+    def("StaticBlock")
+        .bases("Declaration")
+        .build("body")
+        .field("body", [def("Statement")]);
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/es6.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/es6.js

@@ -0,0 +1,236 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var core_1 = (0, tslib_1.__importDefault)(require("./core"));
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
+function default_1(fork) {
+    fork.use(core_1.default);
+    var types = fork.use(types_1.default);
+    var def = types.Type.def;
+    var or = types.Type.or;
+    var defaults = fork.use(shared_1.default).defaults;
+    def("Function")
+        .field("generator", Boolean, defaults["false"])
+        .field("expression", Boolean, defaults["false"])
+        .field("defaults", [or(def("Expression"), null)], defaults.emptyArray)
+        // Legacy
+        .field("rest", or(def("Identifier"), null), defaults["null"]);
+    // The ESTree way of representing a ...rest parameter.
+    def("RestElement")
+        .bases("Pattern")
+        .build("argument")
+        .field("argument", def("Pattern"))
+        .field("typeAnnotation", // for Babylon. Flow parser puts it on the identifier
+    or(def("TypeAnnotation"), def("TSTypeAnnotation"), null), defaults["null"]);
+    def("SpreadElementPattern")
+        .bases("Pattern")
+        .build("argument")
+        .field("argument", def("Pattern"));
+    def("FunctionDeclaration")
+        .build("id", "params", "body", "generator", "expression")
+        // May be `null` in the context of `export default function () {}`
+        .field("id", or(def("Identifier"), null));
+    def("FunctionExpression")
+        .build("id", "params", "body", "generator", "expression");
+    def("ArrowFunctionExpression")
+        .bases("Function", "Expression")
+        .build("params", "body", "expression")
+        // The forced null value here is compatible with the overridden
+        // definition of the "id" field in the Function interface.
+        .field("id", null, defaults["null"])
+        // Arrow function bodies are allowed to be expressions.
+        .field("body", or(def("BlockStatement"), def("Expression")))
+        // The current spec forbids arrow generators, so I have taken the
+        // liberty of enforcing that. TODO Report this.
+        .field("generator", false, defaults["false"]);
+    def("ForOfStatement")
+        .bases("Statement")
+        .build("left", "right", "body")
+        .field("left", or(def("VariableDeclaration"), def("Pattern")))
+        .field("right", def("Expression"))
+        .field("body", def("Statement"));
+    def("YieldExpression")
+        .bases("Expression")
+        .build("argument", "delegate")
+        .field("argument", or(def("Expression"), null))
+        .field("delegate", Boolean, defaults["false"]);
+    def("GeneratorExpression")
+        .bases("Expression")
+        .build("body", "blocks", "filter")
+        .field("body", def("Expression"))
+        .field("blocks", [def("ComprehensionBlock")])
+        .field("filter", or(def("Expression"), null));
+    def("ComprehensionExpression")
+        .bases("Expression")
+        .build("body", "blocks", "filter")
+        .field("body", def("Expression"))
+        .field("blocks", [def("ComprehensionBlock")])
+        .field("filter", or(def("Expression"), null));
+    def("ComprehensionBlock")
+        .bases("Node")
+        .build("left", "right", "each")
+        .field("left", def("Pattern"))
+        .field("right", def("Expression"))
+        .field("each", Boolean);
+    def("Property")
+        .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+        .field("value", or(def("Expression"), def("Pattern")))
+        .field("method", Boolean, defaults["false"])
+        .field("shorthand", Boolean, defaults["false"])
+        .field("computed", Boolean, defaults["false"]);
+    def("ObjectProperty")
+        .field("shorthand", Boolean, defaults["false"]);
+    def("PropertyPattern")
+        .bases("Pattern")
+        .build("key", "pattern")
+        .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+        .field("pattern", def("Pattern"))
+        .field("computed", Boolean, defaults["false"]);
+    def("ObjectPattern")
+        .bases("Pattern")
+        .build("properties")
+        .field("properties", [or(def("PropertyPattern"), def("Property"))]);
+    def("ArrayPattern")
+        .bases("Pattern")
+        .build("elements")
+        .field("elements", [or(def("Pattern"), null)]);
+    def("SpreadElement")
+        .bases("Node")
+        .build("argument")
+        .field("argument", def("Expression"));
+    def("ArrayExpression")
+        .field("elements", [or(def("Expression"), def("SpreadElement"), def("RestElement"), null)]);
+    def("NewExpression")
+        .field("arguments", [or(def("Expression"), def("SpreadElement"))]);
+    def("CallExpression")
+        .field("arguments", [or(def("Expression"), def("SpreadElement"))]);
+    // Note: this node type is *not* an AssignmentExpression with a Pattern on
+    // the left-hand side! The existing AssignmentExpression type already
+    // supports destructuring assignments. AssignmentPattern nodes may appear
+    // wherever a Pattern is allowed, and the right-hand side represents a
+    // default value to be destructured against the left-hand side, if no
+    // value is otherwise provided. For example: default parameter values.
+    def("AssignmentPattern")
+        .bases("Pattern")
+        .build("left", "right")
+        .field("left", def("Pattern"))
+        .field("right", def("Expression"));
+    def("MethodDefinition")
+        .bases("Declaration")
+        .build("kind", "key", "value", "static")
+        .field("kind", or("constructor", "method", "get", "set"))
+        .field("key", def("Expression"))
+        .field("value", def("Function"))
+        .field("computed", Boolean, defaults["false"])
+        .field("static", Boolean, defaults["false"]);
+    var ClassBodyElement = or(def("MethodDefinition"), def("VariableDeclarator"), def("ClassPropertyDefinition"), def("ClassProperty"));
+    def("ClassProperty")
+        .bases("Declaration")
+        .build("key")
+        .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+        .field("computed", Boolean, defaults["false"]);
+    def("ClassPropertyDefinition") // static property
+        .bases("Declaration")
+        .build("definition")
+        // Yes, Virginia, circular definitions are permitted.
+        .field("definition", ClassBodyElement);
+    def("ClassBody")
+        .bases("Declaration")
+        .build("body")
+        .field("body", [ClassBodyElement]);
+    def("ClassDeclaration")
+        .bases("Declaration")
+        .build("id", "body", "superClass")
+        .field("id", or(def("Identifier"), null))
+        .field("body", def("ClassBody"))
+        .field("superClass", or(def("Expression"), null), defaults["null"]);
+    def("ClassExpression")
+        .bases("Expression")
+        .build("id", "body", "superClass")
+        .field("id", or(def("Identifier"), null), defaults["null"])
+        .field("body", def("ClassBody"))
+        .field("superClass", or(def("Expression"), null), defaults["null"]);
+    def("Super")
+        .bases("Expression")
+        .build();
+    // Specifier and ModuleSpecifier are abstract non-standard types
+    // introduced for definitional convenience.
+    def("Specifier").bases("Node");
+    // This supertype is shared/abused by both def/babel.js and
+    // def/esprima.js. In the future, it will be possible to load only one set
+    // of definitions appropriate for a given parser, but until then we must
+    // rely on default functions to reconcile the conflicting AST formats.
+    def("ModuleSpecifier")
+        .bases("Specifier")
+        // This local field is used by Babel/Acorn. It should not technically
+        // be optional in the Babel/Acorn AST format, but it must be optional
+        // in the Esprima AST format.
+        .field("local", or(def("Identifier"), null), defaults["null"])
+        // The id and name fields are used by Esprima. The id field should not
+        // technically be optional in the Esprima AST format, but it must be
+        // optional in the Babel/Acorn AST format.
+        .field("id", or(def("Identifier"), null), defaults["null"])
+        .field("name", or(def("Identifier"), null), defaults["null"]);
+    // import {<id [as name]>} from ...;
+    def("ImportSpecifier")
+        .bases("ModuleSpecifier")
+        .build("imported", "local")
+        .field("imported", def("Identifier"));
+    // import <id> from ...;
+    def("ImportDefaultSpecifier")
+        .bases("ModuleSpecifier")
+        .build("local");
+    // import <* as id> from ...;
+    def("ImportNamespaceSpecifier")
+        .bases("ModuleSpecifier")
+        .build("local");
+    def("ImportDeclaration")
+        .bases("Declaration")
+        .build("specifiers", "source", "importKind")
+        .field("specifiers", [or(def("ImportSpecifier"), def("ImportNamespaceSpecifier"), def("ImportDefaultSpecifier"))], defaults.emptyArray)
+        .field("source", def("Literal"))
+        .field("importKind", or("value", "type"), function () {
+        return "value";
+    });
+    def("ExportNamedDeclaration")
+        .bases("Declaration")
+        .build("declaration", "specifiers", "source")
+        .field("declaration", or(def("Declaration"), null))
+        .field("specifiers", [def("ExportSpecifier")], defaults.emptyArray)
+        .field("source", or(def("Literal"), null), defaults["null"]);
+    def("ExportSpecifier")
+        .bases("ModuleSpecifier")
+        .build("local", "exported")
+        .field("exported", def("Identifier"));
+    def("ExportDefaultDeclaration")
+        .bases("Declaration")
+        .build("declaration")
+        .field("declaration", or(def("Declaration"), def("Expression")));
+    def("ExportAllDeclaration")
+        .bases("Declaration")
+        .build("source")
+        .field("source", def("Literal"));
+    def("TaggedTemplateExpression")
+        .bases("Expression")
+        .build("tag", "quasi")
+        .field("tag", def("Expression"))
+        .field("quasi", def("TemplateLiteral"));
+    def("TemplateLiteral")
+        .bases("Expression")
+        .build("quasis", "expressions")
+        .field("quasis", [def("TemplateElement")])
+        .field("expressions", [def("Expression")]);
+    def("TemplateElement")
+        .bases("Node")
+        .build("value", "tail")
+        .field("value", { "cooked": String, "raw": String })
+        .field("tail", Boolean);
+    def("MetaProperty")
+        .bases("Expression")
+        .build("meta", "property")
+        .field("meta", def("Identifier"))
+        .field("property", def("Identifier"));
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/esprima.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/esprima.js

@@ -0,0 +1,49 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var es_proposals_1 = (0, tslib_1.__importDefault)(require("./es-proposals"));
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
+function default_1(fork) {
+    fork.use(es_proposals_1.default);
+    var types = fork.use(types_1.default);
+    var defaults = fork.use(shared_1.default).defaults;
+    var def = types.Type.def;
+    var or = types.Type.or;
+    def("VariableDeclaration")
+        .field("declarations", [or(def("VariableDeclarator"), def("Identifier") // Esprima deviation.
+        )]);
+    def("Property")
+        .field("value", or(def("Expression"), def("Pattern") // Esprima deviation.
+    ));
+    def("ArrayPattern")
+        .field("elements", [or(def("Pattern"), def("SpreadElement"), null)]);
+    def("ObjectPattern")
+        .field("properties", [or(def("Property"), def("PropertyPattern"), def("SpreadPropertyPattern"), def("SpreadProperty") // Used by Esprima.
+        )]);
+    // Like ModuleSpecifier, except type:"ExportSpecifier" and buildable.
+    // export {<id [as name]>} [from ...];
+    def("ExportSpecifier")
+        .bases("ModuleSpecifier")
+        .build("id", "name");
+    // export <*> from ...;
+    def("ExportBatchSpecifier")
+        .bases("Specifier")
+        .build();
+    def("ExportDeclaration")
+        .bases("Declaration")
+        .build("default", "declaration", "specifiers", "source")
+        .field("default", Boolean)
+        .field("declaration", or(def("Declaration"), def("Expression"), // Implies default.
+    null))
+        .field("specifiers", [or(def("ExportSpecifier"), def("ExportBatchSpecifier"))], defaults.emptyArray)
+        .field("source", or(def("Literal"), null), defaults["null"]);
+    def("Block")
+        .bases("Comment")
+        .build("value", /*optional:*/ "leading", "trailing");
+    def("Line")
+        .bases("Comment")
+        .build("value", /*optional:*/ "leading", "trailing");
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/flow.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/flow.js

@@ -0,0 +1,360 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var es_proposals_1 = (0, tslib_1.__importDefault)(require("./es-proposals"));
+var type_annotations_1 = (0, tslib_1.__importDefault)(require("./type-annotations"));
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
+function default_1(fork) {
+    fork.use(es_proposals_1.default);
+    fork.use(type_annotations_1.default);
+    var types = fork.use(types_1.default);
+    var def = types.Type.def;
+    var or = types.Type.or;
+    var defaults = fork.use(shared_1.default).defaults;
+    // Base types
+    def("Flow").bases("Node");
+    def("FlowType").bases("Flow");
+    // Type annotations
+    def("AnyTypeAnnotation")
+        .bases("FlowType")
+        .build();
+    def("EmptyTypeAnnotation")
+        .bases("FlowType")
+        .build();
+    def("MixedTypeAnnotation")
+        .bases("FlowType")
+        .build();
+    def("VoidTypeAnnotation")
+        .bases("FlowType")
+        .build();
+    def("SymbolTypeAnnotation")
+        .bases("FlowType")
+        .build();
+    def("NumberTypeAnnotation")
+        .bases("FlowType")
+        .build();
+    def("BigIntTypeAnnotation")
+        .bases("FlowType")
+        .build();
+    def("NumberLiteralTypeAnnotation")
+        .bases("FlowType")
+        .build("value", "raw")
+        .field("value", Number)
+        .field("raw", String);
+    // Babylon 6 differs in AST from Flow
+    // same as NumberLiteralTypeAnnotation
+    def("NumericLiteralTypeAnnotation")
+        .bases("FlowType")
+        .build("value", "raw")
+        .field("value", Number)
+        .field("raw", String);
+    def("BigIntLiteralTypeAnnotation")
+        .bases("FlowType")
+        .build("value", "raw")
+        .field("value", null)
+        .field("raw", String);
+    def("StringTypeAnnotation")
+        .bases("FlowType")
+        .build();
+    def("StringLiteralTypeAnnotation")
+        .bases("FlowType")
+        .build("value", "raw")
+        .field("value", String)
+        .field("raw", String);
+    def("BooleanTypeAnnotation")
+        .bases("FlowType")
+        .build();
+    def("BooleanLiteralTypeAnnotation")
+        .bases("FlowType")
+        .build("value", "raw")
+        .field("value", Boolean)
+        .field("raw", String);
+    def("TypeAnnotation")
+        .bases("Node")
+        .build("typeAnnotation")
+        .field("typeAnnotation", def("FlowType"));
+    def("NullableTypeAnnotation")
+        .bases("FlowType")
+        .build("typeAnnotation")
+        .field("typeAnnotation", def("FlowType"));
+    def("NullLiteralTypeAnnotation")
+        .bases("FlowType")
+        .build();
+    def("NullTypeAnnotation")
+        .bases("FlowType")
+        .build();
+    def("ThisTypeAnnotation")
+        .bases("FlowType")
+        .build();
+    def("ExistsTypeAnnotation")
+        .bases("FlowType")
+        .build();
+    def("ExistentialTypeParam")
+        .bases("FlowType")
+        .build();
+    def("FunctionTypeAnnotation")
+        .bases("FlowType")
+        .build("params", "returnType", "rest", "typeParameters")
+        .field("params", [def("FunctionTypeParam")])
+        .field("returnType", def("FlowType"))
+        .field("rest", or(def("FunctionTypeParam"), null))
+        .field("typeParameters", or(def("TypeParameterDeclaration"), null));
+    def("FunctionTypeParam")
+        .bases("Node")
+        .build("name", "typeAnnotation", "optional")
+        .field("name", or(def("Identifier"), null))
+        .field("typeAnnotation", def("FlowType"))
+        .field("optional", Boolean);
+    def("ArrayTypeAnnotation")
+        .bases("FlowType")
+        .build("elementType")
+        .field("elementType", def("FlowType"));
+    def("ObjectTypeAnnotation")
+        .bases("FlowType")
+        .build("properties", "indexers", "callProperties")
+        .field("properties", [
+        or(def("ObjectTypeProperty"), def("ObjectTypeSpreadProperty"))
+    ])
+        .field("indexers", [def("ObjectTypeIndexer")], defaults.emptyArray)
+        .field("callProperties", [def("ObjectTypeCallProperty")], defaults.emptyArray)
+        .field("inexact", or(Boolean, void 0), defaults["undefined"])
+        .field("exact", Boolean, defaults["false"])
+        .field("internalSlots", [def("ObjectTypeInternalSlot")], defaults.emptyArray);
+    def("Variance")
+        .bases("Node")
+        .build("kind")
+        .field("kind", or("plus", "minus"));
+    var LegacyVariance = or(def("Variance"), "plus", "minus", null);
+    def("ObjectTypeProperty")
+        .bases("Node")
+        .build("key", "value", "optional")
+        .field("key", or(def("Literal"), def("Identifier")))
+        .field("value", def("FlowType"))
+        .field("optional", Boolean)
+        .field("variance", LegacyVariance, defaults["null"]);
+    def("ObjectTypeIndexer")
+        .bases("Node")
+        .build("id", "key", "value")
+        .field("id", def("Identifier"))
+        .field("key", def("FlowType"))
+        .field("value", def("FlowType"))
+        .field("variance", LegacyVariance, defaults["null"])
+        .field("static", Boolean, defaults["false"]);
+    def("ObjectTypeCallProperty")
+        .bases("Node")
+        .build("value")
+        .field("value", def("FunctionTypeAnnotation"))
+        .field("static", Boolean, defaults["false"]);
+    def("QualifiedTypeIdentifier")
+        .bases("Node")
+        .build("qualification", "id")
+        .field("qualification", or(def("Identifier"), def("QualifiedTypeIdentifier")))
+        .field("id", def("Identifier"));
+    def("GenericTypeAnnotation")
+        .bases("FlowType")
+        .build("id", "typeParameters")
+        .field("id", or(def("Identifier"), def("QualifiedTypeIdentifier")))
+        .field("typeParameters", or(def("TypeParameterInstantiation"), null));
+    def("MemberTypeAnnotation")
+        .bases("FlowType")
+        .build("object", "property")
+        .field("object", def("Identifier"))
+        .field("property", or(def("MemberTypeAnnotation"), def("GenericTypeAnnotation")));
+    def("IndexedAccessType")
+        .bases("FlowType")
+        .build("objectType", "indexType")
+        .field("objectType", def("FlowType"))
+        .field("indexType", def("FlowType"));
+    def("OptionalIndexedAccessType")
+        .bases("FlowType")
+        .build("objectType", "indexType", "optional")
+        .field("objectType", def("FlowType"))
+        .field("indexType", def("FlowType"))
+        .field('optional', Boolean);
+    def("UnionTypeAnnotation")
+        .bases("FlowType")
+        .build("types")
+        .field("types", [def("FlowType")]);
+    def("IntersectionTypeAnnotation")
+        .bases("FlowType")
+        .build("types")
+        .field("types", [def("FlowType")]);
+    def("TypeofTypeAnnotation")
+        .bases("FlowType")
+        .build("argument")
+        .field("argument", def("FlowType"));
+    def("ObjectTypeSpreadProperty")
+        .bases("Node")
+        .build("argument")
+        .field("argument", def("FlowType"));
+    def("ObjectTypeInternalSlot")
+        .bases("Node")
+        .build("id", "value", "optional", "static", "method")
+        .field("id", def("Identifier"))
+        .field("value", def("FlowType"))
+        .field("optional", Boolean)
+        .field("static", Boolean)
+        .field("method", Boolean);
+    def("TypeParameterDeclaration")
+        .bases("Node")
+        .build("params")
+        .field("params", [def("TypeParameter")]);
+    def("TypeParameterInstantiation")
+        .bases("Node")
+        .build("params")
+        .field("params", [def("FlowType")]);
+    def("TypeParameter")
+        .bases("FlowType")
+        .build("name", "variance", "bound", "default")
+        .field("name", String)
+        .field("variance", LegacyVariance, defaults["null"])
+        .field("bound", or(def("TypeAnnotation"), null), defaults["null"])
+        .field("default", or(def("FlowType"), null), defaults["null"]);
+    def("ClassProperty")
+        .field("variance", LegacyVariance, defaults["null"]);
+    def("ClassImplements")
+        .bases("Node")
+        .build("id")
+        .field("id", def("Identifier"))
+        .field("superClass", or(def("Expression"), null), defaults["null"])
+        .field("typeParameters", or(def("TypeParameterInstantiation"), null), defaults["null"]);
+    def("InterfaceTypeAnnotation")
+        .bases("FlowType")
+        .build("body", "extends")
+        .field("body", def("ObjectTypeAnnotation"))
+        .field("extends", or([def("InterfaceExtends")], null), defaults["null"]);
+    def("InterfaceDeclaration")
+        .bases("Declaration")
+        .build("id", "body", "extends")
+        .field("id", def("Identifier"))
+        .field("typeParameters", or(def("TypeParameterDeclaration"), null), defaults["null"])
+        .field("body", def("ObjectTypeAnnotation"))
+        .field("extends", [def("InterfaceExtends")]);
+    def("DeclareInterface")
+        .bases("InterfaceDeclaration")
+        .build("id", "body", "extends");
+    def("InterfaceExtends")
+        .bases("Node")
+        .build("id")
+        .field("id", def("Identifier"))
+        .field("typeParameters", or(def("TypeParameterInstantiation"), null), defaults["null"]);
+    def("TypeAlias")
+        .bases("Declaration")
+        .build("id", "typeParameters", "right")
+        .field("id", def("Identifier"))
+        .field("typeParameters", or(def("TypeParameterDeclaration"), null))
+        .field("right", def("FlowType"));
+    def("DeclareTypeAlias")
+        .bases("TypeAlias")
+        .build("id", "typeParameters", "right");
+    def("OpaqueType")
+        .bases("Declaration")
+        .build("id", "typeParameters", "impltype", "supertype")
+        .field("id", def("Identifier"))
+        .field("typeParameters", or(def("TypeParameterDeclaration"), null))
+        .field("impltype", def("FlowType"))
+        .field("supertype", or(def("FlowType"), null));
+    def("DeclareOpaqueType")
+        .bases("OpaqueType")
+        .build("id", "typeParameters", "supertype")
+        .field("impltype", or(def("FlowType"), null));
+    def("TypeCastExpression")
+        .bases("Expression")
+        .build("expression", "typeAnnotation")
+        .field("expression", def("Expression"))
+        .field("typeAnnotation", def("TypeAnnotation"));
+    def("TupleTypeAnnotation")
+        .bases("FlowType")
+        .build("types")
+        .field("types", [def("FlowType")]);
+    def("DeclareVariable")
+        .bases("Statement")
+        .build("id")
+        .field("id", def("Identifier"));
+    def("DeclareFunction")
+        .bases("Statement")
+        .build("id")
+        .field("id", def("Identifier"))
+        .field("predicate", or(def("FlowPredicate"), null), defaults["null"]);
+    def("DeclareClass")
+        .bases("InterfaceDeclaration")
+        .build("id");
+    def("DeclareModule")
+        .bases("Statement")
+        .build("id", "body")
+        .field("id", or(def("Identifier"), def("Literal")))
+        .field("body", def("BlockStatement"));
+    def("DeclareModuleExports")
+        .bases("Statement")
+        .build("typeAnnotation")
+        .field("typeAnnotation", def("TypeAnnotation"));
+    def("DeclareExportDeclaration")
+        .bases("Declaration")
+        .build("default", "declaration", "specifiers", "source")
+        .field("default", Boolean)
+        .field("declaration", or(def("DeclareVariable"), def("DeclareFunction"), def("DeclareClass"), def("FlowType"), // Implies default.
+    def("TypeAlias"), // Implies named type
+    def("DeclareOpaqueType"), // Implies named opaque type
+    def("InterfaceDeclaration"), null))
+        .field("specifiers", [or(def("ExportSpecifier"), def("ExportBatchSpecifier"))], defaults.emptyArray)
+        .field("source", or(def("Literal"), null), defaults["null"]);
+    def("DeclareExportAllDeclaration")
+        .bases("Declaration")
+        .build("source")
+        .field("source", or(def("Literal"), null), defaults["null"]);
+    def("ImportDeclaration")
+        .field("importKind", or("value", "type", "typeof"), function () { return "value"; });
+    def("FlowPredicate").bases("Flow");
+    def("InferredPredicate")
+        .bases("FlowPredicate")
+        .build();
+    def("DeclaredPredicate")
+        .bases("FlowPredicate")
+        .build("value")
+        .field("value", def("Expression"));
+    def("Function")
+        .field("predicate", or(def("FlowPredicate"), null), defaults["null"]);
+    def("CallExpression")
+        .field("typeArguments", or(null, def("TypeParameterInstantiation")), defaults["null"]);
+    def("NewExpression")
+        .field("typeArguments", or(null, def("TypeParameterInstantiation")), defaults["null"]);
+    // Enums
+    def("EnumDeclaration")
+        .bases("Declaration")
+        .build("id", "body")
+        .field("id", def("Identifier"))
+        .field("body", or(def("EnumBooleanBody"), def("EnumNumberBody"), def("EnumStringBody"), def("EnumSymbolBody")));
+    def("EnumBooleanBody")
+        .build("members", "explicitType")
+        .field("members", [def("EnumBooleanMember")])
+        .field("explicitType", Boolean);
+    def("EnumNumberBody")
+        .build("members", "explicitType")
+        .field("members", [def("EnumNumberMember")])
+        .field("explicitType", Boolean);
+    def("EnumStringBody")
+        .build("members", "explicitType")
+        .field("members", or([def("EnumStringMember")], [def("EnumDefaultedMember")]))
+        .field("explicitType", Boolean);
+    def("EnumSymbolBody")
+        .build("members")
+        .field("members", [def("EnumDefaultedMember")]);
+    def("EnumBooleanMember")
+        .build("id", "init")
+        .field("id", def("Identifier"))
+        .field("init", or(def("Literal"), Boolean));
+    def("EnumNumberMember")
+        .build("id", "init")
+        .field("id", def("Identifier"))
+        .field("init", def("Literal"));
+    def("EnumStringMember")
+        .build("id", "init")
+        .field("id", def("Identifier"))
+        .field("init", def("Literal"));
+    def("EnumDefaultedMember")
+        .build("id")
+        .field("id", def("Identifier"));
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/jsx.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/jsx.js

@@ -0,0 +1,108 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var es_proposals_1 = (0, tslib_1.__importDefault)(require("./es-proposals"));
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
+function default_1(fork) {
+    fork.use(es_proposals_1.default);
+    var types = fork.use(types_1.default);
+    var def = types.Type.def;
+    var or = types.Type.or;
+    var defaults = fork.use(shared_1.default).defaults;
+    def("JSXAttribute")
+        .bases("Node")
+        .build("name", "value")
+        .field("name", or(def("JSXIdentifier"), def("JSXNamespacedName")))
+        .field("value", or(def("Literal"), // attr="value"
+    def("JSXExpressionContainer"), // attr={value}
+    def("JSXElement"), // attr=<div />
+    def("JSXFragment"), // attr=<></>
+    null // attr= or just attr
+    ), defaults["null"]);
+    def("JSXIdentifier")
+        .bases("Identifier")
+        .build("name")
+        .field("name", String);
+    def("JSXNamespacedName")
+        .bases("Node")
+        .build("namespace", "name")
+        .field("namespace", def("JSXIdentifier"))
+        .field("name", def("JSXIdentifier"));
+    def("JSXMemberExpression")
+        .bases("MemberExpression")
+        .build("object", "property")
+        .field("object", or(def("JSXIdentifier"), def("JSXMemberExpression")))
+        .field("property", def("JSXIdentifier"))
+        .field("computed", Boolean, defaults.false);
+    var JSXElementName = or(def("JSXIdentifier"), def("JSXNamespacedName"), def("JSXMemberExpression"));
+    def("JSXSpreadAttribute")
+        .bases("Node")
+        .build("argument")
+        .field("argument", def("Expression"));
+    var JSXAttributes = [or(def("JSXAttribute"), def("JSXSpreadAttribute"))];
+    def("JSXExpressionContainer")
+        .bases("Expression")
+        .build("expression")
+        .field("expression", or(def("Expression"), def("JSXEmptyExpression")));
+    var JSXChildren = [or(def("JSXText"), def("JSXExpressionContainer"), def("JSXSpreadChild"), def("JSXElement"), def("JSXFragment"), def("Literal") // Legacy: Esprima should return JSXText instead.
+        )];
+    def("JSXElement")
+        .bases("Expression")
+        .build("openingElement", "closingElement", "children")
+        .field("openingElement", def("JSXOpeningElement"))
+        .field("closingElement", or(def("JSXClosingElement"), null), defaults["null"])
+        .field("children", JSXChildren, defaults.emptyArray)
+        .field("name", JSXElementName, function () {
+        // Little-known fact: the `this` object inside a default function
+        // is none other than the partially-built object itself, and any
+        // fields initialized directly from builder function arguments
+        // (like openingElement, closingElement, and children) are
+        // guaranteed to be available.
+        return this.openingElement.name;
+    }, true) // hidden from traversal
+        .field("selfClosing", Boolean, function () {
+        return this.openingElement.selfClosing;
+    }, true) // hidden from traversal
+        .field("attributes", JSXAttributes, function () {
+        return this.openingElement.attributes;
+    }, true); // hidden from traversal
+    def("JSXOpeningElement")
+        .bases("Node")
+        .build("name", "attributes", "selfClosing")
+        .field("name", JSXElementName)
+        .field("attributes", JSXAttributes, defaults.emptyArray)
+        .field("selfClosing", Boolean, defaults["false"]);
+    def("JSXClosingElement")
+        .bases("Node")
+        .build("name")
+        .field("name", JSXElementName);
+    def("JSXFragment")
+        .bases("Expression")
+        .build("openingFragment", "closingFragment", "children")
+        .field("openingFragment", def("JSXOpeningFragment"))
+        .field("closingFragment", def("JSXClosingFragment"))
+        .field("children", JSXChildren, defaults.emptyArray);
+    def("JSXOpeningFragment")
+        .bases("Node")
+        .build();
+    def("JSXClosingFragment")
+        .bases("Node")
+        .build();
+    def("JSXText")
+        .bases("Literal")
+        .build("value", "raw")
+        .field("value", String)
+        .field("raw", String, function () {
+        return this.value;
+    });
+    def("JSXEmptyExpression")
+        .bases("Node")
+        .build();
+    def("JSXSpreadChild")
+        .bases("Node")
+        .build("expression")
+        .field("expression", def("Expression"));
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/operators/core.d.ts

@@ -0,0 +1,5 @@
+export default function (): {
+    BinaryOperators: string[];
+    AssignmentOperators: string[];
+    LogicalOperators: string[];
+};

node_modules/recast/node_modules/ast-types/def/operators/core.js

@@ -0,0 +1,25 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1() {
+    return {
+        BinaryOperators: [
+            "==", "!=", "===", "!==",
+            "<", "<=", ">", ">=",
+            "<<", ">>", ">>>",
+            "+", "-", "*", "/", "%",
+            "&",
+            "|", "^", "in",
+            "instanceof",
+        ],
+        AssignmentOperators: [
+            "=", "+=", "-=", "*=", "/=", "%=",
+            "<<=", ">>=", ">>>=",
+            "|=", "^=", "&=",
+        ],
+        LogicalOperators: [
+            "||", "&&",
+        ],
+    };
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/operators/es2016.d.ts

@@ -0,0 +1,5 @@
+export default function (fork: import("../../types").Fork): {
+    BinaryOperators: string[];
+    AssignmentOperators: string[];
+    LogicalOperators: string[];
+};

node_modules/recast/node_modules/ast-types/def/operators/es2016.js

@@ -0,0 +1,19 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var core_1 = (0, tslib_1.__importDefault)(require("./core"));
+function default_1(fork) {
+    var result = fork.use(core_1.default);
+    // Exponentiation operators. Must run before BinaryOperators or
+    // AssignmentOperators are used (hence before fork.use(es6Def)).
+    // https://github.com/tc39/proposal-exponentiation-operator
+    if (result.BinaryOperators.indexOf("**") < 0) {
+        result.BinaryOperators.push("**");
+    }
+    if (result.AssignmentOperators.indexOf("**=") < 0) {
+        result.AssignmentOperators.push("**=");
+    }
+    return result;
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/operators/es2020.d.ts

@@ -0,0 +1,5 @@
+export default function (fork: import("../../types").Fork): {
+    BinaryOperators: string[];
+    AssignmentOperators: string[];
+    LogicalOperators: string[];
+};

node_modules/recast/node_modules/ast-types/def/operators/es2020.js

@@ -0,0 +1,15 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var es2016_1 = (0, tslib_1.__importDefault)(require("./es2016"));
+function default_1(fork) {
+    var result = fork.use(es2016_1.default);
+    // Nullish coalescing. Must run before LogicalOperators is used.
+    // https://github.com/tc39/proposal-nullish-coalescing
+    if (result.LogicalOperators.indexOf("??") < 0) {
+        result.LogicalOperators.push("??");
+    }
+    return result;
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/operators/es2021.d.ts

@@ -0,0 +1,5 @@
+export default function (fork: import("../../types").Fork): {
+    BinaryOperators: string[];
+    AssignmentOperators: string[];
+    LogicalOperators: string[];
+};

node_modules/recast/node_modules/ast-types/def/operators/es2021.js

@@ -0,0 +1,18 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var es2020_1 = (0, tslib_1.__importDefault)(require("./es2020"));
+function default_1(fork) {
+    var result = fork.use(es2020_1.default);
+    // Logical assignment operators. Must run before AssignmentOperators is used.
+    // https://github.com/tc39/proposal-logical-assignment
+    result.LogicalOperators.forEach(function (op) {
+        var assignOp = op + "=";
+        if (result.AssignmentOperators.indexOf(assignOp) < 0) {
+            result.AssignmentOperators.push(assignOp);
+        }
+    });
+    return result;
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/type-annotations.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Type annotation defs shared between Flow and TypeScript.
+ * These defs could not be defined in ./flow.ts or ./typescript.ts directly
+ * because they use the same name.
+ */
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/type-annotations.js

@@ -0,0 +1,40 @@
+"use strict";;
+/**
+ * Type annotation defs shared between Flow and TypeScript.
+ * These defs could not be defined in ./flow.ts or ./typescript.ts directly
+ * because they use the same name.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
+function default_1(fork) {
+    var types = fork.use(types_1.default);
+    var def = types.Type.def;
+    var or = types.Type.or;
+    var defaults = fork.use(shared_1.default).defaults;
+    var TypeAnnotation = or(def("TypeAnnotation"), def("TSTypeAnnotation"), null);
+    var TypeParamDecl = or(def("TypeParameterDeclaration"), def("TSTypeParameterDeclaration"), null);
+    def("Identifier")
+        .field("typeAnnotation", TypeAnnotation, defaults["null"]);
+    def("ObjectPattern")
+        .field("typeAnnotation", TypeAnnotation, defaults["null"]);
+    def("Function")
+        .field("returnType", TypeAnnotation, defaults["null"])
+        .field("typeParameters", TypeParamDecl, defaults["null"]);
+    def("ClassProperty")
+        .build("key", "value", "typeAnnotation", "static")
+        .field("value", or(def("Expression"), null))
+        .field("static", Boolean, defaults["false"])
+        .field("typeAnnotation", TypeAnnotation, defaults["null"]);
+    ["ClassDeclaration",
+        "ClassExpression",
+    ].forEach(function (typeName) {
+        def(typeName)
+            .field("typeParameters", TypeParamDecl, defaults["null"])
+            .field("superTypeParameters", or(def("TypeParameterInstantiation"), def("TSTypeParameterInstantiation"), null), defaults["null"])
+            .field("implements", or([def("ClassImplements")], [def("TSExpressionWithTypeArguments")]), defaults.emptyArray);
+    });
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/def/typescript.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

node_modules/recast/node_modules/ast-types/def/typescript.js

@@ -0,0 +1,351 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var babel_core_1 = (0, tslib_1.__importDefault)(require("./babel-core"));
+var type_annotations_1 = (0, tslib_1.__importDefault)(require("./type-annotations"));
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
+function default_1(fork) {
+    // Since TypeScript is parsed by Babylon, include the core Babylon types
+    // but omit the Flow-related types.
+    fork.use(babel_core_1.default);
+    fork.use(type_annotations_1.default);
+    var types = fork.use(types_1.default);
+    var n = types.namedTypes;
+    var def = types.Type.def;
+    var or = types.Type.or;
+    var defaults = fork.use(shared_1.default).defaults;
+    var StringLiteral = types.Type.from(function (value, deep) {
+        if (n.StringLiteral &&
+            n.StringLiteral.check(value, deep)) {
+            return true;
+        }
+        if (n.Literal &&
+            n.Literal.check(value, deep) &&
+            typeof value.value === "string") {
+            return true;
+        }
+        return false;
+    }, "StringLiteral");
+    def("TSType")
+        .bases("Node");
+    var TSEntityName = or(def("Identifier"), def("TSQualifiedName"));
+    def("TSTypeReference")
+        .bases("TSType", "TSHasOptionalTypeParameterInstantiation")
+        .build("typeName", "typeParameters")
+        .field("typeName", TSEntityName);
+    // An abstract (non-buildable) base type that provide a commonly-needed
+    // optional .typeParameters field.
+    def("TSHasOptionalTypeParameterInstantiation")
+        .field("typeParameters", or(def("TSTypeParameterInstantiation"), null), defaults["null"]);
+    // An abstract (non-buildable) base type that provide a commonly-needed
+    // optional .typeParameters field.
+    def("TSHasOptionalTypeParameters")
+        .field("typeParameters", or(def("TSTypeParameterDeclaration"), null, void 0), defaults["null"]);
+    // An abstract (non-buildable) base type that provide a commonly-needed
+    // optional .typeAnnotation field.
+    def("TSHasOptionalTypeAnnotation")
+        .field("typeAnnotation", or(def("TSTypeAnnotation"), null), defaults["null"]);
+    def("TSQualifiedName")
+        .bases("Node")
+        .build("left", "right")
+        .field("left", TSEntityName)
+        .field("right", TSEntityName);
+    def("TSAsExpression")
+        .bases("Expression", "Pattern")
+        .build("expression", "typeAnnotation")
+        .field("expression", def("Expression"))
+        .field("typeAnnotation", def("TSType"))
+        .field("extra", or({ parenthesized: Boolean }, null), defaults["null"]);
+    def("TSNonNullExpression")
+        .bases("Expression", "Pattern")
+        .build("expression")
+        .field("expression", def("Expression"));
+    [
+        "TSAnyKeyword",
+        "TSBigIntKeyword",
+        "TSBooleanKeyword",
+        "TSNeverKeyword",
+        "TSNullKeyword",
+        "TSNumberKeyword",
+        "TSObjectKeyword",
+        "TSStringKeyword",
+        "TSSymbolKeyword",
+        "TSUndefinedKeyword",
+        "TSUnknownKeyword",
+        "TSVoidKeyword",
+        "TSIntrinsicKeyword",
+        "TSThisType",
+    ].forEach(function (keywordType) {
+        def(keywordType)
+            .bases("TSType")
+            .build();
+    });
+    def("TSArrayType")
+        .bases("TSType")
+        .build("elementType")
+        .field("elementType", def("TSType"));
+    def("TSLiteralType")
+        .bases("TSType")
+        .build("literal")
+        .field("literal", or(def("NumericLiteral"), def("StringLiteral"), def("BooleanLiteral"), def("TemplateLiteral"), def("UnaryExpression")));
+    def("TemplateLiteral")
+        // The TemplateLiteral type appears to be reused for TypeScript template
+        // literal types (instead of introducing a new TSTemplateLiteralType type),
+        // so we allow the templateLiteral.expressions array to be either all
+        // expressions or all TypeScript types.
+        .field("expressions", or([def("Expression")], [def("TSType")]));
+    ["TSUnionType",
+        "TSIntersectionType",
+    ].forEach(function (typeName) {
+        def(typeName)
+            .bases("TSType")
+            .build("types")
+            .field("types", [def("TSType")]);
+    });
+    def("TSConditionalType")
+        .bases("TSType")
+        .build("checkType", "extendsType", "trueType", "falseType")
+        .field("checkType", def("TSType"))
+        .field("extendsType", def("TSType"))
+        .field("trueType", def("TSType"))
+        .field("falseType", def("TSType"));
+    def("TSInferType")
+        .bases("TSType")
+        .build("typeParameter")
+        .field("typeParameter", def("TSTypeParameter"));
+    def("TSParenthesizedType")
+        .bases("TSType")
+        .build("typeAnnotation")
+        .field("typeAnnotation", def("TSType"));
+    var ParametersType = [or(def("Identifier"), def("RestElement"), def("ArrayPattern"), def("ObjectPattern"))];
+    ["TSFunctionType",
+        "TSConstructorType",
+    ].forEach(function (typeName) {
+        def(typeName)
+            .bases("TSType", "TSHasOptionalTypeParameters", "TSHasOptionalTypeAnnotation")
+            .build("parameters")
+            .field("parameters", ParametersType);
+    });
+    def("TSDeclareFunction")
+        .bases("Declaration", "TSHasOptionalTypeParameters")
+        .build("id", "params", "returnType")
+        .field("declare", Boolean, defaults["false"])
+        .field("async", Boolean, defaults["false"])
+        .field("generator", Boolean, defaults["false"])
+        .field("id", or(def("Identifier"), null), defaults["null"])
+        .field("params", [def("Pattern")])
+        // tSFunctionTypeAnnotationCommon
+        .field("returnType", or(def("TSTypeAnnotation"), def("Noop"), // Still used?
+    null), defaults["null"]);
+    def("TSDeclareMethod")
+        .bases("Declaration", "TSHasOptionalTypeParameters")
+        .build("key", "params", "returnType")
+        .field("async", Boolean, defaults["false"])
+        .field("generator", Boolean, defaults["false"])
+        .field("params", [def("Pattern")])
+        // classMethodOrPropertyCommon
+        .field("abstract", Boolean, defaults["false"])
+        .field("accessibility", or("public", "private", "protected", void 0), defaults["undefined"])
+        .field("static", Boolean, defaults["false"])
+        .field("computed", Boolean, defaults["false"])
+        .field("optional", Boolean, defaults["false"])
+        .field("key", or(def("Identifier"), def("StringLiteral"), def("NumericLiteral"), 
+    // Only allowed if .computed is true.
+    def("Expression")))
+        // classMethodOrDeclareMethodCommon
+        .field("kind", or("get", "set", "method", "constructor"), function getDefault() { return "method"; })
+        .field("access", // Not "accessibility"?
+    or("public", "private", "protected", void 0), defaults["undefined"])
+        .field("decorators", or([def("Decorator")], null), defaults["null"])
+        // tSFunctionTypeAnnotationCommon
+        .field("returnType", or(def("TSTypeAnnotation"), def("Noop"), // Still used?
+    null), defaults["null"]);
+    def("TSMappedType")
+        .bases("TSType")
+        .build("typeParameter", "typeAnnotation")
+        .field("readonly", or(Boolean, "+", "-"), defaults["false"])
+        .field("typeParameter", def("TSTypeParameter"))
+        .field("optional", or(Boolean, "+", "-"), defaults["false"])
+        .field("typeAnnotation", or(def("TSType"), null), defaults["null"]);
+    def("TSTupleType")
+        .bases("TSType")
+        .build("elementTypes")
+        .field("elementTypes", [or(def("TSType"), def("TSNamedTupleMember"))]);
+    def("TSNamedTupleMember")
+        .bases("TSType")
+        .build("label", "elementType", "optional")
+        .field("label", def("Identifier"))
+        .field("optional", Boolean, defaults["false"])
+        .field("elementType", def("TSType"));
+    def("TSRestType")
+        .bases("TSType")
+        .build("typeAnnotation")
+        .field("typeAnnotation", def("TSType"));
+    def("TSOptionalType")
+        .bases("TSType")
+        .build("typeAnnotation")
+        .field("typeAnnotation", def("TSType"));
+    def("TSIndexedAccessType")
+        .bases("TSType")
+        .build("objectType", "indexType")
+        .field("objectType", def("TSType"))
+        .field("indexType", def("TSType"));
+    def("TSTypeOperator")
+        .bases("TSType")
+        .build("operator")
+        .field("operator", String)
+        .field("typeAnnotation", def("TSType"));
+    def("TSTypeAnnotation")
+        .bases("Node")
+        .build("typeAnnotation")
+        .field("typeAnnotation", or(def("TSType"), def("TSTypeAnnotation")));
+    def("TSIndexSignature")
+        .bases("Declaration", "TSHasOptionalTypeAnnotation")
+        .build("parameters", "typeAnnotation")
+        .field("parameters", [def("Identifier")]) // Length === 1
+        .field("readonly", Boolean, defaults["false"]);
+    def("TSPropertySignature")
+        .bases("Declaration", "TSHasOptionalTypeAnnotation")
+        .build("key", "typeAnnotation", "optional")
+        .field("key", def("Expression"))
+        .field("computed", Boolean, defaults["false"])
+        .field("readonly", Boolean, defaults["false"])
+        .field("optional", Boolean, defaults["false"])
+        .field("initializer", or(def("Expression"), null), defaults["null"]);
+    def("TSMethodSignature")
+        .bases("Declaration", "TSHasOptionalTypeParameters", "TSHasOptionalTypeAnnotation")
+        .build("key", "parameters", "typeAnnotation")
+        .field("key", def("Expression"))
+        .field("computed", Boolean, defaults["false"])
+        .field("optional", Boolean, defaults["false"])
+        .field("parameters", ParametersType);
+    def("TSTypePredicate")
+        .bases("TSTypeAnnotation", "TSType")
+        .build("parameterName", "typeAnnotation", "asserts")
+        .field("parameterName", or(def("Identifier"), def("TSThisType")))
+        .field("typeAnnotation", or(def("TSTypeAnnotation"), null), defaults["null"])
+        .field("asserts", Boolean, defaults["false"]);
+    ["TSCallSignatureDeclaration",
+        "TSConstructSignatureDeclaration",
+    ].forEach(function (typeName) {
+        def(typeName)
+            .bases("Declaration", "TSHasOptionalTypeParameters", "TSHasOptionalTypeAnnotation")
+            .build("parameters", "typeAnnotation")
+            .field("parameters", ParametersType);
+    });
+    def("TSEnumMember")
+        .bases("Node")
+        .build("id", "initializer")
+        .field("id", or(def("Identifier"), StringLiteral))
+        .field("initializer", or(def("Expression"), null), defaults["null"]);
+    def("TSTypeQuery")
+        .bases("TSType")
+        .build("exprName")
+        .field("exprName", or(TSEntityName, def("TSImportType")));
+    // Inferred from Babylon's tsParseTypeMember method.
+    var TSTypeMember = or(def("TSCallSignatureDeclaration"), def("TSConstructSignatureDeclaration"), def("TSIndexSignature"), def("TSMethodSignature"), def("TSPropertySignature"));
+    def("TSTypeLiteral")
+        .bases("TSType")
+        .build("members")
+        .field("members", [TSTypeMember]);
+    def("TSTypeParameter")
+        .bases("Identifier")
+        .build("name", "constraint", "default")
+        .field("name", String)
+        .field("constraint", or(def("TSType"), void 0), defaults["undefined"])
+        .field("default", or(def("TSType"), void 0), defaults["undefined"]);
+    def("TSTypeAssertion")
+        .bases("Expression", "Pattern")
+        .build("typeAnnotation", "expression")
+        .field("typeAnnotation", def("TSType"))
+        .field("expression", def("Expression"))
+        .field("extra", or({ parenthesized: Boolean }, null), defaults["null"]);
+    def("TSTypeParameterDeclaration")
+        .bases("Declaration")
+        .build("params")
+        .field("params", [def("TSTypeParameter")]);
+    def("TSTypeParameterInstantiation")
+        .bases("Node")
+        .build("params")
+        .field("params", [def("TSType")]);
+    def("TSEnumDeclaration")
+        .bases("Declaration")
+        .build("id", "members")
+        .field("id", def("Identifier"))
+        .field("const", Boolean, defaults["false"])
+        .field("declare", Boolean, defaults["false"])
+        .field("members", [def("TSEnumMember")])
+        .field("initializer", or(def("Expression"), null), defaults["null"]);
+    def("TSTypeAliasDeclaration")
+        .bases("Declaration", "TSHasOptionalTypeParameters")
+        .build("id", "typeAnnotation")
+        .field("id", def("Identifier"))
+        .field("declare", Boolean, defaults["false"])
+        .field("typeAnnotation", def("TSType"));
+    def("TSModuleBlock")
+        .bases("Node")
+        .build("body")
+        .field("body", [def("Statement")]);
+    def("TSModuleDeclaration")
+        .bases("Declaration")
+        .build("id", "body")
+        .field("id", or(StringLiteral, TSEntityName))
+        .field("declare", Boolean, defaults["false"])
+        .field("global", Boolean, defaults["false"])
+        .field("body", or(def("TSModuleBlock"), def("TSModuleDeclaration"), null), defaults["null"]);
+    def("TSImportType")
+        .bases("TSType", "TSHasOptionalTypeParameterInstantiation")
+        .build("argument", "qualifier", "typeParameters")
+        .field("argument", StringLiteral)
+        .field("qualifier", or(TSEntityName, void 0), defaults["undefined"]);
+    def("TSImportEqualsDeclaration")
+        .bases("Declaration")
+        .build("id", "moduleReference")
+        .field("id", def("Identifier"))
+        .field("isExport", Boolean, defaults["false"])
+        .field("moduleReference", or(TSEntityName, def("TSExternalModuleReference")));
+    def("TSExternalModuleReference")
+        .bases("Declaration")
+        .build("expression")
+        .field("expression", StringLiteral);
+    def("TSExportAssignment")
+        .bases("Statement")
+        .build("expression")
+        .field("expression", def("Expression"));
+    def("TSNamespaceExportDeclaration")
+        .bases("Declaration")
+        .build("id")
+        .field("id", def("Identifier"));
+    def("TSInterfaceBody")
+        .bases("Node")
+        .build("body")
+        .field("body", [TSTypeMember]);
+    def("TSExpressionWithTypeArguments")
+        .bases("TSType", "TSHasOptionalTypeParameterInstantiation")
+        .build("expression", "typeParameters")
+        .field("expression", TSEntityName);
+    def("TSInterfaceDeclaration")
+        .bases("Declaration", "TSHasOptionalTypeParameters")
+        .build("id", "body")
+        .field("id", TSEntityName)
+        .field("declare", Boolean, defaults["false"])
+        .field("extends", or([def("TSExpressionWithTypeArguments")], null), defaults["null"])
+        .field("body", def("TSInterfaceBody"));
+    def("TSParameterProperty")
+        .bases("Pattern")
+        .build("parameter")
+        .field("accessibility", or("public", "private", "protected", void 0), defaults["undefined"])
+        .field("readonly", Boolean, defaults["false"])
+        .field("parameter", or(def("Identifier"), def("AssignmentPattern")));
+    def("ClassProperty")
+        .field("access", // Not "accessibility"?
+    or("public", "private", "protected", void 0), defaults["undefined"]);
+    // Defined already in es6 and babel-core.
+    def("ClassBody")
+        .field("body", [or(def("MethodDefinition"), def("VariableDeclarator"), def("ClassPropertyDefinition"), def("ClassProperty"), def("ClassPrivateProperty"), def("ClassMethod"), def("ClassPrivateMethod"), 
+        // Just need to add these types:
+        def("TSDeclareMethod"), TSTypeMember)]);
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/fork.d.ts

@@ -0,0 +1,43 @@
+import { Plugin } from "./types";
+export default function (plugins: Plugin<any>[]): {
+    Type: {
+        or(...types: any[]): import("./lib/types").Type<any>;
+        from<T>(value: any, name?: string | undefined): import("./lib/types").Type<T>;
+        def(typeName: string): import("./lib/types").Def<any>;
+        hasDef(typeName: string): boolean;
+    };
+    builtInTypes: {
+        string: import("./lib/types").Type<string>;
+        function: import("./lib/types").Type<Function>;
+        array: import("./lib/types").Type<any[]>;
+        object: import("./lib/types").Type<{
+            [key: string]: any;
+        }>;
+        RegExp: import("./lib/types").Type<RegExp>;
+        Date: import("./lib/types").Type<Date>;
+        number: import("./lib/types").Type<number>;
+        boolean: import("./lib/types").Type<boolean>;
+        null: import("./lib/types").Type<null>;
+        undefined: import("./lib/types").Type<undefined>;
+        BigInt: import("./lib/types").Type<BigInt>;
+    };
+    namedTypes: import("./gen/namedTypes").NamedTypes;
+    builders: import("./gen/builders").builders;
+    defineMethod: (name: any, func?: Function | undefined) => Function;
+    getFieldNames: (object: any) => string[];
+    getFieldValue: (object: any, fieldName: any) => any;
+    eachField: (object: any, callback: (name: any, value: any) => any, context?: any) => void;
+    someField: (object: any, callback: (name: any, value: any) => any, context?: any) => boolean;
+    getSupertypeNames: (typeName: string) => string[];
+    getBuilderName: (typeName: any) => any;
+    astNodesAreEquivalent: {
+        (a: any, b: any, problemPath?: any): boolean;
+        assert(a: any, b: any): void;
+    };
+    finalize: () => void;
+    Path: import("./lib/path").PathConstructor;
+    NodePath: import("./lib/node-path").NodePathConstructor;
+    PathVisitor: import("./lib/path-visitor").PathVisitorConstructor;
+    use: <T_1>(plugin: Plugin<T_1>) => T_1;
+    visit: <M = {}>(node: import("./lib/types").ASTNode, methods?: import("./main").Visitor<M> | undefined) => any;
+};

node_modules/recast/node_modules/ast-types/fork.js

@@ -0,0 +1,52 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var types_1 = (0, tslib_1.__importDefault)(require("./lib/types"));
+var path_visitor_1 = (0, tslib_1.__importDefault)(require("./lib/path-visitor"));
+var equiv_1 = (0, tslib_1.__importDefault)(require("./lib/equiv"));
+var path_1 = (0, tslib_1.__importDefault)(require("./lib/path"));
+var node_path_1 = (0, tslib_1.__importDefault)(require("./lib/node-path"));
+function default_1(plugins) {
+    var fork = createFork();
+    var types = fork.use(types_1.default);
+    plugins.forEach(fork.use);
+    types.finalize();
+    var PathVisitor = fork.use(path_visitor_1.default);
+    return {
+        Type: types.Type,
+        builtInTypes: types.builtInTypes,
+        namedTypes: types.namedTypes,
+        builders: types.builders,
+        defineMethod: types.defineMethod,
+        getFieldNames: types.getFieldNames,
+        getFieldValue: types.getFieldValue,
+        eachField: types.eachField,
+        someField: types.someField,
+        getSupertypeNames: types.getSupertypeNames,
+        getBuilderName: types.getBuilderName,
+        astNodesAreEquivalent: fork.use(equiv_1.default),
+        finalize: types.finalize,
+        Path: fork.use(path_1.default),
+        NodePath: fork.use(node_path_1.default),
+        PathVisitor: PathVisitor,
+        use: fork.use,
+        visit: PathVisitor.visit,
+    };
+}
+exports.default = default_1;
+function createFork() {
+    var used = [];
+    var usedResult = [];
+    function use(plugin) {
+        var idx = used.indexOf(plugin);
+        if (idx === -1) {
+            idx = used.length;
+            used.push(plugin);
+            usedResult[idx] = plugin(fork);
+        }
+        return usedResult[idx];
+    }
+    var fork = { use: use };
+    return fork;
+}
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/gen/builders.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/recast/node_modules/ast-types/gen/kinds.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/recast/node_modules/ast-types/gen/namedTypes.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.namedTypes = void 0;
+var namedTypes;
+(function (namedTypes) {
+})(namedTypes = exports.namedTypes || (exports.namedTypes = {}));

node_modules/recast/node_modules/ast-types/gen/visitor.d.ts

@@ -0,0 +1,293 @@
+import { NodePath } from "../lib/node-path";
+import { Context } from "../lib/path-visitor";
+import { namedTypes } from "./namedTypes";
+export interface Visitor<M = {}> {
+    visitPrintable?(this: Context & M, path: NodePath<namedTypes.Printable>): any;
+    visitSourceLocation?(this: Context & M, path: NodePath<namedTypes.SourceLocation>): any;
+    visitNode?(this: Context & M, path: NodePath<namedTypes.Node>): any;
+    visitComment?(this: Context & M, path: NodePath<namedTypes.Comment>): any;
+    visitPosition?(this: Context & M, path: NodePath<namedTypes.Position>): any;
+    visitFile?(this: Context & M, path: NodePath<namedTypes.File>): any;
+    visitProgram?(this: Context & M, path: NodePath<namedTypes.Program>): any;
+    visitStatement?(this: Context & M, path: NodePath<namedTypes.Statement>): any;
+    visitFunction?(this: Context & M, path: NodePath<namedTypes.Function>): any;
+    visitExpression?(this: Context & M, path: NodePath<namedTypes.Expression>): any;
+    visitPattern?(this: Context & M, path: NodePath<namedTypes.Pattern>): any;
+    visitIdentifier?(this: Context & M, path: NodePath<namedTypes.Identifier>): any;
+    visitBlockStatement?(this: Context & M, path: NodePath<namedTypes.BlockStatement>): any;
+    visitEmptyStatement?(this: Context & M, path: NodePath<namedTypes.EmptyStatement>): any;
+    visitExpressionStatement?(this: Context & M, path: NodePath<namedTypes.ExpressionStatement>): any;
+    visitIfStatement?(this: Context & M, path: NodePath<namedTypes.IfStatement>): any;
+    visitLabeledStatement?(this: Context & M, path: NodePath<namedTypes.LabeledStatement>): any;
+    visitBreakStatement?(this: Context & M, path: NodePath<namedTypes.BreakStatement>): any;
+    visitContinueStatement?(this: Context & M, path: NodePath<namedTypes.ContinueStatement>): any;
+    visitWithStatement?(this: Context & M, path: NodePath<namedTypes.WithStatement>): any;
+    visitSwitchStatement?(this: Context & M, path: NodePath<namedTypes.SwitchStatement>): any;
+    visitSwitchCase?(this: Context & M, path: NodePath<namedTypes.SwitchCase>): any;
+    visitReturnStatement?(this: Context & M, path: NodePath<namedTypes.ReturnStatement>): any;
+    visitThrowStatement?(this: Context & M, path: NodePath<namedTypes.ThrowStatement>): any;
+    visitTryStatement?(this: Context & M, path: NodePath<namedTypes.TryStatement>): any;
+    visitCatchClause?(this: Context & M, path: NodePath<namedTypes.CatchClause>): any;
+    visitWhileStatement?(this: Context & M, path: NodePath<namedTypes.WhileStatement>): any;
+    visitDoWhileStatement?(this: Context & M, path: NodePath<namedTypes.DoWhileStatement>): any;
+    visitForStatement?(this: Context & M, path: NodePath<namedTypes.ForStatement>): any;
+    visitDeclaration?(this: Context & M, path: NodePath<namedTypes.Declaration>): any;
+    visitVariableDeclaration?(this: Context & M, path: NodePath<namedTypes.VariableDeclaration>): any;
+    visitForInStatement?(this: Context & M, path: NodePath<namedTypes.ForInStatement>): any;
+    visitDebuggerStatement?(this: Context & M, path: NodePath<namedTypes.DebuggerStatement>): any;
+    visitFunctionDeclaration?(this: Context & M, path: NodePath<namedTypes.FunctionDeclaration>): any;
+    visitFunctionExpression?(this: Context & M, path: NodePath<namedTypes.FunctionExpression>): any;
+    visitVariableDeclarator?(this: Context & M, path: NodePath<namedTypes.VariableDeclarator>): any;
+    visitThisExpression?(this: Context & M, path: NodePath<namedTypes.ThisExpression>): any;
+    visitArrayExpression?(this: Context & M, path: NodePath<namedTypes.ArrayExpression>): any;
+    visitObjectExpression?(this: Context & M, path: NodePath<namedTypes.ObjectExpression>): any;
+    visitProperty?(this: Context & M, path: NodePath<namedTypes.Property>): any;
+    visitLiteral?(this: Context & M, path: NodePath<namedTypes.Literal>): any;
+    visitSequenceExpression?(this: Context & M, path: NodePath<namedTypes.SequenceExpression>): any;
+    visitUnaryExpression?(this: Context & M, path: NodePath<namedTypes.UnaryExpression>): any;
+    visitBinaryExpression?(this: Context & M, path: NodePath<namedTypes.BinaryExpression>): any;
+    visitAssignmentExpression?(this: Context & M, path: NodePath<namedTypes.AssignmentExpression>): any;
+    visitChainElement?(this: Context & M, path: NodePath<namedTypes.ChainElement>): any;
+    visitMemberExpression?(this: Context & M, path: NodePath<namedTypes.MemberExpression>): any;
+    visitUpdateExpression?(this: Context & M, path: NodePath<namedTypes.UpdateExpression>): any;
+    visitLogicalExpression?(this: Context & M, path: NodePath<namedTypes.LogicalExpression>): any;
+    visitConditionalExpression?(this: Context & M, path: NodePath<namedTypes.ConditionalExpression>): any;
+    visitNewExpression?(this: Context & M, path: NodePath<namedTypes.NewExpression>): any;
+    visitCallExpression?(this: Context & M, path: NodePath<namedTypes.CallExpression>): any;
+    visitRestElement?(this: Context & M, path: NodePath<namedTypes.RestElement>): any;
+    visitTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.TypeAnnotation>): any;
+    visitTSTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.TSTypeAnnotation>): any;
+    visitSpreadElementPattern?(this: Context & M, path: NodePath<namedTypes.SpreadElementPattern>): any;
+    visitArrowFunctionExpression?(this: Context & M, path: NodePath<namedTypes.ArrowFunctionExpression>): any;
+    visitForOfStatement?(this: Context & M, path: NodePath<namedTypes.ForOfStatement>): any;
+    visitYieldExpression?(this: Context & M, path: NodePath<namedTypes.YieldExpression>): any;
+    visitGeneratorExpression?(this: Context & M, path: NodePath<namedTypes.GeneratorExpression>): any;
+    visitComprehensionBlock?(this: Context & M, path: NodePath<namedTypes.ComprehensionBlock>): any;
+    visitComprehensionExpression?(this: Context & M, path: NodePath<namedTypes.ComprehensionExpression>): any;
+    visitObjectProperty?(this: Context & M, path: NodePath<namedTypes.ObjectProperty>): any;
+    visitPropertyPattern?(this: Context & M, path: NodePath<namedTypes.PropertyPattern>): any;
+    visitObjectPattern?(this: Context & M, path: NodePath<namedTypes.ObjectPattern>): any;
+    visitArrayPattern?(this: Context & M, path: NodePath<namedTypes.ArrayPattern>): any;
+    visitSpreadElement?(this: Context & M, path: NodePath<namedTypes.SpreadElement>): any;
+    visitAssignmentPattern?(this: Context & M, path: NodePath<namedTypes.AssignmentPattern>): any;
+    visitMethodDefinition?(this: Context & M, path: NodePath<namedTypes.MethodDefinition>): any;
+    visitClassPropertyDefinition?(this: Context & M, path: NodePath<namedTypes.ClassPropertyDefinition>): any;
+    visitClassProperty?(this: Context & M, path: NodePath<namedTypes.ClassProperty>): any;
+    visitClassBody?(this: Context & M, path: NodePath<namedTypes.ClassBody>): any;
+    visitClassDeclaration?(this: Context & M, path: NodePath<namedTypes.ClassDeclaration>): any;
+    visitClassExpression?(this: Context & M, path: NodePath<namedTypes.ClassExpression>): any;
+    visitSuper?(this: Context & M, path: NodePath<namedTypes.Super>): any;
+    visitSpecifier?(this: Context & M, path: NodePath<namedTypes.Specifier>): any;
+    visitModuleSpecifier?(this: Context & M, path: NodePath<namedTypes.ModuleSpecifier>): any;
+    visitImportSpecifier?(this: Context & M, path: NodePath<namedTypes.ImportSpecifier>): any;
+    visitImportDefaultSpecifier?(this: Context & M, path: NodePath<namedTypes.ImportDefaultSpecifier>): any;
+    visitImportNamespaceSpecifier?(this: Context & M, path: NodePath<namedTypes.ImportNamespaceSpecifier>): any;
+    visitImportDeclaration?(this: Context & M, path: NodePath<namedTypes.ImportDeclaration>): any;
+    visitExportNamedDeclaration?(this: Context & M, path: NodePath<namedTypes.ExportNamedDeclaration>): any;
+    visitExportSpecifier?(this: Context & M, path: NodePath<namedTypes.ExportSpecifier>): any;
+    visitExportDefaultDeclaration?(this: Context & M, path: NodePath<namedTypes.ExportDefaultDeclaration>): any;
+    visitExportAllDeclaration?(this: Context & M, path: NodePath<namedTypes.ExportAllDeclaration>): any;
+    visitTaggedTemplateExpression?(this: Context & M, path: NodePath<namedTypes.TaggedTemplateExpression>): any;
+    visitTemplateLiteral?(this: Context & M, path: NodePath<namedTypes.TemplateLiteral>): any;
+    visitTemplateElement?(this: Context & M, path: NodePath<namedTypes.TemplateElement>): any;
+    visitMetaProperty?(this: Context & M, path: NodePath<namedTypes.MetaProperty>): any;
+    visitAwaitExpression?(this: Context & M, path: NodePath<namedTypes.AwaitExpression>): any;
+    visitSpreadProperty?(this: Context & M, path: NodePath<namedTypes.SpreadProperty>): any;
+    visitSpreadPropertyPattern?(this: Context & M, path: NodePath<namedTypes.SpreadPropertyPattern>): any;
+    visitImportExpression?(this: Context & M, path: NodePath<namedTypes.ImportExpression>): any;
+    visitChainExpression?(this: Context & M, path: NodePath<namedTypes.ChainExpression>): any;
+    visitOptionalCallExpression?(this: Context & M, path: NodePath<namedTypes.OptionalCallExpression>): any;
+    visitOptionalMemberExpression?(this: Context & M, path: NodePath<namedTypes.OptionalMemberExpression>): any;
+    visitStaticBlock?(this: Context & M, path: NodePath<namedTypes.StaticBlock>): any;
+    visitDecorator?(this: Context & M, path: NodePath<namedTypes.Decorator>): any;
+    visitPrivateName?(this: Context & M, path: NodePath<namedTypes.PrivateName>): any;
+    visitClassPrivateProperty?(this: Context & M, path: NodePath<namedTypes.ClassPrivateProperty>): any;
+    visitImportAttribute?(this: Context & M, path: NodePath<namedTypes.ImportAttribute>): any;
+    visitRecordExpression?(this: Context & M, path: NodePath<namedTypes.RecordExpression>): any;
+    visitObjectMethod?(this: Context & M, path: NodePath<namedTypes.ObjectMethod>): any;
+    visitTupleExpression?(this: Context & M, path: NodePath<namedTypes.TupleExpression>): any;
+    visitModuleExpression?(this: Context & M, path: NodePath<namedTypes.ModuleExpression>): any;
+    visitJSXAttribute?(this: Context & M, path: NodePath<namedTypes.JSXAttribute>): any;
+    visitJSXIdentifier?(this: Context & M, path: NodePath<namedTypes.JSXIdentifier>): any;
+    visitJSXNamespacedName?(this: Context & M, path: NodePath<namedTypes.JSXNamespacedName>): any;
+    visitJSXExpressionContainer?(this: Context & M, path: NodePath<namedTypes.JSXExpressionContainer>): any;
+    visitJSXElement?(this: Context & M, path: NodePath<namedTypes.JSXElement>): any;
+    visitJSXFragment?(this: Context & M, path: NodePath<namedTypes.JSXFragment>): any;
+    visitJSXMemberExpression?(this: Context & M, path: NodePath<namedTypes.JSXMemberExpression>): any;
+    visitJSXSpreadAttribute?(this: Context & M, path: NodePath<namedTypes.JSXSpreadAttribute>): any;
+    visitJSXEmptyExpression?(this: Context & M, path: NodePath<namedTypes.JSXEmptyExpression>): any;
+    visitJSXText?(this: Context & M, path: NodePath<namedTypes.JSXText>): any;
+    visitJSXSpreadChild?(this: Context & M, path: NodePath<namedTypes.JSXSpreadChild>): any;
+    visitJSXOpeningElement?(this: Context & M, path: NodePath<namedTypes.JSXOpeningElement>): any;
+    visitJSXClosingElement?(this: Context & M, path: NodePath<namedTypes.JSXClosingElement>): any;
+    visitJSXOpeningFragment?(this: Context & M, path: NodePath<namedTypes.JSXOpeningFragment>): any;
+    visitJSXClosingFragment?(this: Context & M, path: NodePath<namedTypes.JSXClosingFragment>): any;
+    visitTypeParameterDeclaration?(this: Context & M, path: NodePath<namedTypes.TypeParameterDeclaration>): any;
+    visitTSTypeParameterDeclaration?(this: Context & M, path: NodePath<namedTypes.TSTypeParameterDeclaration>): any;
+    visitTypeParameterInstantiation?(this: Context & M, path: NodePath<namedTypes.TypeParameterInstantiation>): any;
+    visitTSTypeParameterInstantiation?(this: Context & M, path: NodePath<namedTypes.TSTypeParameterInstantiation>): any;
+    visitClassImplements?(this: Context & M, path: NodePath<namedTypes.ClassImplements>): any;
+    visitTSType?(this: Context & M, path: NodePath<namedTypes.TSType>): any;
+    visitTSHasOptionalTypeParameterInstantiation?(this: Context & M, path: NodePath<namedTypes.TSHasOptionalTypeParameterInstantiation>): any;
+    visitTSExpressionWithTypeArguments?(this: Context & M, path: NodePath<namedTypes.TSExpressionWithTypeArguments>): any;
+    visitFlow?(this: Context & M, path: NodePath<namedTypes.Flow>): any;
+    visitFlowType?(this: Context & M, path: NodePath<namedTypes.FlowType>): any;
+    visitAnyTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.AnyTypeAnnotation>): any;
+    visitEmptyTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.EmptyTypeAnnotation>): any;
+    visitMixedTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.MixedTypeAnnotation>): any;
+    visitVoidTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.VoidTypeAnnotation>): any;
+    visitSymbolTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.SymbolTypeAnnotation>): any;
+    visitNumberTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.NumberTypeAnnotation>): any;
+    visitBigIntTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.BigIntTypeAnnotation>): any;
+    visitNumberLiteralTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.NumberLiteralTypeAnnotation>): any;
+    visitNumericLiteralTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.NumericLiteralTypeAnnotation>): any;
+    visitBigIntLiteralTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.BigIntLiteralTypeAnnotation>): any;
+    visitStringTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.StringTypeAnnotation>): any;
+    visitStringLiteralTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.StringLiteralTypeAnnotation>): any;
+    visitBooleanTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.BooleanTypeAnnotation>): any;
+    visitBooleanLiteralTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.BooleanLiteralTypeAnnotation>): any;
+    visitNullableTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.NullableTypeAnnotation>): any;
+    visitNullLiteralTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.NullLiteralTypeAnnotation>): any;
+    visitNullTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.NullTypeAnnotation>): any;
+    visitThisTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.ThisTypeAnnotation>): any;
+    visitExistsTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.ExistsTypeAnnotation>): any;
+    visitExistentialTypeParam?(this: Context & M, path: NodePath<namedTypes.ExistentialTypeParam>): any;
+    visitFunctionTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.FunctionTypeAnnotation>): any;
+    visitFunctionTypeParam?(this: Context & M, path: NodePath<namedTypes.FunctionTypeParam>): any;
+    visitArrayTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.ArrayTypeAnnotation>): any;
+    visitObjectTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.ObjectTypeAnnotation>): any;
+    visitObjectTypeProperty?(this: Context & M, path: NodePath<namedTypes.ObjectTypeProperty>): any;
+    visitObjectTypeSpreadProperty?(this: Context & M, path: NodePath<namedTypes.ObjectTypeSpreadProperty>): any;
+    visitObjectTypeIndexer?(this: Context & M, path: NodePath<namedTypes.ObjectTypeIndexer>): any;
+    visitObjectTypeCallProperty?(this: Context & M, path: NodePath<namedTypes.ObjectTypeCallProperty>): any;
+    visitObjectTypeInternalSlot?(this: Context & M, path: NodePath<namedTypes.ObjectTypeInternalSlot>): any;
+    visitVariance?(this: Context & M, path: NodePath<namedTypes.Variance>): any;
+    visitQualifiedTypeIdentifier?(this: Context & M, path: NodePath<namedTypes.QualifiedTypeIdentifier>): any;
+    visitGenericTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.GenericTypeAnnotation>): any;
+    visitMemberTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.MemberTypeAnnotation>): any;
+    visitIndexedAccessType?(this: Context & M, path: NodePath<namedTypes.IndexedAccessType>): any;
+    visitOptionalIndexedAccessType?(this: Context & M, path: NodePath<namedTypes.OptionalIndexedAccessType>): any;
+    visitUnionTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.UnionTypeAnnotation>): any;
+    visitIntersectionTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.IntersectionTypeAnnotation>): any;
+    visitTypeofTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.TypeofTypeAnnotation>): any;
+    visitTypeParameter?(this: Context & M, path: NodePath<namedTypes.TypeParameter>): any;
+    visitInterfaceTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.InterfaceTypeAnnotation>): any;
+    visitInterfaceExtends?(this: Context & M, path: NodePath<namedTypes.InterfaceExtends>): any;
+    visitInterfaceDeclaration?(this: Context & M, path: NodePath<namedTypes.InterfaceDeclaration>): any;
+    visitDeclareInterface?(this: Context & M, path: NodePath<namedTypes.DeclareInterface>): any;
+    visitTypeAlias?(this: Context & M, path: NodePath<namedTypes.TypeAlias>): any;
+    visitDeclareTypeAlias?(this: Context & M, path: NodePath<namedTypes.DeclareTypeAlias>): any;
+    visitOpaqueType?(this: Context & M, path: NodePath<namedTypes.OpaqueType>): any;
+    visitDeclareOpaqueType?(this: Context & M, path: NodePath<namedTypes.DeclareOpaqueType>): any;
+    visitTypeCastExpression?(this: Context & M, path: NodePath<namedTypes.TypeCastExpression>): any;
+    visitTupleTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.TupleTypeAnnotation>): any;
+    visitDeclareVariable?(this: Context & M, path: NodePath<namedTypes.DeclareVariable>): any;
+    visitDeclareFunction?(this: Context & M, path: NodePath<namedTypes.DeclareFunction>): any;
+    visitFlowPredicate?(this: Context & M, path: NodePath<namedTypes.FlowPredicate>): any;
+    visitDeclareClass?(this: Context & M, path: NodePath<namedTypes.DeclareClass>): any;
+    visitDeclareModule?(this: Context & M, path: NodePath<namedTypes.DeclareModule>): any;
+    visitDeclareModuleExports?(this: Context & M, path: NodePath<namedTypes.DeclareModuleExports>): any;
+    visitDeclareExportDeclaration?(this: Context & M, path: NodePath<namedTypes.DeclareExportDeclaration>): any;
+    visitExportBatchSpecifier?(this: Context & M, path: NodePath<namedTypes.ExportBatchSpecifier>): any;
+    visitDeclareExportAllDeclaration?(this: Context & M, path: NodePath<namedTypes.DeclareExportAllDeclaration>): any;
+    visitInferredPredicate?(this: Context & M, path: NodePath<namedTypes.InferredPredicate>): any;
+    visitDeclaredPredicate?(this: Context & M, path: NodePath<namedTypes.DeclaredPredicate>): any;
+    visitEnumDeclaration?(this: Context & M, path: NodePath<namedTypes.EnumDeclaration>): any;
+    visitEnumBooleanBody?(this: Context & M, path: NodePath<namedTypes.EnumBooleanBody>): any;
+    visitEnumNumberBody?(this: Context & M, path: NodePath<namedTypes.EnumNumberBody>): any;
+    visitEnumStringBody?(this: Context & M, path: NodePath<namedTypes.EnumStringBody>): any;
+    visitEnumSymbolBody?(this: Context & M, path: NodePath<namedTypes.EnumSymbolBody>): any;
+    visitEnumBooleanMember?(this: Context & M, path: NodePath<namedTypes.EnumBooleanMember>): any;
+    visitEnumNumberMember?(this: Context & M, path: NodePath<namedTypes.EnumNumberMember>): any;
+    visitEnumStringMember?(this: Context & M, path: NodePath<namedTypes.EnumStringMember>): any;
+    visitEnumDefaultedMember?(this: Context & M, path: NodePath<namedTypes.EnumDefaultedMember>): any;
+    visitExportDeclaration?(this: Context & M, path: NodePath<namedTypes.ExportDeclaration>): any;
+    visitBlock?(this: Context & M, path: NodePath<namedTypes.Block>): any;
+    visitLine?(this: Context & M, path: NodePath<namedTypes.Line>): any;
+    visitNoop?(this: Context & M, path: NodePath<namedTypes.Noop>): any;
+    visitDoExpression?(this: Context & M, path: NodePath<namedTypes.DoExpression>): any;
+    visitBindExpression?(this: Context & M, path: NodePath<namedTypes.BindExpression>): any;
+    visitParenthesizedExpression?(this: Context & M, path: NodePath<namedTypes.ParenthesizedExpression>): any;
+    visitExportNamespaceSpecifier?(this: Context & M, path: NodePath<namedTypes.ExportNamespaceSpecifier>): any;
+    visitExportDefaultSpecifier?(this: Context & M, path: NodePath<namedTypes.ExportDefaultSpecifier>): any;
+    visitCommentBlock?(this: Context & M, path: NodePath<namedTypes.CommentBlock>): any;
+    visitCommentLine?(this: Context & M, path: NodePath<namedTypes.CommentLine>): any;
+    visitDirective?(this: Context & M, path: NodePath<namedTypes.Directive>): any;
+    visitDirectiveLiteral?(this: Context & M, path: NodePath<namedTypes.DirectiveLiteral>): any;
+    visitInterpreterDirective?(this: Context & M, path: NodePath<namedTypes.InterpreterDirective>): any;
+    visitStringLiteral?(this: Context & M, path: NodePath<namedTypes.StringLiteral>): any;
+    visitNumericLiteral?(this: Context & M, path: NodePath<namedTypes.NumericLiteral>): any;
+    visitBigIntLiteral?(this: Context & M, path: NodePath<namedTypes.BigIntLiteral>): any;
+    visitDecimalLiteral?(this: Context & M, path: NodePath<namedTypes.DecimalLiteral>): any;
+    visitNullLiteral?(this: Context & M, path: NodePath<namedTypes.NullLiteral>): any;
+    visitBooleanLiteral?(this: Context & M, path: NodePath<namedTypes.BooleanLiteral>): any;
+    visitRegExpLiteral?(this: Context & M, path: NodePath<namedTypes.RegExpLiteral>): any;
+    visitClassMethod?(this: Context & M, path: NodePath<namedTypes.ClassMethod>): any;
+    visitClassPrivateMethod?(this: Context & M, path: NodePath<namedTypes.ClassPrivateMethod>): any;
+    visitRestProperty?(this: Context & M, path: NodePath<namedTypes.RestProperty>): any;
+    visitForAwaitStatement?(this: Context & M, path: NodePath<namedTypes.ForAwaitStatement>): any;
+    visitImport?(this: Context & M, path: NodePath<namedTypes.Import>): any;
+    visitV8IntrinsicIdentifier?(this: Context & M, path: NodePath<namedTypes.V8IntrinsicIdentifier>): any;
+    visitTopicReference?(this: Context & M, path: NodePath<namedTypes.TopicReference>): any;
+    visitTSQualifiedName?(this: Context & M, path: NodePath<namedTypes.TSQualifiedName>): any;
+    visitTSTypeReference?(this: Context & M, path: NodePath<namedTypes.TSTypeReference>): any;
+    visitTSHasOptionalTypeParameters?(this: Context & M, path: NodePath<namedTypes.TSHasOptionalTypeParameters>): any;
+    visitTSHasOptionalTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.TSHasOptionalTypeAnnotation>): any;
+    visitTSAsExpression?(this: Context & M, path: NodePath<namedTypes.TSAsExpression>): any;
+    visitTSNonNullExpression?(this: Context & M, path: NodePath<namedTypes.TSNonNullExpression>): any;
+    visitTSAnyKeyword?(this: Context & M, path: NodePath<namedTypes.TSAnyKeyword>): any;
+    visitTSBigIntKeyword?(this: Context & M, path: NodePath<namedTypes.TSBigIntKeyword>): any;
+    visitTSBooleanKeyword?(this: Context & M, path: NodePath<namedTypes.TSBooleanKeyword>): any;
+    visitTSNeverKeyword?(this: Context & M, path: NodePath<namedTypes.TSNeverKeyword>): any;
+    visitTSNullKeyword?(this: Context & M, path: NodePath<namedTypes.TSNullKeyword>): any;
+    visitTSNumberKeyword?(this: Context & M, path: NodePath<namedTypes.TSNumberKeyword>): any;
+    visitTSObjectKeyword?(this: Context & M, path: NodePath<namedTypes.TSObjectKeyword>): any;
+    visitTSStringKeyword?(this: Context & M, path: NodePath<namedTypes.TSStringKeyword>): any;
+    visitTSSymbolKeyword?(this: Context & M, path: NodePath<namedTypes.TSSymbolKeyword>): any;
+    visitTSUndefinedKeyword?(this: Context & M, path: NodePath<namedTypes.TSUndefinedKeyword>): any;
+    visitTSUnknownKeyword?(this: Context & M, path: NodePath<namedTypes.TSUnknownKeyword>): any;
+    visitTSVoidKeyword?(this: Context & M, path: NodePath<namedTypes.TSVoidKeyword>): any;
+    visitTSIntrinsicKeyword?(this: Context & M, path: NodePath<namedTypes.TSIntrinsicKeyword>): any;
+    visitTSThisType?(this: Context & M, path: NodePath<namedTypes.TSThisType>): any;
+    visitTSArrayType?(this: Context & M, path: NodePath<namedTypes.TSArrayType>): any;
+    visitTSLiteralType?(this: Context & M, path: NodePath<namedTypes.TSLiteralType>): any;
+    visitTSUnionType?(this: Context & M, path: NodePath<namedTypes.TSUnionType>): any;
+    visitTSIntersectionType?(this: Context & M, path: NodePath<namedTypes.TSIntersectionType>): any;
+    visitTSConditionalType?(this: Context & M, path: NodePath<namedTypes.TSConditionalType>): any;
+    visitTSInferType?(this: Context & M, path: NodePath<namedTypes.TSInferType>): any;
+    visitTSTypeParameter?(this: Context & M, path: NodePath<namedTypes.TSTypeParameter>): any;
+    visitTSParenthesizedType?(this: Context & M, path: NodePath<namedTypes.TSParenthesizedType>): any;
+    visitTSFunctionType?(this: Context & M, path: NodePath<namedTypes.TSFunctionType>): any;
+    visitTSConstructorType?(this: Context & M, path: NodePath<namedTypes.TSConstructorType>): any;
+    visitTSDeclareFunction?(this: Context & M, path: NodePath<namedTypes.TSDeclareFunction>): any;
+    visitTSDeclareMethod?(this: Context & M, path: NodePath<namedTypes.TSDeclareMethod>): any;
+    visitTSMappedType?(this: Context & M, path: NodePath<namedTypes.TSMappedType>): any;
+    visitTSTupleType?(this: Context & M, path: NodePath<namedTypes.TSTupleType>): any;
+    visitTSNamedTupleMember?(this: Context & M, path: NodePath<namedTypes.TSNamedTupleMember>): any;
+    visitTSRestType?(this: Context & M, path: NodePath<namedTypes.TSRestType>): any;
+    visitTSOptionalType?(this: Context & M, path: NodePath<namedTypes.TSOptionalType>): any;
+    visitTSIndexedAccessType?(this: Context & M, path: NodePath<namedTypes.TSIndexedAccessType>): any;
+    visitTSTypeOperator?(this: Context & M, path: NodePath<namedTypes.TSTypeOperator>): any;
+    visitTSIndexSignature?(this: Context & M, path: NodePath<namedTypes.TSIndexSignature>): any;
+    visitTSPropertySignature?(this: Context & M, path: NodePath<namedTypes.TSPropertySignature>): any;
+    visitTSMethodSignature?(this: Context & M, path: NodePath<namedTypes.TSMethodSignature>): any;
+    visitTSTypePredicate?(this: Context & M, path: NodePath<namedTypes.TSTypePredicate>): any;
+    visitTSCallSignatureDeclaration?(this: Context & M, path: NodePath<namedTypes.TSCallSignatureDeclaration>): any;
+    visitTSConstructSignatureDeclaration?(this: Context & M, path: NodePath<namedTypes.TSConstructSignatureDeclaration>): any;
+    visitTSEnumMember?(this: Context & M, path: NodePath<namedTypes.TSEnumMember>): any;
+    visitTSTypeQuery?(this: Context & M, path: NodePath<namedTypes.TSTypeQuery>): any;
+    visitTSImportType?(this: Context & M, path: NodePath<namedTypes.TSImportType>): any;
+    visitTSTypeLiteral?(this: Context & M, path: NodePath<namedTypes.TSTypeLiteral>): any;
+    visitTSTypeAssertion?(this: Context & M, path: NodePath<namedTypes.TSTypeAssertion>): any;
+    visitTSEnumDeclaration?(this: Context & M, path: NodePath<namedTypes.TSEnumDeclaration>): any;
+    visitTSTypeAliasDeclaration?(this: Context & M, path: NodePath<namedTypes.TSTypeAliasDeclaration>): any;
+    visitTSModuleBlock?(this: Context & M, path: NodePath<namedTypes.TSModuleBlock>): any;
+    visitTSModuleDeclaration?(this: Context & M, path: NodePath<namedTypes.TSModuleDeclaration>): any;
+    visitTSImportEqualsDeclaration?(this: Context & M, path: NodePath<namedTypes.TSImportEqualsDeclaration>): any;
+    visitTSExternalModuleReference?(this: Context & M, path: NodePath<namedTypes.TSExternalModuleReference>): any;
+    visitTSExportAssignment?(this: Context & M, path: NodePath<namedTypes.TSExportAssignment>): any;
+    visitTSNamespaceExportDeclaration?(this: Context & M, path: NodePath<namedTypes.TSNamespaceExportDeclaration>): any;
+    visitTSInterfaceBody?(this: Context & M, path: NodePath<namedTypes.TSInterfaceBody>): any;
+    visitTSInterfaceDeclaration?(this: Context & M, path: NodePath<namedTypes.TSInterfaceDeclaration>): any;
+    visitTSParameterProperty?(this: Context & M, path: NodePath<namedTypes.TSParameterProperty>): any;
+}

node_modules/recast/node_modules/ast-types/gen/visitor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/recast/node_modules/ast-types/lib/equiv.d.ts

@@ -0,0 +1,5 @@
+import { Fork } from "../types";
+export default function (fork: Fork): {
+    (a: any, b: any, problemPath?: any): boolean;
+    assert(a: any, b: any): void;
+};

node_modules/recast/node_modules/ast-types/lib/equiv.js

@@ -0,0 +1,154 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var types_1 = (0, tslib_1.__importDefault)(require("./types"));
+function default_1(fork) {
+    var types = fork.use(types_1.default);
+    var getFieldNames = types.getFieldNames;
+    var getFieldValue = types.getFieldValue;
+    var isArray = types.builtInTypes.array;
+    var isObject = types.builtInTypes.object;
+    var isDate = types.builtInTypes.Date;
+    var isRegExp = types.builtInTypes.RegExp;
+    var hasOwn = Object.prototype.hasOwnProperty;
+    function astNodesAreEquivalent(a, b, problemPath) {
+        if (isArray.check(problemPath)) {
+            problemPath.length = 0;
+        }
+        else {
+            problemPath = null;
+        }
+        return areEquivalent(a, b, problemPath);
+    }
+    astNodesAreEquivalent.assert = function (a, b) {
+        var problemPath = [];
+        if (!astNodesAreEquivalent(a, b, problemPath)) {
+            if (problemPath.length === 0) {
+                if (a !== b) {
+                    throw new Error("Nodes must be equal");
+                }
+            }
+            else {
+                throw new Error("Nodes differ in the following path: " +
+                    problemPath.map(subscriptForProperty).join(""));
+            }
+        }
+    };
+    function subscriptForProperty(property) {
+        if (/[_$a-z][_$a-z0-9]*/i.test(property)) {
+            return "." + property;
+        }
+        return "[" + JSON.stringify(property) + "]";
+    }
+    function areEquivalent(a, b, problemPath) {
+        if (a === b) {
+            return true;
+        }
+        if (isArray.check(a)) {
+            return arraysAreEquivalent(a, b, problemPath);
+        }
+        if (isObject.check(a)) {
+            return objectsAreEquivalent(a, b, problemPath);
+        }
+        if (isDate.check(a)) {
+            return isDate.check(b) && (+a === +b);
+        }
+        if (isRegExp.check(a)) {
+            return isRegExp.check(b) && (a.source === b.source &&
+                a.global === b.global &&
+                a.multiline === b.multiline &&
+                a.ignoreCase === b.ignoreCase);
+        }
+        return a == b;
+    }
+    function arraysAreEquivalent(a, b, problemPath) {
+        isArray.assert(a);
+        var aLength = a.length;
+        if (!isArray.check(b) || b.length !== aLength) {
+            if (problemPath) {
+                problemPath.push("length");
+            }
+            return false;
+        }
+        for (var i = 0; i < aLength; ++i) {
+            if (problemPath) {
+                problemPath.push(i);
+            }
+            if (i in a !== i in b) {
+                return false;
+            }
+            if (!areEquivalent(a[i], b[i], problemPath)) {
+                return false;
+            }
+            if (problemPath) {
+                var problemPathTail = problemPath.pop();
+                if (problemPathTail !== i) {
+                    throw new Error("" + problemPathTail);
+                }
+            }
+        }
+        return true;
+    }
+    function objectsAreEquivalent(a, b, problemPath) {
+        isObject.assert(a);
+        if (!isObject.check(b)) {
+            return false;
+        }
+        // Fast path for a common property of AST nodes.
+        if (a.type !== b.type) {
+            if (problemPath) {
+                problemPath.push("type");
+            }
+            return false;
+        }
+        var aNames = getFieldNames(a);
+        var aNameCount = aNames.length;
+        var bNames = getFieldNames(b);
+        var bNameCount = bNames.length;
+        if (aNameCount === bNameCount) {
+            for (var i = 0; i < aNameCount; ++i) {
+                var name = aNames[i];
+                var aChild = getFieldValue(a, name);
+                var bChild = getFieldValue(b, name);
+                if (problemPath) {
+                    problemPath.push(name);
+                }
+                if (!areEquivalent(aChild, bChild, problemPath)) {
+                    return false;
+                }
+                if (problemPath) {
+                    var problemPathTail = problemPath.pop();
+                    if (problemPathTail !== name) {
+                        throw new Error("" + problemPathTail);
+                    }
+                }
+            }
+            return true;
+        }
+        if (!problemPath) {
+            return false;
+        }
+        // Since aNameCount !== bNameCount, we need to find some name that's
+        // missing in aNames but present in bNames, or vice-versa.
+        var seenNames = Object.create(null);
+        for (i = 0; i < aNameCount; ++i) {
+            seenNames[aNames[i]] = true;
+        }
+        for (i = 0; i < bNameCount; ++i) {
+            name = bNames[i];
+            if (!hasOwn.call(seenNames, name)) {
+                problemPath.push(name);
+                return false;
+            }
+            delete seenNames[name];
+        }
+        for (name in seenNames) {
+            problemPath.push(name);
+            break;
+        }
+        return false;
+    }
+    return astNodesAreEquivalent;
+}
+exports.default = default_1;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/lib/node-path.d.ts

@@ -0,0 +1,22 @@
+import { Fork } from "../types";
+import { ASTNode } from "./types";
+import { Path } from "./path";
+import { Scope } from "./scope";
+export interface NodePath<N = any, V = any> extends Path<V> {
+    node: N;
+    parent: any;
+    scope: any;
+    replace: Path['replace'];
+    prune(...args: any[]): any;
+    _computeNode(): any;
+    _computeParent(): any;
+    _computeScope(): Scope | null;
+    getValueProperty(name: any): any;
+    needsParens(assumeExpressionContext?: boolean): boolean;
+    canBeFirstInStatement(): boolean;
+    firstInStatement(): boolean;
+}
+export interface NodePathConstructor {
+    new <N extends ASTNode = any, V = any>(value: any, parentPath?: any, name?: any): NodePath<N, V>;
+}
+export default function nodePathPlugin(fork: Fork): NodePathConstructor;

node_modules/recast/node_modules/ast-types/lib/node-path.js

@@ -0,0 +1,411 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var types_1 = (0, tslib_1.__importDefault)(require("./types"));
+var path_1 = (0, tslib_1.__importDefault)(require("./path"));
+var scope_1 = (0, tslib_1.__importDefault)(require("./scope"));
+function nodePathPlugin(fork) {
+    var types = fork.use(types_1.default);
+    var n = types.namedTypes;
+    var b = types.builders;
+    var isNumber = types.builtInTypes.number;
+    var isArray = types.builtInTypes.array;
+    var Path = fork.use(path_1.default);
+    var Scope = fork.use(scope_1.default);
+    var NodePath = function NodePath(value, parentPath, name) {
+        if (!(this instanceof NodePath)) {
+            throw new Error("NodePath constructor cannot be invoked without 'new'");
+        }
+        Path.call(this, value, parentPath, name);
+    };
+    var NPp = NodePath.prototype = Object.create(Path.prototype, {
+        constructor: {
+            value: NodePath,
+            enumerable: false,
+            writable: true,
+            configurable: true
+        }
+    });
+    Object.defineProperties(NPp, {
+        node: {
+            get: function () {
+                Object.defineProperty(this, "node", {
+                    configurable: true,
+                    value: this._computeNode()
+                });
+                return this.node;
+            }
+        },
+        parent: {
+            get: function () {
+                Object.defineProperty(this, "parent", {
+                    configurable: true,
+                    value: this._computeParent()
+                });
+                return this.parent;
+            }
+        },
+        scope: {
+            get: function () {
+                Object.defineProperty(this, "scope", {
+                    configurable: true,
+                    value: this._computeScope()
+                });
+                return this.scope;
+            }
+        }
+    });
+    NPp.replace = function () {
+        delete this.node;
+        delete this.parent;
+        delete this.scope;
+        return Path.prototype.replace.apply(this, arguments);
+    };
+    NPp.prune = function () {
+        var remainingNodePath = this.parent;
+        this.replace();
+        return cleanUpNodesAfterPrune(remainingNodePath);
+    };
+    // The value of the first ancestor Path whose value is a Node.
+    NPp._computeNode = function () {
+        var value = this.value;
+        if (n.Node.check(value)) {
+            return value;
+        }
+        var pp = this.parentPath;
+        return pp && pp.node || null;
+    };
+    // The first ancestor Path whose value is a Node distinct from this.node.
+    NPp._computeParent = function () {
+        var value = this.value;
+        var pp = this.parentPath;
+        if (!n.Node.check(value)) {
+            while (pp && !n.Node.check(pp.value)) {
+                pp = pp.parentPath;
+            }
+            if (pp) {
+                pp = pp.parentPath;
+            }
+        }
+        while (pp && !n.Node.check(pp.value)) {
+            pp = pp.parentPath;
+        }
+        return pp || null;
+    };
+    // The closest enclosing scope that governs this node.
+    NPp._computeScope = function () {
+        var value = this.value;
+        var pp = this.parentPath;
+        var scope = pp && pp.scope;
+        if (n.Node.check(value) &&
+            Scope.isEstablishedBy(value)) {
+            scope = new Scope(this, scope);
+        }
+        return scope || null;
+    };
+    NPp.getValueProperty = function (name) {
+        return types.getFieldValue(this.value, name);
+    };
+    /**
+     * Determine whether this.node needs to be wrapped in parentheses in order
+     * for a parser to reproduce the same local AST structure.
+     *
+     * For instance, in the expression `(1 + 2) * 3`, the BinaryExpression
+     * whose operator is "+" needs parentheses, because `1 + 2 * 3` would
+     * parse differently.
+     *
+     * If assumeExpressionContext === true, we don't worry about edge cases
+     * like an anonymous FunctionExpression appearing lexically first in its
+     * enclosing statement and thus needing parentheses to avoid being parsed
+     * as a FunctionDeclaration with a missing name.
+     */
+    NPp.needsParens = function (assumeExpressionContext) {
+        var pp = this.parentPath;
+        if (!pp) {
+            return false;
+        }
+        var node = this.value;
+        // Only expressions need parentheses.
+        if (!n.Expression.check(node)) {
+            return false;
+        }
+        // Identifiers never need parentheses.
+        if (node.type === "Identifier") {
+            return false;
+        }
+        while (!n.Node.check(pp.value)) {
+            pp = pp.parentPath;
+            if (!pp) {
+                return false;
+            }
+        }
+        var parent = pp.value;
+        switch (node.type) {
+            case "UnaryExpression":
+            case "SpreadElement":
+            case "SpreadProperty":
+                return parent.type === "MemberExpression"
+                    && this.name === "object"
+                    && parent.object === node;
+            case "BinaryExpression":
+            case "LogicalExpression":
+                switch (parent.type) {
+                    case "CallExpression":
+                        return this.name === "callee"
+                            && parent.callee === node;
+                    case "UnaryExpression":
+                    case "SpreadElement":
+                    case "SpreadProperty":
+                        return true;
+                    case "MemberExpression":
+                        return this.name === "object"
+                            && parent.object === node;
+                    case "BinaryExpression":
+                    case "LogicalExpression": {
+                        var n_1 = node;
+                        var po = parent.operator;
+                        var pp_1 = PRECEDENCE[po];
+                        var no = n_1.operator;
+                        var np = PRECEDENCE[no];
+                        if (pp_1 > np) {
+                            return true;
+                        }
+                        if (pp_1 === np && this.name === "right") {
+                            if (parent.right !== n_1) {
+                                throw new Error("Nodes must be equal");
+                            }
+                            return true;
+                        }
+                    }
+                    default:
+                        return false;
+                }
+            case "SequenceExpression":
+                switch (parent.type) {
+                    case "ForStatement":
+                        // Although parentheses wouldn't hurt around sequence
+                        // expressions in the head of for loops, traditional style
+                        // dictates that e.g. i++, j++ should not be wrapped with
+                        // parentheses.
+                        return false;
+                    case "ExpressionStatement":
+                        return this.name !== "expression";
+                    default:
+                        // Otherwise err on the side of overparenthesization, adding
+                        // explicit exceptions above if this proves overzealous.
+                        return true;
+                }
+            case "YieldExpression":
+                switch (parent.type) {
+                    case "BinaryExpression":
+                    case "LogicalExpression":
+                    case "UnaryExpression":
+                    case "SpreadElement":
+                    case "SpreadProperty":
+                    case "CallExpression":
+                    case "MemberExpression":
+                    case "NewExpression":
+                    case "ConditionalExpression":
+                    case "YieldExpression":
+                        return true;
+                    default:
+                        return false;
+                }
+            case "Literal":
+                return parent.type === "MemberExpression"
+                    && isNumber.check(node.value)
+                    && this.name === "object"
+                    && parent.object === node;
+            case "AssignmentExpression":
+            case "ConditionalExpression":
+                switch (parent.type) {
+                    case "UnaryExpression":
+                    case "SpreadElement":
+                    case "SpreadProperty":
+                    case "BinaryExpression":
+                    case "LogicalExpression":
+                        return true;
+                    case "CallExpression":
+                        return this.name === "callee"
+                            && parent.callee === node;
+                    case "ConditionalExpression":
+                        return this.name === "test"
+                            && parent.test === node;
+                    case "MemberExpression":
+                        return this.name === "object"
+                            && parent.object === node;
+                    default:
+                        return false;
+                }
+            default:
+                if (parent.type === "NewExpression" &&
+                    this.name === "callee" &&
+                    parent.callee === node) {
+                    return containsCallExpression(node);
+                }
+        }
+        if (assumeExpressionContext !== true &&
+            !this.canBeFirstInStatement() &&
+            this.firstInStatement())
+            return true;
+        return false;
+    };
+    function isBinary(node) {
+        return n.BinaryExpression.check(node)
+            || n.LogicalExpression.check(node);
+    }
+    // @ts-ignore 'isUnaryLike' is declared but its value is never read. [6133]
+    function isUnaryLike(node) {
+        return n.UnaryExpression.check(node)
+            // I considered making SpreadElement and SpreadProperty subtypes
+            // of UnaryExpression, but they're not really Expression nodes.
+            || (n.SpreadElement && n.SpreadElement.check(node))
+            || (n.SpreadProperty && n.SpreadProperty.check(node));
+    }
+    var PRECEDENCE = {};
+    [["||"],
+        ["&&"],
+        ["|"],
+        ["^"],
+        ["&"],
+        ["==", "===", "!=", "!=="],
+        ["<", ">", "<=", ">=", "in", "instanceof"],
+        [">>", "<<", ">>>"],
+        ["+", "-"],
+        ["*", "/", "%"]
+    ].forEach(function (tier, i) {
+        tier.forEach(function (op) {
+            PRECEDENCE[op] = i;
+        });
+    });
+    function containsCallExpression(node) {
+        if (n.CallExpression.check(node)) {
+            return true;
+        }
+        if (isArray.check(node)) {
+            return node.some(containsCallExpression);
+        }
+        if (n.Node.check(node)) {
+            return types.someField(node, function (_name, child) {
+                return containsCallExpression(child);
+            });
+        }
+        return false;
+    }
+    NPp.canBeFirstInStatement = function () {
+        var node = this.node;
+        return !n.FunctionExpression.check(node)
+            && !n.ObjectExpression.check(node);
+    };
+    NPp.firstInStatement = function () {
+        return firstInStatement(this);
+    };
+    function firstInStatement(path) {
+        for (var node, parent; path.parent; path = path.parent) {
+            node = path.node;
+            parent = path.parent.node;
+            if (n.BlockStatement.check(parent) &&
+                path.parent.name === "body" &&
+                path.name === 0) {
+                if (parent.body[0] !== node) {
+                    throw new Error("Nodes must be equal");
+                }
+                return true;
+            }
+            if (n.ExpressionStatement.check(parent) &&
+                path.name === "expression") {
+                if (parent.expression !== node) {
+                    throw new Error("Nodes must be equal");
+                }
+                return true;
+            }
+            if (n.SequenceExpression.check(parent) &&
+                path.parent.name === "expressions" &&
+                path.name === 0) {
+                if (parent.expressions[0] !== node) {
+                    throw new Error("Nodes must be equal");
+                }
+                continue;
+            }
+            if (n.CallExpression.check(parent) &&
+                path.name === "callee") {
+                if (parent.callee !== node) {
+                    throw new Error("Nodes must be equal");
+                }
+                continue;
+            }
+            if (n.MemberExpression.check(parent) &&
+                path.name === "object") {
+                if (parent.object !== node) {
+                    throw new Error("Nodes must be equal");
+                }
+                continue;
+            }
+            if (n.ConditionalExpression.check(parent) &&
+                path.name === "test") {
+                if (parent.test !== node) {
+                    throw new Error("Nodes must be equal");
+                }
+                continue;
+            }
+            if (isBinary(parent) &&
+                path.name === "left") {
+                if (parent.left !== node) {
+                    throw new Error("Nodes must be equal");
+                }
+                continue;
+            }
+            if (n.UnaryExpression.check(parent) &&
+                !parent.prefix &&
+                path.name === "argument") {
+                if (parent.argument !== node) {
+                    throw new Error("Nodes must be equal");
+                }
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Pruning certain nodes will result in empty or incomplete nodes, here we clean those nodes up.
+     */
+    function cleanUpNodesAfterPrune(remainingNodePath) {
+        if (n.VariableDeclaration.check(remainingNodePath.node)) {
+            var declarations = remainingNodePath.get('declarations').value;
+            if (!declarations || declarations.length === 0) {
+                return remainingNodePath.prune();
+            }
+        }
+        else if (n.ExpressionStatement.check(remainingNodePath.node)) {
+            if (!remainingNodePath.get('expression').value) {
+                return remainingNodePath.prune();
+            }
+        }
+        else if (n.IfStatement.check(remainingNodePath.node)) {
+            cleanUpIfStatementAfterPrune(remainingNodePath);
+        }
+        return remainingNodePath;
+    }
+    function cleanUpIfStatementAfterPrune(ifStatement) {
+        var testExpression = ifStatement.get('test').value;
+        var alternate = ifStatement.get('alternate').value;
+        var consequent = ifStatement.get('consequent').value;
+        if (!consequent && !alternate) {
+            var testExpressionStatement = b.expressionStatement(testExpression);
+            ifStatement.replace(testExpressionStatement);
+        }
+        else if (!consequent && alternate) {
+            var negatedTestExpression = b.unaryExpression('!', testExpression, true);
+            if (n.UnaryExpression.check(testExpression) && testExpression.operator === '!') {
+                negatedTestExpression = testExpression.argument;
+            }
+            ifStatement.get("test").replace(negatedTestExpression);
+            ifStatement.get("consequent").replace(alternate);
+            ifStatement.get("alternate").replace();
+        }
+    }
+    return NodePath;
+}
+exports.default = nodePathPlugin;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/lib/path-visitor.d.ts

@@ -0,0 +1,52 @@
+import { Fork, Omit } from "../types";
+import { ASTNode } from "./types";
+import { NodePath } from "./node-path";
+export interface PathVisitor {
+    _reusableContextStack: any;
+    _methodNameTable: any;
+    _shouldVisitComments: any;
+    Context: any;
+    _visiting: any;
+    _changeReported: any;
+    _abortRequested: boolean;
+    visit(...args: any[]): any;
+    reset(...args: any[]): any;
+    visitWithoutReset(path: any): any;
+    AbortRequest: any;
+    abort(): void;
+    visitor: any;
+    acquireContext(path: any): any;
+    releaseContext(context: any): void;
+    reportChanged(): void;
+    wasChangeReported(): any;
+}
+export interface PathVisitorStatics {
+    fromMethodsObject(methods?: any): Visitor;
+    visit<M = {}>(node: ASTNode, methods?: import("../gen/visitor").Visitor<M>): any;
+}
+export interface PathVisitorConstructor extends PathVisitorStatics {
+    new (): PathVisitor;
+}
+export interface Visitor extends PathVisitor {
+}
+export interface VisitorConstructor extends PathVisitorStatics {
+    new (): Visitor;
+}
+export interface VisitorMethods {
+    [visitorMethod: string]: (path: NodePath) => any;
+}
+export interface SharedContextMethods {
+    currentPath: any;
+    needToCallTraverse: boolean;
+    Context: any;
+    visitor: any;
+    reset(path: any, ...args: any[]): any;
+    invokeVisitorMethod(methodName: string): any;
+    traverse(path: any, newVisitor?: VisitorMethods): any;
+    visit(path: any, newVisitor?: VisitorMethods): any;
+    reportChanged(): void;
+    abort(): void;
+}
+export interface Context extends Omit<PathVisitor, "visit" | "reset">, SharedContextMethods {
+}
+export default function pathVisitorPlugin(fork: Fork): PathVisitorConstructor;

node_modules/recast/node_modules/ast-types/lib/path-visitor.js

@@ -0,0 +1,343 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var types_1 = (0, tslib_1.__importDefault)(require("./types"));
+var node_path_1 = (0, tslib_1.__importDefault)(require("./node-path"));
+var hasOwn = Object.prototype.hasOwnProperty;
+function pathVisitorPlugin(fork) {
+    var types = fork.use(types_1.default);
+    var NodePath = fork.use(node_path_1.default);
+    var isArray = types.builtInTypes.array;
+    var isObject = types.builtInTypes.object;
+    var isFunction = types.builtInTypes.function;
+    var undefined;
+    var PathVisitor = function PathVisitor() {
+        if (!(this instanceof PathVisitor)) {
+            throw new Error("PathVisitor constructor cannot be invoked without 'new'");
+        }
+        // Permanent state.
+        this._reusableContextStack = [];
+        this._methodNameTable = computeMethodNameTable(this);
+        this._shouldVisitComments =
+            hasOwn.call(this._methodNameTable, "Block") ||
+                hasOwn.call(this._methodNameTable, "Line");
+        this.Context = makeContextConstructor(this);
+        // State reset every time PathVisitor.prototype.visit is called.
+        this._visiting = false;
+        this._changeReported = false;
+    };
+    function computeMethodNameTable(visitor) {
+        var typeNames = Object.create(null);
+        for (var methodName in visitor) {
+            if (/^visit[A-Z]/.test(methodName)) {
+                typeNames[methodName.slice("visit".length)] = true;
+            }
+        }
+        var supertypeTable = types.computeSupertypeLookupTable(typeNames);
+        var methodNameTable = Object.create(null);
+        var typeNameKeys = Object.keys(supertypeTable);
+        var typeNameCount = typeNameKeys.length;
+        for (var i = 0; i < typeNameCount; ++i) {
+            var typeName = typeNameKeys[i];
+            methodName = "visit" + supertypeTable[typeName];
+            if (isFunction.check(visitor[methodName])) {
+                methodNameTable[typeName] = methodName;
+            }
+        }
+        return methodNameTable;
+    }
+    PathVisitor.fromMethodsObject = function fromMethodsObject(methods) {
+        if (methods instanceof PathVisitor) {
+            return methods;
+        }
+        if (!isObject.check(methods)) {
+            // An empty visitor?
+            return new PathVisitor;
+        }
+        var Visitor = function Visitor() {
+            if (!(this instanceof Visitor)) {
+                throw new Error("Visitor constructor cannot be invoked without 'new'");
+            }
+            PathVisitor.call(this);
+        };
+        var Vp = Visitor.prototype = Object.create(PVp);
+        Vp.constructor = Visitor;
+        extend(Vp, methods);
+        extend(Visitor, PathVisitor);
+        isFunction.assert(Visitor.fromMethodsObject);
+        isFunction.assert(Visitor.visit);
+        return new Visitor;
+    };
+    function extend(target, source) {
+        for (var property in source) {
+            if (hasOwn.call(source, property)) {
+                target[property] = source[property];
+            }
+        }
+        return target;
+    }
+    PathVisitor.visit = function visit(node, methods) {
+        return PathVisitor.fromMethodsObject(methods).visit(node);
+    };
+    var PVp = PathVisitor.prototype;
+    PVp.visit = function () {
+        if (this._visiting) {
+            throw new Error("Recursively calling visitor.visit(path) resets visitor state. " +
+                "Try this.visit(path) or this.traverse(path) instead.");
+        }
+        // Private state that needs to be reset before every traversal.
+        this._visiting = true;
+        this._changeReported = false;
+        this._abortRequested = false;
+        var argc = arguments.length;
+        var args = new Array(argc);
+        for (var i = 0; i < argc; ++i) {
+            args[i] = arguments[i];
+        }
+        if (!(args[0] instanceof NodePath)) {
+            args[0] = new NodePath({ root: args[0] }).get("root");
+        }
+        // Called with the same arguments as .visit.
+        this.reset.apply(this, args);
+        var didNotThrow;
+        try {
+            var root = this.visitWithoutReset(args[0]);
+            didNotThrow = true;
+        }
+        finally {
+            this._visiting = false;
+            if (!didNotThrow && this._abortRequested) {
+                // If this.visitWithoutReset threw an exception and
+                // this._abortRequested was set to true, return the root of
+                // the AST instead of letting the exception propagate, so that
+                // client code does not have to provide a try-catch block to
+                // intercept the AbortRequest exception.  Other kinds of
+                // exceptions will propagate without being intercepted and
+                // rethrown by a catch block, so their stacks will accurately
+                // reflect the original throwing context.
+                return args[0].value;
+            }
+        }
+        return root;
+    };
+    PVp.AbortRequest = function AbortRequest() { };
+    PVp.abort = function () {
+        var visitor = this;
+        visitor._abortRequested = true;
+        var request = new visitor.AbortRequest();
+        // If you decide to catch this exception and stop it from propagating,
+        // make sure to call its cancel method to avoid silencing other
+        // exceptions that might be thrown later in the traversal.
+        request.cancel = function () {
+            visitor._abortRequested = false;
+        };
+        throw request;
+    };
+    PVp.reset = function (_path /*, additional arguments */) {
+        // Empty stub; may be reassigned or overridden by subclasses.
+    };
+    PVp.visitWithoutReset = function (path) {
+        if (this instanceof this.Context) {
+            // Since this.Context.prototype === this, there's a chance we
+            // might accidentally call context.visitWithoutReset. If that
+            // happens, re-invoke the method against context.visitor.
+            return this.visitor.visitWithoutReset(path);
+        }
+        if (!(path instanceof NodePath)) {
+            throw new Error("");
+        }
+        var value = path.value;
+        var methodName = value &&
+            typeof value === "object" &&
+            typeof value.type === "string" &&
+            this._methodNameTable[value.type];
+        if (methodName) {
+            var context = this.acquireContext(path);
+            try {
+                return context.invokeVisitorMethod(methodName);
+            }
+            finally {
+                this.releaseContext(context);
+            }
+        }
+        else {
+            // If there was no visitor method to call, visit the children of
+            // this node generically.
+            return visitChildren(path, this);
+        }
+    };
+    function visitChildren(path, visitor) {
+        if (!(path instanceof NodePath)) {
+            throw new Error("");
+        }
+        if (!(visitor instanceof PathVisitor)) {
+            throw new Error("");
+        }
+        var value = path.value;
+        if (isArray.check(value)) {
+            path.each(visitor.visitWithoutReset, visitor);
+        }
+        else if (!isObject.check(value)) {
+            // No children to visit.
+        }
+        else {
+            var childNames = types.getFieldNames(value);
+            // The .comments field of the Node type is hidden, so we only
+            // visit it if the visitor defines visitBlock or visitLine, and
+            // value.comments is defined.
+            if (visitor._shouldVisitComments &&
+                value.comments &&
+                childNames.indexOf("comments") < 0) {
+                childNames.push("comments");
+            }
+            var childCount = childNames.length;
+            var childPaths = [];
+            for (var i = 0; i < childCount; ++i) {
+                var childName = childNames[i];
+                if (!hasOwn.call(value, childName)) {
+                    value[childName] = types.getFieldValue(value, childName);
+                }
+                childPaths.push(path.get(childName));
+            }
+            for (var i = 0; i < childCount; ++i) {
+                visitor.visitWithoutReset(childPaths[i]);
+            }
+        }
+        return path.value;
+    }
+    PVp.acquireContext = function (path) {
+        if (this._reusableContextStack.length === 0) {
+            return new this.Context(path);
+        }
+        return this._reusableContextStack.pop().reset(path);
+    };
+    PVp.releaseContext = function (context) {
+        if (!(context instanceof this.Context)) {
+            throw new Error("");
+        }
+        this._reusableContextStack.push(context);
+        context.currentPath = null;
+    };
+    PVp.reportChanged = function () {
+        this._changeReported = true;
+    };
+    PVp.wasChangeReported = function () {
+        return this._changeReported;
+    };
+    function makeContextConstructor(visitor) {
+        function Context(path) {
+            if (!(this instanceof Context)) {
+                throw new Error("");
+            }
+            if (!(this instanceof PathVisitor)) {
+                throw new Error("");
+            }
+            if (!(path instanceof NodePath)) {
+                throw new Error("");
+            }
+            Object.defineProperty(this, "visitor", {
+                value: visitor,
+                writable: false,
+                enumerable: true,
+                configurable: false
+            });
+            this.currentPath = path;
+            this.needToCallTraverse = true;
+            Object.seal(this);
+        }
+        if (!(visitor instanceof PathVisitor)) {
+            throw new Error("");
+        }
+        // Note that the visitor object is the prototype of Context.prototype,
+        // so all visitor methods are inherited by context objects.
+        var Cp = Context.prototype = Object.create(visitor);
+        Cp.constructor = Context;
+        extend(Cp, sharedContextProtoMethods);
+        return Context;
+    }
+    // Every PathVisitor has a different this.Context constructor and
+    // this.Context.prototype object, but those prototypes can all use the
+    // same reset, invokeVisitorMethod, and traverse function objects.
+    var sharedContextProtoMethods = Object.create(null);
+    sharedContextProtoMethods.reset =
+        function reset(path) {
+            if (!(this instanceof this.Context)) {
+                throw new Error("");
+            }
+            if (!(path instanceof NodePath)) {
+                throw new Error("");
+            }
+            this.currentPath = path;
+            this.needToCallTraverse = true;
+            return this;
+        };
+    sharedContextProtoMethods.invokeVisitorMethod =
+        function invokeVisitorMethod(methodName) {
+            if (!(this instanceof this.Context)) {
+                throw new Error("");
+            }
+            if (!(this.currentPath instanceof NodePath)) {
+                throw new Error("");
+            }
+            var result = this.visitor[methodName].call(this, this.currentPath);
+            if (result === false) {
+                // Visitor methods return false to indicate that they have handled
+                // their own traversal needs, and we should not complain if
+                // this.needToCallTraverse is still true.
+                this.needToCallTraverse = false;
+            }
+            else if (result !== undefined) {
+                // Any other non-undefined value returned from the visitor method
+                // is interpreted as a replacement value.
+                this.currentPath = this.currentPath.replace(result)[0];
+                if (this.needToCallTraverse) {
+                    // If this.traverse still hasn't been called, visit the
+                    // children of the replacement node.
+                    this.traverse(this.currentPath);
+                }
+            }
+            if (this.needToCallTraverse !== false) {
+                throw new Error("Must either call this.traverse or return false in " + methodName);
+            }
+            var path = this.currentPath;
+            return path && path.value;
+        };
+    sharedContextProtoMethods.traverse =
+        function traverse(path, newVisitor) {
+            if (!(this instanceof this.Context)) {
+                throw new Error("");
+            }
+            if (!(path instanceof NodePath)) {
+                throw new Error("");
+            }
+            if (!(this.currentPath instanceof NodePath)) {
+                throw new Error("");
+            }
+            this.needToCallTraverse = false;
+            return visitChildren(path, PathVisitor.fromMethodsObject(newVisitor || this.visitor));
+        };
+    sharedContextProtoMethods.visit =
+        function visit(path, newVisitor) {
+            if (!(this instanceof this.Context)) {
+                throw new Error("");
+            }
+            if (!(path instanceof NodePath)) {
+                throw new Error("");
+            }
+            if (!(this.currentPath instanceof NodePath)) {
+                throw new Error("");
+            }
+            this.needToCallTraverse = false;
+            return PathVisitor.fromMethodsObject(newVisitor || this.visitor).visitWithoutReset(path);
+        };
+    sharedContextProtoMethods.reportChanged = function reportChanged() {
+        this.visitor.reportChanged();
+    };
+    sharedContextProtoMethods.abort = function abort() {
+        this.needToCallTraverse = false;
+        this.visitor.abort();
+    };
+    return PathVisitor;
+}
+exports.default = pathVisitorPlugin;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/lib/path.d.ts

@@ -0,0 +1,25 @@
+import { Fork } from "../types";
+import { ASTNode } from "./types";
+export interface Path<V = any> {
+    value: V;
+    parentPath: any;
+    name: any;
+    __childCache: object | null;
+    getValueProperty(name: any): any;
+    get(...names: any[]): any;
+    each(callback: any, context?: any): any;
+    map(callback: any, context?: any): any;
+    filter(callback: any, context?: any): any;
+    shift(): any;
+    unshift(...args: any[]): any;
+    push(...args: any[]): any;
+    pop(): any;
+    insertAt(index: number, ...args: any[]): any;
+    insertBefore(...args: any[]): any;
+    insertAfter(...args: any[]): any;
+    replace(replacement?: ASTNode, ...args: ASTNode[]): any;
+}
+export interface PathConstructor {
+    new <V = any>(value: any, parentPath?: any, name?: any): Path<V>;
+}
+export default function pathPlugin(fork: Fork): PathConstructor;

node_modules/recast/node_modules/ast-types/lib/path.js

@@ -0,0 +1,331 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var types_1 = (0, tslib_1.__importDefault)(require("./types"));
+var Op = Object.prototype;
+var hasOwn = Op.hasOwnProperty;
+function pathPlugin(fork) {
+    var types = fork.use(types_1.default);
+    var isArray = types.builtInTypes.array;
+    var isNumber = types.builtInTypes.number;
+    var Path = function Path(value, parentPath, name) {
+        if (!(this instanceof Path)) {
+            throw new Error("Path constructor cannot be invoked without 'new'");
+        }
+        if (parentPath) {
+            if (!(parentPath instanceof Path)) {
+                throw new Error("");
+            }
+        }
+        else {
+            parentPath = null;
+            name = null;
+        }
+        // The value encapsulated by this Path, generally equal to
+        // parentPath.value[name] if we have a parentPath.
+        this.value = value;
+        // The immediate parent Path of this Path.
+        this.parentPath = parentPath;
+        // The name of the property of parentPath.value through which this
+        // Path's value was reached.
+        this.name = name;
+        // Calling path.get("child") multiple times always returns the same
+        // child Path object, for both performance and consistency reasons.
+        this.__childCache = null;
+    };
+    var Pp = Path.prototype;
+    function getChildCache(path) {
+        // Lazily create the child cache. This also cheapens cache
+        // invalidation, since you can just reset path.__childCache to null.
+        return path.__childCache || (path.__childCache = Object.create(null));
+    }
+    function getChildPath(path, name) {
+        var cache = getChildCache(path);
+        var actualChildValue = path.getValueProperty(name);
+        var childPath = cache[name];
+        if (!hasOwn.call(cache, name) ||
+            // Ensure consistency between cache and reality.
+            childPath.value !== actualChildValue) {
+            childPath = cache[name] = new path.constructor(actualChildValue, path, name);
+        }
+        return childPath;
+    }
+    // This method is designed to be overridden by subclasses that need to
+    // handle missing properties, etc.
+    Pp.getValueProperty = function getValueProperty(name) {
+        return this.value[name];
+    };
+    Pp.get = function get() {
+        var names = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            names[_i] = arguments[_i];
+        }
+        var path = this;
+        var count = names.length;
+        for (var i = 0; i < count; ++i) {
+            path = getChildPath(path, names[i]);
+        }
+        return path;
+    };
+    Pp.each = function each(callback, context) {
+        var childPaths = [];
+        var len = this.value.length;
+        var i = 0;
+        // Collect all the original child paths before invoking the callback.
+        for (var i = 0; i < len; ++i) {
+            if (hasOwn.call(this.value, i)) {
+                childPaths[i] = this.get(i);
+            }
+        }
+        // Invoke the callback on just the original child paths, regardless of
+        // any modifications made to the array by the callback. I chose these
+        // semantics over cleverly invoking the callback on new elements because
+        // this way is much easier to reason about.
+        context = context || this;
+        for (i = 0; i < len; ++i) {
+            if (hasOwn.call(childPaths, i)) {
+                callback.call(context, childPaths[i]);
+            }
+        }
+    };
+    Pp.map = function map(callback, context) {
+        var result = [];
+        this.each(function (childPath) {
+            result.push(callback.call(this, childPath));
+        }, context);
+        return result;
+    };
+    Pp.filter = function filter(callback, context) {
+        var result = [];
+        this.each(function (childPath) {
+            if (callback.call(this, childPath)) {
+                result.push(childPath);
+            }
+        }, context);
+        return result;
+    };
+    function emptyMoves() { }
+    function getMoves(path, offset, start, end) {
+        isArray.assert(path.value);
+        if (offset === 0) {
+            return emptyMoves;
+        }
+        var length = path.value.length;
+        if (length < 1) {
+            return emptyMoves;
+        }
+        var argc = arguments.length;
+        if (argc === 2) {
+            start = 0;
+            end = length;
+        }
+        else if (argc === 3) {
+            start = Math.max(start, 0);
+            end = length;
+        }
+        else {
+            start = Math.max(start, 0);
+            end = Math.min(end, length);
+        }
+        isNumber.assert(start);
+        isNumber.assert(end);
+        var moves = Object.create(null);
+        var cache = getChildCache(path);
+        for (var i = start; i < end; ++i) {
+            if (hasOwn.call(path.value, i)) {
+                var childPath = path.get(i);
+                if (childPath.name !== i) {
+                    throw new Error("");
+                }
+                var newIndex = i + offset;
+                childPath.name = newIndex;
+                moves[newIndex] = childPath;
+                delete cache[i];
+            }
+        }
+        delete cache.length;
+        return function () {
+            for (var newIndex in moves) {
+                var childPath = moves[newIndex];
+                if (childPath.name !== +newIndex) {
+                    throw new Error("");
+                }
+                cache[newIndex] = childPath;
+                path.value[newIndex] = childPath.value;
+            }
+        };
+    }
+    Pp.shift = function shift() {
+        var move = getMoves(this, -1);
+        var result = this.value.shift();
+        move();
+        return result;
+    };
+    Pp.unshift = function unshift() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var move = getMoves(this, args.length);
+        var result = this.value.unshift.apply(this.value, args);
+        move();
+        return result;
+    };
+    Pp.push = function push() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        isArray.assert(this.value);
+        delete getChildCache(this).length;
+        return this.value.push.apply(this.value, args);
+    };
+    Pp.pop = function pop() {
+        isArray.assert(this.value);
+        var cache = getChildCache(this);
+        delete cache[this.value.length - 1];
+        delete cache.length;
+        return this.value.pop();
+    };
+    Pp.insertAt = function insertAt(index) {
+        var argc = arguments.length;
+        var move = getMoves(this, argc - 1, index);
+        if (move === emptyMoves && argc <= 1) {
+            return this;
+        }
+        index = Math.max(index, 0);
+        for (var i = 1; i < argc; ++i) {
+            this.value[index + i - 1] = arguments[i];
+        }
+        move();
+        return this;
+    };
+    Pp.insertBefore = function insertBefore() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var pp = this.parentPath;
+        var argc = args.length;
+        var insertAtArgs = [this.name];
+        for (var i = 0; i < argc; ++i) {
+            insertAtArgs.push(args[i]);
+        }
+        return pp.insertAt.apply(pp, insertAtArgs);
+    };
+    Pp.insertAfter = function insertAfter() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var pp = this.parentPath;
+        var argc = args.length;
+        var insertAtArgs = [this.name + 1];
+        for (var i = 0; i < argc; ++i) {
+            insertAtArgs.push(args[i]);
+        }
+        return pp.insertAt.apply(pp, insertAtArgs);
+    };
+    function repairRelationshipWithParent(path) {
+        if (!(path instanceof Path)) {
+            throw new Error("");
+        }
+        var pp = path.parentPath;
+        if (!pp) {
+            // Orphan paths have no relationship to repair.
+            return path;
+        }
+        var parentValue = pp.value;
+        var parentCache = getChildCache(pp);
+        // Make sure parentCache[path.name] is populated.
+        if (parentValue[path.name] === path.value) {
+            parentCache[path.name] = path;
+        }
+        else if (isArray.check(parentValue)) {
+            // Something caused path.name to become out of date, so attempt to
+            // recover by searching for path.value in parentValue.
+            var i = parentValue.indexOf(path.value);
+            if (i >= 0) {
+                parentCache[path.name = i] = path;
+            }
+        }
+        else {
+            // If path.value disagrees with parentValue[path.name], and
+            // path.name is not an array index, let path.value become the new
+            // parentValue[path.name] and update parentCache accordingly.
+            parentValue[path.name] = path.value;
+            parentCache[path.name] = path;
+        }
+        if (parentValue[path.name] !== path.value) {
+            throw new Error("");
+        }
+        if (path.parentPath.get(path.name) !== path) {
+            throw new Error("");
+        }
+        return path;
+    }
+    Pp.replace = function replace(replacement) {
+        var results = [];
+        var parentValue = this.parentPath.value;
+        var parentCache = getChildCache(this.parentPath);
+        var count = arguments.length;
+        repairRelationshipWithParent(this);
+        if (isArray.check(parentValue)) {
+            var originalLength = parentValue.length;
+            var move = getMoves(this.parentPath, count - 1, this.name + 1);
+            var spliceArgs = [this.name, 1];
+            for (var i = 0; i < count; ++i) {
+                spliceArgs.push(arguments[i]);
+            }
+            var splicedOut = parentValue.splice.apply(parentValue, spliceArgs);
+            if (splicedOut[0] !== this.value) {
+                throw new Error("");
+            }
+            if (parentValue.length !== (originalLength - 1 + count)) {
+                throw new Error("");
+            }
+            move();
+            if (count === 0) {
+                delete this.value;
+                delete parentCache[this.name];
+                this.__childCache = null;
+            }
+            else {
+                if (parentValue[this.name] !== replacement) {
+                    throw new Error("");
+                }
+                if (this.value !== replacement) {
+                    this.value = replacement;
+                    this.__childCache = null;
+                }
+                for (i = 0; i < count; ++i) {
+                    results.push(this.parentPath.get(this.name + i));
+                }
+                if (results[0] !== this) {
+                    throw new Error("");
+                }
+            }
+        }
+        else if (count === 1) {
+            if (this.value !== replacement) {
+                this.__childCache = null;
+            }
+            this.value = parentValue[this.name] = replacement;
+            results.push(this);
+        }
+        else if (count === 0) {
+            delete parentValue[this.name];
+            delete this.value;
+            this.__childCache = null;
+            // Leave this path cached as parentCache[this.name], even though
+            // it no longer has a value defined.
+        }
+        else {
+            throw new Error("Could not replace path");
+        }
+        return results;
+    };
+    return Path;
+}
+exports.default = pathPlugin;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/lib/scope.d.ts

@@ -0,0 +1,27 @@
+import { Fork } from "../types";
+import { NodePath } from "./node-path";
+export interface Scope {
+    path: NodePath;
+    node: any;
+    isGlobal: boolean;
+    depth: number;
+    parent: any;
+    bindings: any;
+    types: any;
+    didScan: boolean;
+    declares(name: any): any;
+    declaresType(name: any): any;
+    declareTemporary(prefix?: any): any;
+    injectTemporary(identifier: any, init: any): any;
+    scan(force?: any): any;
+    getBindings(): any;
+    getTypes(): any;
+    lookup(name: any): any;
+    lookupType(name: any): any;
+    getGlobalScope(): Scope;
+}
+export interface ScopeConstructor {
+    new (path: NodePath, parentScope: any): Scope;
+    isEstablishedBy(node: any): any;
+}
+export default function scopePlugin(fork: Fork): ScopeConstructor;

node_modules/recast/node_modules/ast-types/lib/scope.js

@@ -0,0 +1,355 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var types_1 = (0, tslib_1.__importDefault)(require("./types"));
+var hasOwn = Object.prototype.hasOwnProperty;
+function scopePlugin(fork) {
+    var types = fork.use(types_1.default);
+    var Type = types.Type;
+    var namedTypes = types.namedTypes;
+    var Node = namedTypes.Node;
+    var Expression = namedTypes.Expression;
+    var isArray = types.builtInTypes.array;
+    var b = types.builders;
+    var Scope = function Scope(path, parentScope) {
+        if (!(this instanceof Scope)) {
+            throw new Error("Scope constructor cannot be invoked without 'new'");
+        }
+        if (!TypeParameterScopeType.check(path.value)) {
+            ScopeType.assert(path.value);
+        }
+        var depth;
+        if (parentScope) {
+            if (!(parentScope instanceof Scope)) {
+                throw new Error("");
+            }
+            depth = parentScope.depth + 1;
+        }
+        else {
+            parentScope = null;
+            depth = 0;
+        }
+        Object.defineProperties(this, {
+            path: { value: path },
+            node: { value: path.value },
+            isGlobal: { value: !parentScope, enumerable: true },
+            depth: { value: depth },
+            parent: { value: parentScope },
+            bindings: { value: {} },
+            types: { value: {} },
+        });
+    };
+    var ScopeType = Type.or(
+    // Program nodes introduce global scopes.
+    namedTypes.Program, 
+    // Function is the supertype of FunctionExpression,
+    // FunctionDeclaration, ArrowExpression, etc.
+    namedTypes.Function, 
+    // In case you didn't know, the caught parameter shadows any variable
+    // of the same name in an outer scope.
+    namedTypes.CatchClause);
+    // These types introduce scopes that are restricted to type parameters in
+    // Flow (this doesn't apply to ECMAScript).
+    var TypeParameterScopeType = Type.or(namedTypes.Function, namedTypes.ClassDeclaration, namedTypes.ClassExpression, namedTypes.InterfaceDeclaration, namedTypes.TSInterfaceDeclaration, namedTypes.TypeAlias, namedTypes.TSTypeAliasDeclaration);
+    var FlowOrTSTypeParameterType = Type.or(namedTypes.TypeParameter, namedTypes.TSTypeParameter);
+    Scope.isEstablishedBy = function (node) {
+        return ScopeType.check(node) || TypeParameterScopeType.check(node);
+    };
+    var Sp = Scope.prototype;
+    // Will be overridden after an instance lazily calls scanScope.
+    Sp.didScan = false;
+    Sp.declares = function (name) {
+        this.scan();
+        return hasOwn.call(this.bindings, name);
+    };
+    Sp.declaresType = function (name) {
+        this.scan();
+        return hasOwn.call(this.types, name);
+    };
+    Sp.declareTemporary = function (prefix) {
+        if (prefix) {
+            if (!/^[a-z$_]/i.test(prefix)) {
+                throw new Error("");
+            }
+        }
+        else {
+            prefix = "t$";
+        }
+        // Include this.depth in the name to make sure the name does not
+        // collide with any variables in nested/enclosing scopes.
+        prefix += this.depth.toString(36) + "$";
+        this.scan();
+        var index = 0;
+        while (this.declares(prefix + index)) {
+            ++index;
+        }
+        var name = prefix + index;
+        return this.bindings[name] = types.builders.identifier(name);
+    };
+    Sp.injectTemporary = function (identifier, init) {
+        identifier || (identifier = this.declareTemporary());
+        var bodyPath = this.path.get("body");
+        if (namedTypes.BlockStatement.check(bodyPath.value)) {
+            bodyPath = bodyPath.get("body");
+        }
+        bodyPath.unshift(b.variableDeclaration("var", [b.variableDeclarator(identifier, init || null)]));
+        return identifier;
+    };
+    Sp.scan = function (force) {
+        if (force || !this.didScan) {
+            for (var name in this.bindings) {
+                // Empty out this.bindings, just in cases.
+                delete this.bindings[name];
+            }
+            for (var name in this.types) {
+                // Empty out this.types, just in cases.
+                delete this.types[name];
+            }
+            scanScope(this.path, this.bindings, this.types);
+            this.didScan = true;
+        }
+    };
+    Sp.getBindings = function () {
+        this.scan();
+        return this.bindings;
+    };
+    Sp.getTypes = function () {
+        this.scan();
+        return this.types;
+    };
+    function scanScope(path, bindings, scopeTypes) {
+        var node = path.value;
+        if (TypeParameterScopeType.check(node)) {
+            var params = path.get('typeParameters', 'params');
+            if (isArray.check(params.value)) {
+                params.each(function (childPath) {
+                    addTypeParameter(childPath, scopeTypes);
+                });
+            }
+        }
+        if (ScopeType.check(node)) {
+            if (namedTypes.CatchClause.check(node)) {
+                // A catch clause establishes a new scope but the only variable
+                // bound in that scope is the catch parameter. Any other
+                // declarations create bindings in the outer scope.
+                addPattern(path.get("param"), bindings);
+            }
+            else {
+                recursiveScanScope(path, bindings, scopeTypes);
+            }
+        }
+    }
+    function recursiveScanScope(path, bindings, scopeTypes) {
+        var node = path.value;
+        if (path.parent &&
+            namedTypes.FunctionExpression.check(path.parent.node) &&
+            path.parent.node.id) {
+            addPattern(path.parent.get("id"), bindings);
+        }
+        if (!node) {
+            // None of the remaining cases matter if node is falsy.
+        }
+        else if (isArray.check(node)) {
+            path.each(function (childPath) {
+                recursiveScanChild(childPath, bindings, scopeTypes);
+            });
+        }
+        else if (namedTypes.Function.check(node)) {
+            path.get("params").each(function (paramPath) {
+                addPattern(paramPath, bindings);
+            });
+            recursiveScanChild(path.get("body"), bindings, scopeTypes);
+            recursiveScanScope(path.get("typeParameters"), bindings, scopeTypes);
+        }
+        else if ((namedTypes.TypeAlias && namedTypes.TypeAlias.check(node)) ||
+            (namedTypes.InterfaceDeclaration && namedTypes.InterfaceDeclaration.check(node)) ||
+            (namedTypes.TSTypeAliasDeclaration && namedTypes.TSTypeAliasDeclaration.check(node)) ||
+            (namedTypes.TSInterfaceDeclaration && namedTypes.TSInterfaceDeclaration.check(node))) {
+            addTypePattern(path.get("id"), scopeTypes);
+        }
+        else if (namedTypes.VariableDeclarator.check(node)) {
+            addPattern(path.get("id"), bindings);
+            recursiveScanChild(path.get("init"), bindings, scopeTypes);
+        }
+        else if (node.type === "ImportSpecifier" ||
+            node.type === "ImportNamespaceSpecifier" ||
+            node.type === "ImportDefaultSpecifier") {
+            addPattern(
+            // Esprima used to use the .name field to refer to the local
+            // binding identifier for ImportSpecifier nodes, but .id for
+            // ImportNamespaceSpecifier and ImportDefaultSpecifier nodes.
+            // ESTree/Acorn/ESpree use .local for all three node types.
+            path.get(node.local ? "local" :
+                node.name ? "name" : "id"), bindings);
+        }
+        else if (Node.check(node) && !Expression.check(node)) {
+            types.eachField(node, function (name, child) {
+                var childPath = path.get(name);
+                if (!pathHasValue(childPath, child)) {
+                    throw new Error("");
+                }
+                recursiveScanChild(childPath, bindings, scopeTypes);
+            });
+        }
+    }
+    function pathHasValue(path, value) {
+        if (path.value === value) {
+            return true;
+        }
+        // Empty arrays are probably produced by defaults.emptyArray, in which
+        // case is makes sense to regard them as equivalent, if not ===.
+        if (Array.isArray(path.value) &&
+            path.value.length === 0 &&
+            Array.isArray(value) &&
+            value.length === 0) {
+            return true;
+        }
+        return false;
+    }
+    function recursiveScanChild(path, bindings, scopeTypes) {
+        var node = path.value;
+        if (!node || Expression.check(node)) {
+            // Ignore falsy values and Expressions.
+        }
+        else if (namedTypes.FunctionDeclaration.check(node) &&
+            node.id !== null) {
+            addPattern(path.get("id"), bindings);
+        }
+        else if (namedTypes.ClassDeclaration &&
+            namedTypes.ClassDeclaration.check(node) &&
+            node.id !== null) {
+            addPattern(path.get("id"), bindings);
+            recursiveScanScope(path.get("typeParameters"), bindings, scopeTypes);
+        }
+        else if ((namedTypes.InterfaceDeclaration &&
+            namedTypes.InterfaceDeclaration.check(node)) ||
+            (namedTypes.TSInterfaceDeclaration &&
+                namedTypes.TSInterfaceDeclaration.check(node))) {
+            addTypePattern(path.get("id"), scopeTypes);
+        }
+        else if (ScopeType.check(node)) {
+            if (namedTypes.CatchClause.check(node) &&
+                // TODO Broaden this to accept any pattern.
+                namedTypes.Identifier.check(node.param)) {
+                var catchParamName = node.param.name;
+                var hadBinding = hasOwn.call(bindings, catchParamName);
+                // Any declarations that occur inside the catch body that do
+                // not have the same name as the catch parameter should count
+                // as bindings in the outer scope.
+                recursiveScanScope(path.get("body"), bindings, scopeTypes);
+                // If a new binding matching the catch parameter name was
+                // created while scanning the catch body, ignore it because it
+                // actually refers to the catch parameter and not the outer
+                // scope that we're currently scanning.
+                if (!hadBinding) {
+                    delete bindings[catchParamName];
+                }
+            }
+        }
+        else {
+            recursiveScanScope(path, bindings, scopeTypes);
+        }
+    }
+    function addPattern(patternPath, bindings) {
+        var pattern = patternPath.value;
+        namedTypes.Pattern.assert(pattern);
+        if (namedTypes.Identifier.check(pattern)) {
+            if (hasOwn.call(bindings, pattern.name)) {
+                bindings[pattern.name].push(patternPath);
+            }
+            else {
+                bindings[pattern.name] = [patternPath];
+            }
+        }
+        else if (namedTypes.AssignmentPattern &&
+            namedTypes.AssignmentPattern.check(pattern)) {
+            addPattern(patternPath.get('left'), bindings);
+        }
+        else if (namedTypes.ObjectPattern &&
+            namedTypes.ObjectPattern.check(pattern)) {
+            patternPath.get('properties').each(function (propertyPath) {
+                var property = propertyPath.value;
+                if (namedTypes.Pattern.check(property)) {
+                    addPattern(propertyPath, bindings);
+                }
+                else if (namedTypes.Property.check(property) ||
+                    (namedTypes.ObjectProperty &&
+                        namedTypes.ObjectProperty.check(property))) {
+                    addPattern(propertyPath.get('value'), bindings);
+                }
+                else if (namedTypes.SpreadProperty &&
+                    namedTypes.SpreadProperty.check(property)) {
+                    addPattern(propertyPath.get('argument'), bindings);
+                }
+            });
+        }
+        else if (namedTypes.ArrayPattern &&
+            namedTypes.ArrayPattern.check(pattern)) {
+            patternPath.get('elements').each(function (elementPath) {
+                var element = elementPath.value;
+                if (namedTypes.Pattern.check(element)) {
+                    addPattern(elementPath, bindings);
+                }
+                else if (namedTypes.SpreadElement &&
+                    namedTypes.SpreadElement.check(element)) {
+                    addPattern(elementPath.get("argument"), bindings);
+                }
+            });
+        }
+        else if (namedTypes.PropertyPattern &&
+            namedTypes.PropertyPattern.check(pattern)) {
+            addPattern(patternPath.get('pattern'), bindings);
+        }
+        else if ((namedTypes.SpreadElementPattern &&
+            namedTypes.SpreadElementPattern.check(pattern)) ||
+            (namedTypes.RestElement &&
+                namedTypes.RestElement.check(pattern)) ||
+            (namedTypes.SpreadPropertyPattern &&
+                namedTypes.SpreadPropertyPattern.check(pattern))) {
+            addPattern(patternPath.get('argument'), bindings);
+        }
+    }
+    function addTypePattern(patternPath, types) {
+        var pattern = patternPath.value;
+        namedTypes.Pattern.assert(pattern);
+        if (namedTypes.Identifier.check(pattern)) {
+            if (hasOwn.call(types, pattern.name)) {
+                types[pattern.name].push(patternPath);
+            }
+            else {
+                types[pattern.name] = [patternPath];
+            }
+        }
+    }
+    function addTypeParameter(parameterPath, types) {
+        var parameter = parameterPath.value;
+        FlowOrTSTypeParameterType.assert(parameter);
+        if (hasOwn.call(types, parameter.name)) {
+            types[parameter.name].push(parameterPath);
+        }
+        else {
+            types[parameter.name] = [parameterPath];
+        }
+    }
+    Sp.lookup = function (name) {
+        for (var scope = this; scope; scope = scope.parent)
+            if (scope.declares(name))
+                break;
+        return scope;
+    };
+    Sp.lookupType = function (name) {
+        for (var scope = this; scope; scope = scope.parent)
+            if (scope.declaresType(name))
+                break;
+        return scope;
+    };
+    Sp.getGlobalScope = function () {
+        var scope = this;
+        while (!scope.isGlobal)
+            scope = scope.parent;
+        return scope;
+    };
+    return Scope;
+}
+exports.default = scopePlugin;
+module.exports = exports["default"];

node_modules/recast/node_modules/ast-types/lib/shared.d.ts

@@ -0,0 +1,13 @@
+import { Fork } from "../types";
+export default function (fork: Fork): {
+    geq: (than: any) => import("./types").Type<unknown>;
+    defaults: {
+        null: () => null;
+        emptyArray: () => never[];
+        false: () => boolean;
+        true: () => boolean;
+        undefined: () => void;
+        "use strict": () => string;
+    };
+    isPrimitive: import("./types").Type<unknown>;
+};

node_modules/recast/node_modules/ast-types/lib/shared.js

@@ -0,0 +1,47 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var types_1 = (0, tslib_1.__importDefault)(require("./types"));
+function default_1(fork) {
+    var types = fork.use(types_1.default);
+    var Type = types.Type;
+    var builtin = types.builtInTypes;
+    var isNumber = builtin.number;
+    // An example of constructing a new type with arbitrary constraints from
+    // an existing type.
+    function geq(than) {
+        return Type.from(function (value) { return isNumber.check(value) && value >= than; }, isNumber + " >= " + than);
+    }
+    ;
+    // Default value-returning functions that may optionally be passed as a
+    // third argument to Def.prototype.field.
+    var defaults = {
+        // Functions were used because (among other reasons) that's the most
+        // elegant way to allow for the emptyArray one always to give a new
+        // array instance.
+        "null": function () { return null; },
+        "emptyArray": function () { return []; },
+        "false": function () { return false; },
+        "true": function () { return true; },
+        "undefined": function () { },
+        "use strict": function () { return "use strict"; }
+    };
+    var naiveIsPrimitive = Type.or(builtin.string, builtin.number, builtin.boolean, builtin.null, builtin.undefined);
+    var isPrimitive = Type.from(function (value) {
+        if (value === null)
+            return true;
+        var type = typeof value;
+        if (type === "object" ||
+            type === "function") {
+            return false;
+        }
+        return true;
+    }, naiveIsPrimitive.toString());
+    return {
+        geq: geq,
+        defaults: defaults,
+        isPrimitive: isPrimitive,
+    };
+}
+exports.default = default_1;
+module.exports = exports["default"];