Deployed the page to Github Pages.

2024-11-03 21:30:09 -05:00 · 2024-11-03 21:30:09 -05:00 · 2c89899458
commit 2c89899458
parent 1d79754e93
62797 changed files with 6551425 additions and 15279 deletions
--- a/node_modules/tsutils/.editorconfig
+++ b/node_modules/tsutils/.editorconfig
@ -0,0 +1,12 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+indent_size = 4
+indent_style = space
+trim_trailing_whitespace = true
+
+[*.{json,yml,md}]
+indent_size = 2
--- a/node_modules/tsutils/.fimbullinter.yaml
+++ b/node_modules/tsutils/.fimbullinter.yaml
@ -0,0 +1,2 @@
+exclude:
+  - test/rules/**
--- a/node_modules/tsutils/.wotanrc.yaml
+++ b/node_modules/tsutils/.wotanrc.yaml
@ -0,0 +1,5 @@
+extends: wotan:recommended
+rules:
+    # TODO enable once https://github.com/Microsoft/TypeScript/issues/24706 is resolved
+    no-useless-assertion: off
+    no-useless-predicate: off
--- a/node_modules/tsutils/CHANGELOG.md
+++ b/node_modules/tsutils/CHANGELOG.md
@ -0,0 +1,529 @@
+# 2.29.0
+
+**Features:**
+
+* added utility `isCompilerOptionEnabled`
+
+# 2.28.0
+
+Typeguards are now split into multiple submodules for each version of TypeScript (starting with 2.8.0).
+That means you can now import directly from `"tsutils/typeguard/2.8"` to get compatible declaraton files for TypeScript@2.8.
+For more information please read the relevant section in [README.md](README.md).
+
+**Features:**
+
+* added typeguards: `isTupleType`, `isOptionalTypeNode`, `isRestTypeNode`, `isSyntheticExpression` (currently available from `"tsutils/typeguard/3.0"`)
+* added utility `isStrictCompilerOptionEnabled`
+
+# 2.27.2
+
+Avoid crash caused by removed function in `typescript@3.0.0`.
+
+# 2.27.1
+
+Added support for TypeScript@3.0.0 nightly builds.
+
+# 2.27.0
+
+**Features:**
+
+* added `getIIFE` utility
+
+# 2.26.2
+
+**Bugfixes:**
+
+* `forEachComment` and `forEachTokenWithTrivia` no longer duplicate comments around missing nodes
+
+# 2.26.1
+
+**Bugfixes:**
+
+* fixed crash in `hasSideEffects` with tagged template literal without substitution: ``tag`template` ``
+
+# 2.26.0
+
+**Features:**
+
+* added typeguard `isLiteralTypeNode`
+* added support for type imports (`type T = import('foo')`) to `findImports` via `ImportKind.ImportType`
+
+# 2.25.1
+
+**Bugfixes:**
+
+* `collectVariableUsage`: fixed name lookup in function signatures to match runtime behavior. Note that this is not completely fixed in TypeScript, yet. See: [Microsoft/TypeScript#22825](https://github.com/Microsoft/TypeScript/issues/22825) and [Microsoft/TypeScript#22769](https://github.com/Microsoft/TypeScript/issues/22769)
+
+# 2.25.0
+
+**Features:**
+
+* added utilities: `isStatementInAmbientContext` and `isAmbientModuleBlock`
+
+# 2.24.0
+
+**Features:**
+
+* added typeguards for typescript@2.8: `isConditionalTypeNode`, `isInferTypeNode`, `isConditionalType`, `isInstantiableType`, `isSubstitutionType`
+
+# 2.23.0
+
+**Features:**
+
+* added typeguard `isForInOrOfStatement`
+
+**Bugfixes:**
+
+* correctly handle comments in generic JSX elements: `<MyComponent<string>/*comment*/></MyComponent>`
+* fixed a bug with false positive trailing comments at the end of JSX self closing element: `<div><br/>/*no comment*/</div>`
+
+# 2.22.2
+
+**Bugfixes:**
+
+* `collectVariableUsage`: handle ConditionalTypes and `infer T`, which will be introduced in TypeScript@2.8.0 and are already available in nightly builds
+* `isLiteralType` no longer returns true for `ts.TypeFlags.BooleanLiteral` as this is not a `ts.LiteralType`
+
+# 2.22.1
+
+**Bugfixes:**
+
+* `endsControlFlow`:
+  * handle loops that might not even run a single iteration
+  * handle constant boolean conditions in loops and if
+
+# 2.22.0
+
+**Features:**
+
+* added `isFalsyType` utility
+
+# 2.21.2
+
+**Bugfixes:**
+
+* fixed compile error with `typescript@2.8.0-dev`
+
+# 2.21.1
+
+**Bugfixes:**
+
+* `isReassignmentTarget`: handle type assertions and non-null assertion
+
+# 2.21.0
+
+**Bugfixes:**
+
+* `forEachDeclaredVariable` uses a more precise type for the callback parameter to make it useable again with typescript@2.7.1
+
+**Features:**
+
+* added `isUniqueESSymbolType` typeguard
+
+# 2.20.0
+
+**Features:**
+
+* added `isThenableType` utility
+* added `unionTypeParts` utility
+
+# 2.19.1
+
+**Bugfixes:**
+
+* `forEachComment`, `getCommentAtPosition` and `isPositionInComment`: skip shebang (`#! something`) to not miss following comments at the start of the file
+
+# 2.19.0
+
+**Features:**
+
+* added `WrappedAst` interface that models the type of a wrapped SourceFile more accurate
+* added `getWrappedNodeAtPosition` utiltiy that takes a `NodeWrap` and returns the most deeply nested NodeWrap that contains the given position
+
+# 2.18.0
+
+**Features:**
+
+* `getControlFlowEnd` accepts BlockLike as argument
+
+**Bugfixes:**
+
+* `getControlFlowEnd` and `endsControlFlow`: correctly handle nested LabeledStatements
+* `endsControlFlow` removed erroneous special case when an IterationStatement is passed as argument whose parent is a LabeledStatement.
+  * if you want labels of an IterationStatement (or SwitchStatement) to be handled, you need to pass the LabeledStatement as argument.
+  * :warning: this fix may change the returned value if you relied on the buggy behavior
+
+**Deprecations:**
+
+* deprecated overload of `getControlFlowEnd` that contains the `label` parameter. This parameter is no longer used and should no longer be passed to the function.
+
+# 2.17.1
+
+**Bugfixes:**
+
+* `getControlFlowEnd` and `endsControlFlow` (#22)
+  * ThrowStatements inside `try` are filtered out if there is a `catch` clause
+  * TryStatements with `catch` only end control flow if `try` AND `catch` definitely end control flow
+
+# 2.17.0
+
+**Features:**
+
+* added `kind` property to `NodeWrap`
+* added `getControlFlowEnd` to public API
+
+# 2.16.0
+
+**Features:**
+
+* added `isDecorator` and `isCallLikeExpression` typeguards
+
+# 2.15.0
+
+**Features:**
+
+* added `convertAst` utility to produce a flattened and wrapped version of the AST
+
+# 2.14.0
+
+**Features:**
+
+* added `isDeleteExpression`
+* added `getLineBreakStyle`
+
+# 2.13.1
+
+**Bugfixes:**
+
+* fixed name of `isJsxFragment`
+
+# 2.13.0
+
+**Features:**
+
+* added support for `JsxFragment` introduced in typescript@2.6.2
+* added corresponding typeguard functions
+
+# 2.12.2
+
+**Bugfixes:**
+
+* `endsControlFlow`
+  * added missing logic for labeled statement, iteration statements and try-catch
+  * added missing logic for `break` and `continue` with labels
+  * take all jump statements into account, not only the last statement
+* `isValidIdentifier` and `isValidNumericLiteral` handle irregular whitespace
+* `findImports` searches in ambient modules inside regular `.ts` files (not only `.d.ts`)
+* `canHaveJsDoc` is now a typeguard
+
+# 2.12.1
+
+**Bugfixes:**
+
+* `forEachTokenWithTrivia`
+  * handles irregular whitespace and no longer visits some tokens twice
+  * correctly calculates the range of JsxText
+
+# 2.12.0
+
+**API-Changes:**
+
+* deprecated `ImportOptions` if favor of the new `ImportKind` enum
+
+# 2.11.2
+
+**Bugfixes:**
+
+* `parseJsDocOfNode`: set correct `pos`, `end` and `parent` properties. Also affects `getJsDoc` of `EndOfFileToken`
+
+# 2.11.1
+
+**Bugfixes:**
+
+* `collectVariableUsage`: correctly consider catch binding as block scoped declaration inside catch block
+
+# 2.11.0
+
+**Bugfixes:**
+
+* `getJsDoc` now correctly returns JsDoc for `EndOfFileToken`
+
+**Features:**
+
+* added utility `parseJsDocOfNode`
+
+# 2.10.0
+
+**Features:**
+
+* added utility `findImports` to find all kinds of imports in a source file
+
+# 2.9.0
+
+**Features:**
+
+* added typeguard `isMappedTypeNode`
+* added utilities `canHaveJsDoc` and `getJsDoc`
+
+# 2.8.2
+
+**Bugfixes:**
+
+* `collectVariableUsage`: handle global augmentation like other module augmentations
+
+# 2.8.1
+
+**Bugfixes:**
+
+* Support `typescript@2.5.1` with optional catch binding
+* `collectVariableUsage` fixed a bug where method decorator had method's parameters in scope
+
+# 2.8.0
+
+* Compatibility with the latest typescript nightly
+* Added `getIdentifierText` to unescape identifiers across typescript versions
+
+# 2.7.1
+
+**Bugfixes:**
+
+* `isReassignmentTarget` don't return `true` for right side of assignment
+
+# 2.7.0
+
+**Features:**
+
+* Added `isReassignmentTarget` utility
+
+# 2.6.1
+
+**Bugfixes:**
+
+* `getDeclarationDomain` now returns `undefined` for Parameter in IndexSignature
+* `collectVariableUsage` ignores Parameter in IndexSignature
+
+# 2.6.0
+
+**Bugfixes:**
+
+* `collectVariableUsage`:
+  * don't merge imports with global declarations
+  * treat everything in a declaration file as exported if there is no explicit `export {};`
+* `isExpressionValueUsed`: handle destructuring in `for...of`
+
+**Features:**
+
+* Added `getModifier` utility
+* Added `DeclarationDomain.Import` to distinguish imports from other declarations
+
+# 2.5.1
+
+**Bugfixes:**
+
+* `collectVariableUsage` ignore jump labels as in `break label;`
+
+# 2.5.0
+
+**Bugfixes:**
+
+* `isFunctionWithBody` handles constructor overload correctly.
+
+**Features:**
+
+* Implemented `isExpressionValueUsed` to check whether the result of an expression is actually used.
+* Implemented `getDeclarationDomain` to determine if a given declaration introduces a new symbol in the value or type domain.
+
+**`collectVariableUses` is now usable**
+
+* no longer ignores signatures and its parameters
+* don't merge declarations and uses across domains
+* no longer marks exceptions in catch clause or parameter properties as exported
+* fixed exports of namespaces
+* fixed scoping of ClassExpression name
+* correcly handle ambient namespaces and module augmentations
+* fixed how `: typeof foo` is handled for parameters and function return type
+* **still WIP**: `export {Foo as Bar}` inside ambient namespaces and modules
+
+# 2.4.0
+
+**Bugfixes:**
+
+* `getLineRanges`: `contentLength` now contains the correct line length when there are multiple consecutive line break characters
+* `getTokenAtPosition`: don't match tokens that end at the specified position (because that's already outside of their range)
+* deprecated the misnamed `isModfierFlagSet`, use the new `isModifierFlagSet` instead
+
+**Features:**
+
+* Added typeguard: `isJsDoc`
+* Added experimental scope and usage analysis (`getUsageDomain` and `collectVariableUsage`)
+
+# 2.3.0
+
+**Bugfixes:**
+
+* `forEachComment` no longer omits some comments when callback returns a truthy value
+* `isPositionInComment` fixed false positive inside JSXText
+
+**Features:**
+
+* Added utility: `getCommentAtPosition`
+
+# 2.2.0
+
+**Bugfixes:**
+
+* Fixed bit value of `SideEffectOptions.JsxElement` to be a power of 2
+
+**Features:**
+
+* Added utilities: `getTokenAtPosition` and `isPositionInComment`
+
+# 2.1.0
+
+**Features:**
+
+* Added typeguard `isExpression`
+* Added utilities: `hasSideEffects`, `getDeclarationOfBindingElement`
+
+# 2.0.0
+
+**Breaking Changes:**
+
+* Dropped compatibility with `typescript@<2.1.0`
+* Removed misnamed `isNumericliteral`, use `isNumericLiteral` instead (notice the uppercase L)
+* Removed `isEnumLiteralType` which will cause compile errors with typescript@2.4.0
+* Refactored directory structure: all imports that referenced subdirectories (e.g. `require('tsutils/src/typeguard')` will be broken
+
+**Features:**
+
+* New directory structure allows imports of typeguards or utils independently, e.g. (`require('tsutils/typeguard')`)
+
+# 1.9.1
+
+**Bugfixes:**
+
+* `isObjectFlagSet` now uses the correct `objectFlags` property
+
+# 1.9.0
+
+**Bugfixes:**
+
+* `getNextToken` no longer omits `EndOfFileToken` when there is no trivia before EOF. That means the only inputs where `getNextToken` returns `undefined` are `SourceFile` and `EndOfFileToken`
+
+**Features**:
+
+* Added typeguards for types
+* Added utilities for flag checking: `isNodeFlagSet`, `isTypeFlagSet`, `isSymbolFlagSet`,`isObjectFlagSet`, `isModifierFlagSet`
+
+# 1.8.0
+
+**Features:**
+
+* Support peer dependency of typescript nightlies of 2.4.0
+* Added typeguards: `isJsxAttributes`, `isIntersectionTypeNode`, `isTypeOperatorNode`, `isTypePredicateNode`, `isTypeQueryNode`, `isUnionTypeNode`
+
+# 1.7.0
+
+**Bugfixes:**
+
+* `isFunctionScopeBoundary` now handles Interfaces, TypeAliases, FunctionSignatures, etc
+
+**Features:**
+
+* Added utilities: `isThisParameter`, `isSameLine` and `isFunctionWithBody`
+
+# 1.6.0
+
+**Features:**
+
+* Add `isValidPropertyAccess`, `isValidNumericLiteral` and `isValidPropertyName`
+
+# 1.5.0
+
+**Features:**
+
+* Add `isValidIdentifier`
+
+# 1.4.0
+
+**Features:**
+
+* Add `contentLength` property to the result of `getLineRanges`
+
+# 1.3.0
+
+**Bugfixes:**
+
+* `canHaveLeadingTrivia`:
+  * Fix property access on undefined parent reference
+  * Fixes: [palantir/tslint#2330](https://github.com/palantir/tslint/issues/2330)
+* `hasOwnThisReference`: now includes accessors on object literals
+
+**Features:**
+
+* Typeguards:
+  * isTypeParameterDeclaration
+  * isEnitityName
+
+# 1.2.2
+
+**Bugfixes:**
+
+* `hasOwnThisReference`:
+  * exclude overload signatures of function declarations
+  * add method declarations on object literals
+
+# 1.2.1
+
+**Bugfixes:**
+
+* Fix name of `isNumericLiteral`
+
+# 1.2.0
+
+**Features:**
+
+* Typeguards:
+  * isEnumMember
+  * isExpressionWithTypeArguments
+  * isImportSpecifier
+* Utilities:
+  * isJsDocKind, isTypeNodeKind
+* Allow typescript@next in peerDependencies
+
+# 1.1.0
+
+**Bugfixes:**
+
+* Fix isBlockScopeBoundary: Remove WithStatement, IfStatment, DoStatement and WhileStatement because they are no scope boundary whitout a block.
+
+**Features:**
+
+* Added more typeguards:
+  * isAssertionExpression
+  * isEmptyStatement
+  * isJsxAttributeLike
+  * isJsxOpeningLikeElement
+  * isNonNullExpression
+  * isSyntaxList
+* Utilities:
+  * getNextToken, getPreviousToken
+  * hasOwnThisReference
+  * getLineRanges
+
+# 1.0.0
+
+**Features:**
+
+* Initial implementation of typeguards
+* Utilities:
+  * getChildOfKind
+  * isNodeKind, isAssignmentKind
+  * hasModifier, isParameterProperty, hasAccessModifier
+  * getPreviousStatement, getNextStatement
+  * getPropertyName
+  * forEachDestructuringIdentifier, forEachDeclaredVariable
+  * getVariableDeclarationKind, isBlockScopedVariableDeclarationList, isBlockScopedVariableDeclaration
+  * isScopeBoundary, isFunctionScopeBoundary, isBlockScopeBoundary
+  * forEachToken, forEachTokenWithTrivia, forEachComment
+  * endsControlFlow
--- a/node_modules/tsutils/LICENSE
+++ b/node_modules/tsutils/LICENSE
@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Klaus Meinhardt
+
+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.
--- a/node_modules/tsutils/README.md
+++ b/node_modules/tsutils/README.md
@ -0,0 +1,61 @@
+# Utility functions for working with typescript's AST
+
+[![Greenkeeper badge](https://badges.greenkeeper.io/ajafff/tsutils.svg)](https://greenkeeper.io/)
+
+## Usage
+
+This package consists of two major parts: utilities and typeguard functions.
+By importing the project you will get both of them.
+```js
+import * as utils from "tsutils";
+utils.isIdentifier(node); // typeguard
+utils.getLineRanges(sourceFile); // utilities
+```
+
+If you don't need everything offered by this package, you can select what should be imported. The parts that are not imported are never read from disk and may save some startup time and reduce memory consumtion.
+
+If you only need typeguards you can explicitly import them:
+```js
+import { isIdentifier } from "tsutils/typeguard";
+// You can even distiguish between typeguards for nodes and types
+import { isUnionTypeNode } from "tsutils/typeguard/node";
+import { isUnionType } from "tsutils/typeguard/type";
+```
+
+If you only need the utilities you can also explicitly import them:
+```js
+import { forEachComment, forEachToken } from "tsutils/util";
+```
+
+### Typescript version dependency
+
+This package is backwards compatible with typescript 2.1.0 at runtime although compiling might need a newer version of typescript installed.
+
+Using `typescript@next` might work, but it's not officially supported. If you encounter any bugs, please open an issue.
+
+For compatibility with older versions of TypeScript typeguard functions are separated by TypeScript version. If you are stuck on `typescript@2.8`, you should import directly from the submodule for that version:
+
+```js
+// all typeguards compatible with typescript@2.8
+import { isIdentifier } from "tsutils/typeguard/2.8";
+// you can even use nested submodules
+import { isIdentifier } from "tsutils/typeguard/2.8/node";
+
+// all typeguards compatible with typescript@2.9 (includes those of 2.8)
+import { isIdentifier } from "tsutils/typeguard/2.9";
+
+// always points to the latest stable version (2.9 as of writing this)
+import { isIdentifier } from "tsutils/typeguard";
+import { isIdentifier } from "tsutils";
+
+// always points to the typeguards for the next TypeScript version (3.0 as of writing this)
+import { isIdentifier } from "tsutils/typeguard/next";
+```
+
+Note that if you are also using utility functions, you should prefer the relevant submodule:
+
+```js
+// importing directly from 'tsutils' would pull in the latest typeguards
+import { forEachToken } from 'tsutils/util';
+import { isIdentifier } from 'tsutils/typeguard/2.8';
+```
--- a/node_modules/tsutils/index.d.ts
+++ b/node_modules/tsutils/index.d.ts
@ -0,0 +1,2 @@
+export * from './typeguard';
+export * from './util';
--- a/node_modules/tsutils/index.js
+++ b/node_modules/tsutils/index.js
@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./typeguard"), exports);
+tslib_1.__exportStar(require("./util"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxzREFBNEI7QUFDNUIsaURBQXVCIn0=
--- a/node_modules/tsutils/node_modules/tslib/CopyrightNotice.txt
+++ b/node_modules/tsutils/node_modules/tslib/CopyrightNotice.txt
@ -0,0 +1,15 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
--- a/node_modules/tsutils/node_modules/tslib/LICENSE.txt
+++ b/node_modules/tsutils/node_modules/tslib/LICENSE.txt
@ -0,0 +1,12 @@
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
--- a/node_modules/tsutils/node_modules/tslib/README.md
+++ b/node_modules/tsutils/node_modules/tslib/README.md
@ -0,0 +1,142 @@
+# tslib
+
+This is a runtime library for [TypeScript](http://www.typescriptlang.org/) that contains all of the TypeScript helper functions.
+
+This library is primarily used by the `--importHelpers` flag in TypeScript.
+When using `--importHelpers`, a module that uses helper functions like `__extends` and `__assign` in the following emitted file:
+
+```ts
+var __assign = (this && this.__assign) || Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+        s = arguments[i];
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+    }
+    return t;
+};
+exports.x = {};
+exports.y = __assign({}, exports.x);
+
+```
+
+will instead be emitted as something like the following:
+
+```ts
+var tslib_1 = require("tslib");
+exports.x = {};
+exports.y = tslib_1.__assign({}, exports.x);
+```
+
+Because this can avoid duplicate declarations of things like `__extends`, `__assign`, etc., this means delivering users smaller files on average, as well as less runtime overhead.
+For optimized bundles with TypeScript, you should absolutely consider using `tslib` and `--importHelpers`.
+
+# Installing
+
+For the latest stable version, run:
+
+## npm
+
+```sh
+# TypeScript 2.3.3 or later
+npm install tslib
+
+# TypeScript 2.3.2 or earlier
+npm install tslib@1.6.1
+```
+
+## yarn
+
+```sh
+# TypeScript 2.3.3 or later
+yarn add tslib
+
+# TypeScript 2.3.2 or earlier
+yarn add tslib@1.6.1
+```
+
+## bower
+
+```sh
+# TypeScript 2.3.3 or later
+bower install tslib
+
+# TypeScript 2.3.2 or earlier
+bower install tslib@1.6.1
+```
+
+## JSPM
+
+```sh
+# TypeScript 2.3.3 or later
+jspm install tslib
+
+# TypeScript 2.3.2 or earlier
+jspm install tslib@1.6.1
+```
+
+# Usage
+
+Set the `importHelpers` compiler option on the command line:
+
+```
+tsc --importHelpers file.ts
+```
+
+or in your tsconfig.json:
+
+```json
+{
+    "compilerOptions": {
+        "importHelpers": true
+    }
+}
+```
+
+#### For bower and JSPM users
+
+You will need to add a `paths` mapping for `tslib`, e.g. For Bower users:
+
+```json
+{
+    "compilerOptions": {
+        "module": "amd",
+        "importHelpers": true,
+        "baseUrl": "./",
+        "paths": {
+            "tslib" : ["bower_components/tslib/tslib.d.ts"]
+        }
+    }
+}
+```
+
+For JSPM users:
+
+```json
+{
+    "compilerOptions": {
+        "module": "system",
+        "importHelpers": true,
+        "baseUrl": "./",
+        "paths": {
+            "tslib" : ["jspm_packages/npm/tslib@1.[version].0/tslib.d.ts"]
+        }
+    }
+}
+```
+
+
+# Contribute
+
+There are many ways to [contribute](https://github.com/Microsoft/TypeScript/blob/master/CONTRIBUTING.md) to TypeScript.
+
+* [Submit bugs](https://github.com/Microsoft/TypeScript/issues) and help us verify fixes as they are checked in.
+* Review the [source code changes](https://github.com/Microsoft/TypeScript/pulls).
+* Engage with other TypeScript users and developers on [StackOverflow](http://stackoverflow.com/questions/tagged/typescript).
+* Join the [#typescript](http://twitter.com/#!/search/realtime/%23typescript) discussion on Twitter.
+* [Contribute bug fixes](https://github.com/Microsoft/TypeScript/blob/master/CONTRIBUTING.md).
+
+# Documentation
+
+* [Quick tutorial](http://www.typescriptlang.org/Tutorial)
+* [Programming handbook](http://www.typescriptlang.org/Handbook)
+* [Homepage](http://www.typescriptlang.org/)
--- a/node_modules/tsutils/node_modules/tslib/modules/index.js
+++ b/node_modules/tsutils/node_modules/tslib/modules/index.js
@ -0,0 +1,51 @@
+import tslib from '../tslib.js';
+const {
+    __extends,
+    __assign,
+    __rest,
+    __decorate,
+    __param,
+    __metadata,
+    __awaiter,
+    __generator,
+    __exportStar,
+    __createBinding,
+    __values,
+    __read,
+    __spread,
+    __spreadArrays,
+    __await,
+    __asyncGenerator,
+    __asyncDelegator,
+    __asyncValues,
+    __makeTemplateObject,
+    __importStar,
+    __importDefault,
+    __classPrivateFieldGet,
+    __classPrivateFieldSet,
+} = tslib;
+export {
+    __extends,
+    __assign,
+    __rest,
+    __decorate,
+    __param,
+    __metadata,
+    __awaiter,
+    __generator,
+    __exportStar,
+    __createBinding,
+    __values,
+    __read,
+    __spread,
+    __spreadArrays,
+    __await,
+    __asyncGenerator,
+    __asyncDelegator,
+    __asyncValues,
+    __makeTemplateObject,
+    __importStar,
+    __importDefault,
+    __classPrivateFieldGet,
+    __classPrivateFieldSet,
+};
--- a/node_modules/tsutils/node_modules/tslib/modules/package.json
+++ b/node_modules/tsutils/node_modules/tslib/modules/package.json
@ -0,0 +1,3 @@
+{
+    "type": "module"
+}
--- a/node_modules/tsutils/node_modules/tslib/package.json
+++ b/node_modules/tsutils/node_modules/tslib/package.json
@ -0,0 +1,37 @@
+{
+    "name": "tslib",
+    "author": "Microsoft Corp.",
+    "homepage": "https://www.typescriptlang.org/",
+    "version": "1.14.1",
+    "license": "0BSD",
+    "description": "Runtime library for TypeScript helper functions",
+    "keywords": [
+        "TypeScript",
+        "Microsoft",
+        "compiler",
+        "language",
+        "javascript",
+        "tslib",
+        "runtime"
+    ],
+    "bugs": {
+        "url": "https://github.com/Microsoft/TypeScript/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Microsoft/tslib.git"
+    },
+    "main": "tslib.js",
+    "module": "tslib.es6.js",
+    "jsnext:main": "tslib.es6.js",
+    "typings": "tslib.d.ts",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "module": "./tslib.es6.js",
+            "import": "./modules/index.js",
+            "default": "./tslib.js"
+        },
+        "./": "./"
+    }
+}
--- a/node_modules/tsutils/node_modules/tslib/test/validateModuleExportsMatchCommonJS/index.js
+++ b/node_modules/tsutils/node_modules/tslib/test/validateModuleExportsMatchCommonJS/index.js
@ -0,0 +1,23 @@
+// When on node 14, it validates that all of the commonjs exports
+// are correctly re-exported for es modules importers.
+
+const nodeMajor = Number(process.version.split(".")[0].slice(1))
+if (nodeMajor < 14) {
+  console.log("Skipping because node does not support module exports.")
+  process.exit(0)
+}
+
+// ES Modules import via the ./modules folder
+import * as esTSLib from "../../modules/index.js"
+
+// Force a commonjs resolve
+import { createRequire } from "module";
+const commonJSTSLib = createRequire(import.meta.url)("../../tslib.js");
+
+for (const key in commonJSTSLib) {
+  if (commonJSTSLib.hasOwnProperty(key)) {
+    if(!esTSLib[key]) throw new Error(`ESModules is missing ${key} - it needs to be re-exported in  ./modules/index.js`)
+  }
+}
+
+console.log("All exports in commonjs are available for es module consumers.")
--- a/node_modules/tsutils/node_modules/tslib/test/validateModuleExportsMatchCommonJS/package.json
+++ b/node_modules/tsutils/node_modules/tslib/test/validateModuleExportsMatchCommonJS/package.json
@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "scripts": {
+    "test": "node index.js"
+  }
+}
--- a/node_modules/tsutils/node_modules/tslib/tslib.d.ts
+++ b/node_modules/tsutils/node_modules/tslib/tslib.d.ts
@ -0,0 +1,37 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+export declare function __extends(d: Function, b: Function): void;
+export declare function __assign(t: any, ...sources: any[]): any;
+export declare function __rest(t: any, propertyNames: (string | symbol)[]): any;
+export declare function __decorate(decorators: Function[], target: any, key?: string | symbol, desc?: any): any;
+export declare function __param(paramIndex: number, decorator: Function): Function;
+export declare function __metadata(metadataKey: any, metadataValue: any): Function;
+export declare function __awaiter(thisArg: any, _arguments: any, P: Function, generator: Function): any;
+export declare function __generator(thisArg: any, body: Function): any;
+export declare function __exportStar(m: any, exports: any): void;
+export declare function __values(o: any): any;
+export declare function __read(o: any, n?: number): any[];
+export declare function __spread(...args: any[][]): any[];
+export declare function __spreadArrays(...args: any[][]): any[];
+export declare function __await(v: any): any;
+export declare function __asyncGenerator(thisArg: any, _arguments: any, generator: Function): any;
+export declare function __asyncDelegator(o: any): any;
+export declare function __asyncValues(o: any): any;
+export declare function __makeTemplateObject(cooked: string[], raw: string[]): TemplateStringsArray;
+export declare function __importStar<T>(mod: T): T;
+export declare function __importDefault<T>(mod: T): T | { default: T };
+export declare function __classPrivateFieldGet<T extends object, V>(receiver: T, privateMap: { has(o: T): boolean, get(o: T): V | undefined }): V;
+export declare function __classPrivateFieldSet<T extends object, V>(receiver: T, privateMap: { has(o: T): boolean, set(o: T, value: V): any }, value: V): V;
+export declare function __createBinding(object: object, target: object, key: PropertyKey, objectKey?: PropertyKey): void;
--- a/node_modules/tsutils/node_modules/tslib/tslib.es6.html
+++ b/node_modules/tsutils/node_modules/tslib/tslib.es6.html
@ -0,0 +1 @@
+<script src="tslib.es6.js"></script>
--- a/node_modules/tsutils/node_modules/tslib/tslib.es6.js
+++ b/node_modules/tsutils/node_modules/tslib/tslib.es6.js
@ -0,0 +1,218 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+export function __extends(d, b) {
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+export var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    }
+    return __assign.apply(this, arguments);
+}
+
+export function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+export function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+export function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+export function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+export function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+export function __createBinding(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}
+
+export function __exportStar(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+
+export function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+export function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+export function __spread() {
+    for (var ar = [], i = 0; i < arguments.length; i++)
+        ar = ar.concat(__read(arguments[i]));
+    return ar;
+}
+
+export function __spreadArrays() {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+
+export function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+export function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+export function __asyncDelegator(o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+}
+
+export function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+export function __makeTemplateObject(cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+
+export function __importStar(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result.default = mod;
+    return result;
+}
+
+export function __importDefault(mod) {
+    return (mod && mod.__esModule) ? mod : { default: mod };
+}
+
+export function __classPrivateFieldGet(receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+
+export function __classPrivateFieldSet(receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+}
--- a/node_modules/tsutils/node_modules/tslib/tslib.html
+++ b/node_modules/tsutils/node_modules/tslib/tslib.html
@ -0,0 +1 @@
+<script src="tslib.js"></script>
--- a/node_modules/tsutils/node_modules/tslib/tslib.js
+++ b/node_modules/tsutils/node_modules/tslib/tslib.js
@ -0,0 +1,284 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+/* global global, define, System, Reflect, Promise */
+var __extends;
+var __assign;
+var __rest;
+var __decorate;
+var __param;
+var __metadata;
+var __awaiter;
+var __generator;
+var __exportStar;
+var __values;
+var __read;
+var __spread;
+var __spreadArrays;
+var __await;
+var __asyncGenerator;
+var __asyncDelegator;
+var __asyncValues;
+var __makeTemplateObject;
+var __importStar;
+var __importDefault;
+var __classPrivateFieldGet;
+var __classPrivateFieldSet;
+var __createBinding;
+(function (factory) {
+    var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
+    if (typeof define === "function" && define.amd) {
+        define("tslib", ["exports"], function (exports) { factory(createExporter(root, createExporter(exports))); });
+    }
+    else if (typeof module === "object" && typeof module.exports === "object") {
+        factory(createExporter(root, createExporter(module.exports)));
+    }
+    else {
+        factory(createExporter(root));
+    }
+    function createExporter(exports, previous) {
+        if (exports !== root) {
+            if (typeof Object.create === "function") {
+                Object.defineProperty(exports, "__esModule", { value: true });
+            }
+            else {
+                exports.__esModule = true;
+            }
+        }
+        return function (id, v) { return exports[id] = previous ? previous(id, v) : v; };
+    }
+})
+(function (exporter) {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+
+    __extends = function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+
+    __assign = Object.assign || function (t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+
+    __rest = function (s, e) {
+        var t = {};
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    };
+
+    __decorate = function (decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    };
+
+    __param = function (paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); }
+    };
+
+    __metadata = function (metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+    };
+
+    __awaiter = function (thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    };
+
+    __generator = function (thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    };
+
+    __createBinding = function(o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+    };
+
+    __exportStar = function (m, exports) {
+        for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
+    };
+
+    __values = function (o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    };
+
+    __read = function (o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    };
+
+    __spread = function () {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    };
+
+    __spreadArrays = function () {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    };
+
+    __await = function (v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    };
+
+    __asyncGenerator = function (thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);  }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+    };
+
+    __asyncDelegator = function (o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    };
+
+    __asyncValues = function (o) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+    };
+
+    __makeTemplateObject = function (cooked, raw) {
+        if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+        return cooked;
+    };
+
+    __importStar = function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+        result["default"] = mod;
+        return result;
+    };
+
+    __importDefault = function (mod) {
+        return (mod && mod.__esModule) ? mod : { "default": mod };
+    };
+
+    __classPrivateFieldGet = function (receiver, privateMap) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to get private field on non-instance");
+        }
+        return privateMap.get(receiver);
+    };
+
+    __classPrivateFieldSet = function (receiver, privateMap, value) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to set private field on non-instance");
+        }
+        privateMap.set(receiver, value);
+        return value;
+    };
+
+    exporter("__extends", __extends);
+    exporter("__assign", __assign);
+    exporter("__rest", __rest);
+    exporter("__decorate", __decorate);
+    exporter("__param", __param);
+    exporter("__metadata", __metadata);
+    exporter("__awaiter", __awaiter);
+    exporter("__generator", __generator);
+    exporter("__exportStar", __exportStar);
+    exporter("__createBinding", __createBinding);
+    exporter("__values", __values);
+    exporter("__read", __read);
+    exporter("__spread", __spread);
+    exporter("__spreadArrays", __spreadArrays);
+    exporter("__await", __await);
+    exporter("__asyncGenerator", __asyncGenerator);
+    exporter("__asyncDelegator", __asyncDelegator);
+    exporter("__asyncValues", __asyncValues);
+    exporter("__makeTemplateObject", __makeTemplateObject);
+    exporter("__importStar", __importStar);
+    exporter("__importDefault", __importDefault);
+    exporter("__classPrivateFieldGet", __classPrivateFieldGet);
+    exporter("__classPrivateFieldSet", __classPrivateFieldSet);
+});
--- a/node_modules/tsutils/package.json
+++ b/node_modules/tsutils/package.json
@ -0,0 +1,55 @@
+{
+  "name": "tsutils",
+  "version": "2.29.0",
+  "description": "utilities for working with typescript's AST",
+  "scripts": {
+    "compile": "rm -rf {,util,typeguard,test/**}/*.js; tsc -p .",
+    "lint:tslint": "wotan -m @fimbul/valtyr",
+    "lint:wotan": "wotan",
+    "lint": "run-p lint:*",
+    "test": "mocha test/*Tests.js && tslint --test 'test/rules/**/tslint.json'",
+    "verify": "run-s compile lint coverage",
+    "prepublishOnly": "npm run verify",
+    "coverage": "nyc npm test",
+    "report-coverage": "cat ./coverage/lcov.info | coveralls",
+    "github-release": "GITHUB_TOKEN=$(cat ~/github_token.txt) github-release-from-changelog",
+    "postpublish": "git push origin master --tags; npm run github-release"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ajafff/tsutils"
+  },
+  "keywords": [
+    "typescript",
+    "ts",
+    "ast",
+    "typeguard",
+    "utils",
+    "helper",
+    "node"
+  ],
+  "author": "Klaus Meinhardt",
+  "license": "MIT",
+  "devDependencies": {
+    "@fimbul/valtyr": "^0.12.0",
+    "@fimbul/wotan": "^0.12.0",
+    "@types/chai": "^4.0.10",
+    "@types/mocha": "^5.0.0",
+    "@types/node": "^10.0.3",
+    "chai": "^4.1.2",
+    "coveralls": "^3.0.0",
+    "github-release-from-changelog": "^1.3.0",
+    "mocha": "^5.0.0",
+    "npm-run-all": "^4.1.2",
+    "nyc": "^12.0.1",
+    "tslint": "^5.8.0",
+    "tslint-consistent-codestyle": "^1.11.0",
+    "typescript": "^3.0.0-rc"
+  },
+  "peerDependencies": {
+    "typescript": ">=2.1.0 || >=2.1.0-dev || >=2.2.0-dev || >=2.3.0-dev || >=2.4.0-dev || >=2.5.0-dev || >=2.6.0-dev || >=2.7.0-dev || >=2.8.0-dev || >=2.9.0-dev || >= 3.0.0-dev || >= 3.1.0-dev"
+  },
+  "dependencies": {
+    "tslib": "^1.8.1"
+  }
+}
--- a/node_modules/tsutils/typeguard/2.8/index.d.ts
+++ b/node_modules/tsutils/typeguard/2.8/index.d.ts
@ -0,0 +1,2 @@
+export * from './node';
+export * from './type';
--- a/node_modules/tsutils/typeguard/2.8/index.js
+++ b/node_modules/tsutils/typeguard/2.8/index.js
@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./node"), exports);
+tslib_1.__exportStar(require("./type"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpREFBdUI7QUFDdkIsaURBQXVCIn0=
--- a/node_modules/tsutils/typeguard/2.8/node.d.ts
+++ b/node_modules/tsutils/typeguard/2.8/node.d.ts
@ -0,0 +1,153 @@
+import * as ts from 'typescript';
+export declare function isAccessorDeclaration(node: ts.Node): node is ts.AccessorDeclaration;
+export declare function isArrayBindingPattern(node: ts.Node): node is ts.ArrayBindingPattern;
+export declare function isArrayLiteralExpression(node: ts.Node): node is ts.ArrayLiteralExpression;
+export declare function isArrayTypeNode(node: ts.Node): node is ts.ArrayTypeNode;
+export declare function isArrowFunction(node: ts.Node): node is ts.ArrowFunction;
+export declare function isAsExpression(node: ts.Node): node is ts.AsExpression;
+export declare function isAssertionExpression(node: ts.Node): node is ts.AssertionExpression;
+export declare function isAwaitExpression(node: ts.Node): node is ts.AwaitExpression;
+export declare function isBinaryExpression(node: ts.Node): node is ts.BinaryExpression;
+export declare function isBindingElement(node: ts.Node): node is ts.BindingElement;
+export declare function isBindingPattern(node: ts.Node): node is ts.BindingPattern;
+export declare function isBlock(node: ts.Node): node is ts.Block;
+export declare function isBlockLike(node: ts.Node): node is ts.BlockLike;
+export declare function isBreakOrContinueStatement(node: ts.Node): node is ts.BreakOrContinueStatement;
+export declare function isBreakStatement(node: ts.Node): node is ts.BreakStatement;
+export declare function isCallExpression(node: ts.Node): node is ts.CallExpression;
+export declare function isCallLikeExpression(node: ts.Node): node is ts.CallLikeExpression;
+export declare function isCallSignatureDeclaration(node: ts.Node): node is ts.CallSignatureDeclaration;
+export declare function isCaseBlock(node: ts.Node): node is ts.CaseBlock;
+export declare function isCaseClause(node: ts.Node): node is ts.CaseClause;
+export declare function isCaseOrDefaultClause(node: ts.Node): node is ts.CaseOrDefaultClause;
+export declare function isCatchClause(node: ts.Node): node is ts.CatchClause;
+export declare function isClassDeclaration(node: ts.Node): node is ts.ClassDeclaration;
+export declare function isClassExpression(node: ts.Node): node is ts.ClassExpression;
+export declare function isClassLikeDeclaration(node: ts.Node): node is ts.ClassLikeDeclaration;
+export declare function isCommaListExpression(node: ts.Node): node is ts.CommaListExpression;
+export declare function isConditionalExpression(node: ts.Node): node is ts.ConditionalExpression;
+export declare function isConditionalTypeNode(node: ts.Node): node is ts.ConditionalTypeNode;
+export declare function isConstructorDeclaration(node: ts.Node): node is ts.ConstructorDeclaration;
+export declare function isConstructorTypeNode(node: ts.Node): node is ts.ConstructorTypeNode;
+export declare function isConstructSignatureDeclaration(node: ts.Node): node is ts.ConstructSignatureDeclaration;
+export declare function isContinueStatement(node: ts.Node): node is ts.ContinueStatement;
+export declare function isComputedPropertyName(node: ts.Node): node is ts.ComputedPropertyName;
+export declare function isDebuggerStatement(node: ts.Node): node is ts.DebuggerStatement;
+export declare function isDecorator(node: ts.Node): node is ts.Decorator;
+export declare function isDefaultClause(node: ts.Node): node is ts.DefaultClause;
+export declare function isDeleteExpression(node: ts.Node): node is ts.DeleteExpression;
+export declare function isDoStatement(node: ts.Node): node is ts.DoStatement;
+export declare function isElementAccessExpression(node: ts.Node): node is ts.ElementAccessExpression;
+export declare function isEmptyStatement(node: ts.Node): node is ts.EmptyStatement;
+export declare function isEntityName(node: ts.Node): node is ts.EntityName;
+export declare function isEntityNameExpression(node: ts.Node): node is ts.EntityNameExpression;
+export declare function isEnumDeclaration(node: ts.Node): node is ts.EnumDeclaration;
+export declare function isEnumMember(node: ts.Node): node is ts.EnumMember;
+export declare function isExportAssignment(node: ts.Node): node is ts.ExportAssignment;
+export declare function isExportDeclaration(node: ts.Node): node is ts.ExportDeclaration;
+export declare function isExportSpecifier(node: ts.Node): node is ts.ExportSpecifier;
+export declare function isExpression(node: ts.Node): node is ts.Expression;
+export declare function isExpressionStatement(node: ts.Node): node is ts.ExpressionStatement;
+export declare function isExpressionWithTypeArguments(node: ts.Node): node is ts.ExpressionWithTypeArguments;
+export declare function isExternalModuleReference(node: ts.Node): node is ts.ExternalModuleReference;
+export declare function isForInStatement(node: ts.Node): node is ts.ForInStatement;
+export declare function isForInOrOfStatement(node: ts.Node): node is ts.ForInOrOfStatement;
+export declare function isForOfStatement(node: ts.Node): node is ts.ForOfStatement;
+export declare function isForStatement(node: ts.Node): node is ts.ForStatement;
+export declare function isFunctionDeclaration(node: ts.Node): node is ts.FunctionDeclaration;
+export declare function isFunctionExpression(node: ts.Node): node is ts.FunctionExpression;
+export declare function isFunctionTypeNode(node: ts.Node): node is ts.FunctionTypeNode;
+export declare function isGetAccessorDeclaration(node: ts.Node): node is ts.GetAccessorDeclaration;
+export declare function isIdentifier(node: ts.Node): node is ts.Identifier;
+export declare function isIfStatement(node: ts.Node): node is ts.IfStatement;
+export declare function isImportClause(node: ts.Node): node is ts.ImportClause;
+export declare function isImportDeclaration(node: ts.Node): node is ts.ImportDeclaration;
+export declare function isImportEqualsDeclaration(node: ts.Node): node is ts.ImportEqualsDeclaration;
+export declare function isImportSpecifier(node: ts.Node): node is ts.ImportSpecifier;
+export declare function isIndexedAccessTypeNode(node: ts.Node): node is ts.IndexedAccessTypeNode;
+export declare function isIndexSignatureDeclaration(node: ts.Node): node is ts.IndexSignatureDeclaration;
+export declare function isInferTypeNode(node: ts.Node): node is ts.InferTypeNode;
+export declare function isInterfaceDeclaration(node: ts.Node): node is ts.InterfaceDeclaration;
+export declare function isIntersectionTypeNode(node: ts.Node): node is ts.IntersectionTypeNode;
+export declare function isIterationStatement(node: ts.Node): node is ts.IterationStatement;
+export declare function isJsDoc(node: ts.Node): node is ts.JSDoc;
+export declare function isJsxAttribute(node: ts.Node): node is ts.JsxAttribute;
+export declare function isJsxAttributeLike(node: ts.Node): node is ts.JsxAttributeLike;
+export declare function isJsxAttributes(node: ts.Node): node is ts.JsxAttributes;
+export declare function isJsxClosingElement(node: ts.Node): node is ts.JsxClosingElement;
+export declare function isJsxClosingFragment(node: ts.Node): node is ts.JsxClosingFragment;
+export declare function isJsxElement(node: ts.Node): node is ts.JsxElement;
+export declare function isJsxExpression(node: ts.Node): node is ts.JsxExpression;
+export declare function isJsxFramgment(node: ts.Node): node is ts.JsxFragment;
+export declare function isJsxFragment(node: ts.Node): node is ts.JsxFragment;
+export declare function isJsxOpeningElement(node: ts.Node): node is ts.JsxOpeningElement;
+export declare function isJsxOpeningFragment(node: ts.Node): node is ts.JsxOpeningFragment;
+export declare function isJsxOpeningLikeElement(node: ts.Node): node is ts.JsxOpeningLikeElement;
+export declare function isJsxSelfClosingElement(node: ts.Node): node is ts.JsxSelfClosingElement;
+export declare function isJsxSpreadAttribute(node: ts.Node): node is ts.JsxSpreadAttribute;
+export declare function isJsxText(node: ts.Node): node is ts.JsxText;
+export declare function isLabeledStatement(node: ts.Node): node is ts.LabeledStatement;
+export declare function isLiteralExpression(node: ts.Node): node is ts.LiteralExpression;
+export declare function isLiteralTypeNode(node: ts.Node): node is ts.LiteralTypeNode;
+export declare function isMappedTypeNode(node: ts.Node): node is ts.MappedTypeNode;
+export declare function isMetaProperty(node: ts.Node): node is ts.MetaProperty;
+export declare function isMethodDeclaration(node: ts.Node): node is ts.MethodDeclaration;
+export declare function isMethodSignature(node: ts.Node): node is ts.MethodSignature;
+export declare function isModuleBlock(node: ts.Node): node is ts.ModuleBlock;
+export declare function isModuleDeclaration(node: ts.Node): node is ts.ModuleDeclaration;
+export declare function isNamedExports(node: ts.Node): node is ts.NamedExports;
+export declare function isNamedImports(node: ts.Node): node is ts.NamedImports;
+export declare function isNamespaceDeclaration(node: ts.Node): node is ts.NamespaceDeclaration;
+export declare function isNamespaceImport(node: ts.Node): node is ts.NamespaceImport;
+export declare function isNamespaceExportDeclaration(node: ts.Node): node is ts.NamespaceExportDeclaration;
+export declare function isNewExpression(node: ts.Node): node is ts.NewExpression;
+export declare function isNonNullExpression(node: ts.Node): node is ts.NonNullExpression;
+export declare function isNoSubstitutionTemplateLiteral(node: ts.Node): node is ts.NoSubstitutionTemplateLiteral;
+export declare function isNumericLiteral(node: ts.Node): node is ts.NumericLiteral;
+export declare function isObjectBindingPattern(node: ts.Node): node is ts.ObjectBindingPattern;
+export declare function isObjectLiteralExpression(node: ts.Node): node is ts.ObjectLiteralExpression;
+export declare function isOmittedExpression(node: ts.Node): node is ts.OmittedExpression;
+export declare function isParameterDeclaration(node: ts.Node): node is ts.ParameterDeclaration;
+export declare function isParenthesizedExpression(node: ts.Node): node is ts.ParenthesizedExpression;
+export declare function isParenthesizedTypeNode(node: ts.Node): node is ts.ParenthesizedTypeNode;
+export declare function isPostfixUnaryExpression(node: ts.Node): node is ts.PostfixUnaryExpression;
+export declare function isPrefixUnaryExpression(node: ts.Node): node is ts.PrefixUnaryExpression;
+export declare function isPropertyAccessExpression(node: ts.Node): node is ts.PropertyAccessExpression;
+export declare function isPropertyAssignment(node: ts.Node): node is ts.PropertyAssignment;
+export declare function isPropertyDeclaration(node: ts.Node): node is ts.PropertyDeclaration;
+export declare function isPropertySignature(node: ts.Node): node is ts.PropertySignature;
+export declare function isQualifiedName(node: ts.Node): node is ts.QualifiedName;
+export declare function isRegularExpressionLiteral(node: ts.Node): node is ts.RegularExpressionLiteral;
+export declare function isReturnStatement(node: ts.Node): node is ts.ReturnStatement;
+export declare function isSetAccessorDeclaration(node: ts.Node): node is ts.SetAccessorDeclaration;
+export declare function isShorthandPropertyAssignment(node: ts.Node): node is ts.ShorthandPropertyAssignment;
+export declare function isSignatureDeclaration(node: ts.Node): node is ts.SignatureDeclaration;
+export declare function isSourceFile(node: ts.Node): node is ts.SourceFile;
+export declare function isSpreadAssignment(node: ts.Node): node is ts.SpreadAssignment;
+export declare function isSpreadElement(node: ts.Node): node is ts.SpreadElement;
+export declare function isStringLiteral(node: ts.Node): node is ts.StringLiteral;
+export declare function isSwitchStatement(node: ts.Node): node is ts.SwitchStatement;
+export declare function isSyntaxList(node: ts.Node): node is ts.SyntaxList;
+export declare function isTaggedTemplateExpression(node: ts.Node): node is ts.TaggedTemplateExpression;
+export declare function isTemplateExpression(node: ts.Node): node is ts.TemplateExpression;
+export declare function isTemplateLiteral(node: ts.Node): node is ts.TemplateLiteral;
+export declare function isTextualLiteral(node: ts.Node): node is ts.LiteralExpression;
+export declare function isThrowStatement(node: ts.Node): node is ts.ThrowStatement;
+export declare function isTryStatement(node: ts.Node): node is ts.TryStatement;
+export declare function isTupleTypeNode(node: ts.Node): node is ts.TupleTypeNode;
+export declare function isTypeAliasDeclaration(node: ts.Node): node is ts.TypeAliasDeclaration;
+export declare function isTypeAssertion(node: ts.Node): node is ts.TypeAssertion;
+export declare function isTypeLiteralNode(node: ts.Node): node is ts.TypeLiteralNode;
+export declare function isTypeOfExpression(node: ts.Node): node is ts.TypeOfExpression;
+export declare function isTypeOperatorNode(node: ts.Node): node is ts.TypeOperatorNode;
+export declare function isTypeParameterDeclaration(node: ts.Node): node is ts.TypeParameterDeclaration;
+export declare function isTypePredicateNode(node: ts.Node): node is ts.TypePredicateNode;
+export declare function isTypeReferenceNode(node: ts.Node): node is ts.TypeReferenceNode;
+export declare function isTypeQueryNode(node: ts.Node): node is ts.TypeQueryNode;
+export declare function isUnionTypeNode(node: ts.Node): node is ts.UnionTypeNode;
+export declare function isVariableDeclaration(node: ts.Node): node is ts.VariableDeclaration;
+export declare function isVariableStatement(node: ts.Node): node is ts.VariableStatement;
+export declare function isVariableDeclarationList(node: ts.Node): node is ts.VariableDeclarationList;
+export declare function isVoidExpression(node: ts.Node): node is ts.VoidExpression;
+export declare function isWhileStatement(node: ts.Node): node is ts.WhileStatement;
+export declare function isWithStatement(node: ts.Node): node is ts.WithStatement;
--- a/node_modules/tsutils/typeguard/2.8/node.js
+++ b/node_modules/tsutils/typeguard/2.8/node.js
--- a/node_modules/tsutils/typeguard/2.8/type.d.ts
+++ b/node_modules/tsutils/typeguard/2.8/type.d.ts
@ -0,0 +1,18 @@
+import * as ts from 'typescript';
+export declare function isConditionalType(type: ts.Type): type is ts.ConditionalType;
+export declare function isEnumType(type: ts.Type): type is ts.EnumType;
+export declare function isGenericType(type: ts.Type): type is ts.GenericType;
+export declare function isIndexedAccessType(type: ts.Type): type is ts.IndexedAccessType;
+export declare function isIndexedAccessype(type: ts.Type): type is ts.IndexType;
+export declare function isInstantiableType(type: ts.Type): type is ts.InstantiableType;
+export declare function isInterfaceType(type: ts.Type): type is ts.InterfaceType;
+export declare function isIntersectionType(type: ts.Type): type is ts.IntersectionType;
+export declare function isLiteralType(type: ts.Type): type is ts.LiteralType;
+export declare function isObjectType(type: ts.Type): type is ts.ObjectType;
+export declare function isSubstitutionType(type: ts.Type): type is ts.SubstitutionType;
+export declare function isTypeParameter(type: ts.Type): type is ts.TypeParameter;
+export declare function isTypeReference(type: ts.Type): type is ts.TypeReference;
+export declare function isTypeVariable(type: ts.Type): type is ts.TypeParameter | ts.IndexedAccessType;
+export declare function isUnionOrIntersectionType(type: ts.Type): type is ts.UnionOrIntersectionType;
+export declare function isUnionType(type: ts.Type): type is ts.UnionType;
+export declare function isUniqueESSymbolType(type: ts.Type): type is ts.UniqueESSymbolType;
--- a/node_modules/tsutils/typeguard/2.8/type.js
+++ b/node_modules/tsutils/typeguard/2.8/type.js
@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ts = require("typescript");
+function isConditionalType(type) {
+    return (type.flags & ts.TypeFlags.Conditional) !== 0;
+}
+exports.isConditionalType = isConditionalType;
+function isEnumType(type) {
+    return (type.flags & ts.TypeFlags.Enum) !== 0;
+}
+exports.isEnumType = isEnumType;
+function isGenericType(type) {
+    return (type.flags & ts.TypeFlags.Object) !== 0 &&
+        (type.objectFlags & ts.ObjectFlags.ClassOrInterface) !== 0 &&
+        (type.objectFlags & ts.ObjectFlags.Reference) !== 0;
+}
+exports.isGenericType = isGenericType;
+function isIndexedAccessType(type) {
+    return (type.flags & ts.TypeFlags.IndexedAccess) !== 0;
+}
+exports.isIndexedAccessType = isIndexedAccessType;
+function isIndexedAccessype(type) {
+    return (type.flags & ts.TypeFlags.Index) !== 0;
+}
+exports.isIndexedAccessype = isIndexedAccessype;
+function isInstantiableType(type) {
+    return (type.flags & ts.TypeFlags.Instantiable) !== 0;
+}
+exports.isInstantiableType = isInstantiableType;
+function isInterfaceType(type) {
+    return (type.flags & ts.TypeFlags.Object) !== 0 &&
+        (type.objectFlags & ts.ObjectFlags.ClassOrInterface) !== 0;
+}
+exports.isInterfaceType = isInterfaceType;
+function isIntersectionType(type) {
+    return (type.flags & ts.TypeFlags.Intersection) !== 0;
+}
+exports.isIntersectionType = isIntersectionType;
+function isLiteralType(type) {
+    return (type.flags & ts.TypeFlags.StringOrNumberLiteral) !== 0;
+}
+exports.isLiteralType = isLiteralType;
+function isObjectType(type) {
+    return (type.flags & ts.TypeFlags.Object) !== 0;
+}
+exports.isObjectType = isObjectType;
+function isSubstitutionType(type) {
+    return (type.flags & ts.TypeFlags.Substitution) !== 0;
+}
+exports.isSubstitutionType = isSubstitutionType;
+function isTypeParameter(type) {
+    return (type.flags & ts.TypeFlags.TypeParameter) !== 0;
+}
+exports.isTypeParameter = isTypeParameter;
+function isTypeReference(type) {
+    return (type.flags & ts.TypeFlags.Object) !== 0 &&
+        (type.objectFlags & ts.ObjectFlags.Reference) !== 0;
+}
+exports.isTypeReference = isTypeReference;
+function isTypeVariable(type) {
+    return (type.flags & ts.TypeFlags.TypeVariable) !== 0;
+}
+exports.isTypeVariable = isTypeVariable;
+function isUnionOrIntersectionType(type) {
+    return (type.flags & ts.TypeFlags.UnionOrIntersection) !== 0;
+}
+exports.isUnionOrIntersectionType = isUnionOrIntersectionType;
+function isUnionType(type) {
+    return (type.flags & ts.TypeFlags.Union) !== 0;
+}
+exports.isUnionType = isUnionType;
+function isUniqueESSymbolType(type) {
+    return (type.flags & ts.TypeFlags.UniqueESSymbol) !== 0;
+}
+exports.isUniqueESSymbolType = isUniqueESSymbolType;
+//# sourceMappingURL=data:application/json;base64,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
--- a/node_modules/tsutils/typeguard/2.9/index.d.ts
+++ b/node_modules/tsutils/typeguard/2.9/index.d.ts
@ -0,0 +1,2 @@
+export * from './node';
+export * from './type';
--- a/node_modules/tsutils/typeguard/2.9/index.js
+++ b/node_modules/tsutils/typeguard/2.9/index.js
@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./node"), exports);
+tslib_1.__exportStar(require("./type"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpREFBdUI7QUFDdkIsaURBQXVCIn0=
--- a/node_modules/tsutils/typeguard/2.9/node.d.ts
+++ b/node_modules/tsutils/typeguard/2.9/node.d.ts
@ -0,0 +1,3 @@
+export * from '../2.8/node';
+import * as ts from 'typescript';
+export declare function isImportTypeNode(node: ts.Node): node is ts.ImportTypeNode;
--- a/node_modules/tsutils/typeguard/2.9/node.js
+++ b/node_modules/tsutils/typeguard/2.9/node.js
@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("../2.8/node"), exports);
+var ts = require("typescript");
+function isImportTypeNode(node) {
+    return node.kind === ts.SyntaxKind.ImportType;
+}
+exports.isImportTypeNode = isImportTypeNode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm5vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsc0RBQTRCO0FBRTVCLCtCQUFpQztBQUVqQyxTQUFnQixnQkFBZ0IsQ0FBQyxJQUFhO0lBQzFDLE9BQU8sSUFBSSxDQUFDLElBQUksS0FBSyxFQUFFLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBQztBQUNsRCxDQUFDO0FBRkQsNENBRUMifQ==
--- a/node_modules/tsutils/typeguard/2.9/type.d.ts
+++ b/node_modules/tsutils/typeguard/2.9/type.d.ts
@ -0,0 +1 @@
+export * from '../2.8/type';
--- a/node_modules/tsutils/typeguard/2.9/type.js
+++ b/node_modules/tsutils/typeguard/2.9/type.js
@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("../2.8/type"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsc0RBQTRCIn0=
--- a/node_modules/tsutils/typeguard/3.0/index.d.ts
+++ b/node_modules/tsutils/typeguard/3.0/index.d.ts
@ -0,0 +1,2 @@
+export * from './node';
+export * from './type';
--- a/node_modules/tsutils/typeguard/3.0/index.js
+++ b/node_modules/tsutils/typeguard/3.0/index.js
@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./node"), exports);
+tslib_1.__exportStar(require("./type"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpREFBdUI7QUFDdkIsaURBQXVCIn0=
--- a/node_modules/tsutils/typeguard/3.0/node.d.ts
+++ b/node_modules/tsutils/typeguard/3.0/node.d.ts
@ -0,0 +1,5 @@
+export * from '../2.9/node';
+import * as ts from 'typescript';
+export declare function isOptionalTypeNode(node: ts.Node): node is ts.OptionalTypeNode;
+export declare function isRestTypeNode(node: ts.Node): node is ts.RestTypeNode;
+export declare function isSyntheticExpression(node: ts.Node): node is ts.SyntheticExpression;
--- a/node_modules/tsutils/typeguard/3.0/node.js
+++ b/node_modules/tsutils/typeguard/3.0/node.js
@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("../2.9/node"), exports);
+var ts = require("typescript");
+function isOptionalTypeNode(node) {
+    return node.kind === ts.SyntaxKind.OptionalType;
+}
+exports.isOptionalTypeNode = isOptionalTypeNode;
+function isRestTypeNode(node) {
+    return node.kind === ts.SyntaxKind.RestType;
+}
+exports.isRestTypeNode = isRestTypeNode;
+function isSyntheticExpression(node) {
+    return node.kind === ts.SyntaxKind.SyntheticExpression;
+}
+exports.isSyntheticExpression = isSyntheticExpression;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm5vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsc0RBQTRCO0FBRTVCLCtCQUFpQztBQUVqQyxTQUFnQixrQkFBa0IsQ0FBQyxJQUFhO0lBQzVDLE9BQU8sSUFBSSxDQUFDLElBQUksS0FBSyxFQUFFLENBQUMsVUFBVSxDQUFDLFlBQVksQ0FBQztBQUNwRCxDQUFDO0FBRkQsZ0RBRUM7QUFFRCxTQUFnQixjQUFjLENBQUMsSUFBYTtJQUN4QyxPQUFPLElBQUksQ0FBQyxJQUFJLEtBQUssRUFBRSxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQUM7QUFDaEQsQ0FBQztBQUZELHdDQUVDO0FBRUQsU0FBZ0IscUJBQXFCLENBQUMsSUFBYTtJQUMvQyxPQUFPLElBQUksQ0FBQyxJQUFJLEtBQUssRUFBRSxDQUFDLFVBQVUsQ0FBQyxtQkFBbUIsQ0FBQztBQUMzRCxDQUFDO0FBRkQsc0RBRUMifQ==
--- a/node_modules/tsutils/typeguard/3.0/type.d.ts
+++ b/node_modules/tsutils/typeguard/3.0/type.d.ts
@ -0,0 +1,3 @@
+export * from '../2.9/type';
+import * as ts from 'typescript';
+export declare function isTupleType(type: ts.Type): type is ts.TupleType;
--- a/node_modules/tsutils/typeguard/3.0/type.js
+++ b/node_modules/tsutils/typeguard/3.0/type.js
@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("../2.9/type"), exports);
+var ts = require("typescript");
+function isTupleType(type) {
+    return (type.flags & ts.TypeFlags.Object && type.objectFlags & ts.ObjectFlags.Tuple) !== 0;
+}
+exports.isTupleType = isTupleType;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsc0RBQTRCO0FBRTVCLCtCQUFpQztBQUVqQyxTQUFnQixXQUFXLENBQUMsSUFBYTtJQUNyQyxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssR0FBRyxFQUFFLENBQUMsU0FBUyxDQUFDLE1BQU0sSUFBb0IsSUFBSyxDQUFDLFdBQVcsR0FBRyxFQUFFLENBQUMsV0FBVyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUNoSCxDQUFDO0FBRkQsa0NBRUMifQ==
--- a/node_modules/tsutils/typeguard/index.d.ts
+++ b/node_modules/tsutils/typeguard/index.d.ts
@ -0,0 +1,2 @@
+export * from './node';
+export * from './type';
--- a/node_modules/tsutils/typeguard/index.js
+++ b/node_modules/tsutils/typeguard/index.js
@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./node"), exports);
+tslib_1.__exportStar(require("./type"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpREFBdUI7QUFDdkIsaURBQXVCIn0=
--- a/node_modules/tsutils/typeguard/next/index.d.ts
+++ b/node_modules/tsutils/typeguard/next/index.d.ts
@ -0,0 +1,2 @@
+export * from './node';
+export * from './type';
--- a/node_modules/tsutils/typeguard/next/index.js
+++ b/node_modules/tsutils/typeguard/next/index.js
@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./node"), exports);
+tslib_1.__exportStar(require("./type"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpREFBdUI7QUFDdkIsaURBQXVCIn0=
--- a/node_modules/tsutils/typeguard/next/node.d.ts
+++ b/node_modules/tsutils/typeguard/next/node.d.ts
@ -0,0 +1 @@
+export * from '../3.0/node';
--- a/node_modules/tsutils/typeguard/next/node.js
+++ b/node_modules/tsutils/typeguard/next/node.js
@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("../3.0/node"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm5vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsc0RBQTRCIn0=
--- a/node_modules/tsutils/typeguard/next/type.d.ts
+++ b/node_modules/tsutils/typeguard/next/type.d.ts
@ -0,0 +1 @@
+export * from '../3.0/type';
--- a/node_modules/tsutils/typeguard/next/type.js
+++ b/node_modules/tsutils/typeguard/next/type.js
@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("../3.0/type"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsc0RBQTRCIn0=
--- a/node_modules/tsutils/typeguard/node.d.ts
+++ b/node_modules/tsutils/typeguard/node.d.ts
@ -0,0 +1 @@
+export * from './2.9/node';
--- a/node_modules/tsutils/typeguard/node.js
+++ b/node_modules/tsutils/typeguard/node.js
@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./2.9/node"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm5vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscURBQTJCIn0=
--- a/node_modules/tsutils/typeguard/type.d.ts
+++ b/node_modules/tsutils/typeguard/type.d.ts
@ -0,0 +1 @@
+export * from './2.9/type';
--- a/node_modules/tsutils/typeguard/type.js
+++ b/node_modules/tsutils/typeguard/type.js
@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./2.9/type"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscURBQTJCIn0=
--- a/node_modules/tsutils/util/control-flow.d.ts
+++ b/node_modules/tsutils/util/control-flow.d.ts
@ -0,0 +1,9 @@
+import * as ts from 'typescript';
+export declare function endsControlFlow(statement: ts.Statement | ts.BlockLike): boolean;
+export declare type ControlFlowStatement = ts.BreakStatement | ts.ContinueStatement | ts.ReturnStatement | ts.ThrowStatement;
+export interface ControlFlowEnd {
+    readonly statements: ReadonlyArray<ControlFlowStatement>;
+    readonly end: boolean;
+}
+export declare function getControlFlowEnd(statement: ts.Statement | ts.BlockLike): ControlFlowEnd;
+export declare function getControlFlowEnd(statement: ts.Statement | ts.BlockLike, label?: ts.Identifier): ControlFlowEnd;
--- a/node_modules/tsutils/util/control-flow.js
+++ b/node_modules/tsutils/util/control-flow.js
--- a/node_modules/tsutils/util/convert-ast.d.ts
+++ b/node_modules/tsutils/util/convert-ast.d.ts
@ -0,0 +1,19 @@
+import * as ts from 'typescript';
+export interface NodeWrap {
+    node: ts.Node;
+    kind: ts.SyntaxKind;
+    children: NodeWrap[];
+    next?: NodeWrap;
+    skip?: NodeWrap;
+    parent?: NodeWrap;
+}
+export interface WrappedAst extends NodeWrap {
+    next: NodeWrap;
+    skip: undefined;
+    parent: undefined;
+}
+export interface ConvertedAst {
+    wrapped: WrappedAst;
+    flat: ReadonlyArray<ts.Node>;
+}
+export declare function convertAst(sourceFile: ts.SourceFile): ConvertedAst;
--- a/node_modules/tsutils/util/convert-ast.js
+++ b/node_modules/tsutils/util/convert-ast.js
@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ts = require("typescript");
+var util_1 = require("./util");
+function convertAst(sourceFile) {
+    var wrapped = {
+        node: sourceFile,
+        parent: undefined,
+        kind: ts.SyntaxKind.SourceFile,
+        children: [],
+        next: undefined,
+        skip: undefined,
+    };
+    var flat = [];
+    var current = wrapped;
+    var previous = current;
+    ts.forEachChild(sourceFile, function wrap(node) {
+        flat.push(node);
+        var parent = current;
+        previous.next = current = {
+            node: node,
+            parent: parent,
+            kind: node.kind,
+            children: [],
+            next: undefined,
+            skip: undefined,
+        };
+        if (previous !== parent)
+            setSkip(previous, current);
+        previous = current;
+        parent.children.push(current);
+        if (util_1.isNodeKind(node.kind))
+            ts.forEachChild(node, wrap);
+        current = parent;
+    });
+    return {
+        wrapped: wrapped,
+        flat: flat,
+    };
+}
+exports.convertAst = convertAst;
+function setSkip(node, skip) {
+    do {
+        node.skip = skip;
+        node = node.parent;
+    } while (node !== skip.parent);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udmVydC1hc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjb252ZXJ0LWFzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLCtCQUFpQztBQUNqQywrQkFBb0M7QUFtQ3BDLFNBQWdCLFVBQVUsQ0FBQyxVQUF5QjtJQUNoRCxJQUFNLE9BQU8sR0FBZTtRQUN4QixJQUFJLEVBQUUsVUFBVTtRQUNoQixNQUFNLEVBQUUsU0FBUztRQUNqQixJQUFJLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxVQUFVO1FBQzlCLFFBQVEsRUFBRSxFQUFFO1FBQ1osSUFBSSxFQUFPLFNBQVM7UUFDcEIsSUFBSSxFQUFFLFNBQVM7S0FDbEIsQ0FBQztJQUNGLElBQU0sSUFBSSxHQUFjLEVBQUUsQ0FBQztJQUMzQixJQUFJLE9BQU8sR0FBYSxPQUFPLENBQUM7SUFDaEMsSUFBSSxRQUFRLEdBQUcsT0FBTyxDQUFDO0lBQ3ZCLEVBQUUsQ0FBQyxZQUFZLENBQUMsVUFBVSxFQUFFLFNBQVMsSUFBSSxDQUFDLElBQUk7UUFDMUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNoQixJQUFNLE1BQU0sR0FBRyxPQUFPLENBQUM7UUFDdkIsUUFBUSxDQUFDLElBQUksR0FBRyxPQUFPLEdBQUc7WUFDdEIsSUFBSSxNQUFBO1lBQ0osTUFBTSxRQUFBO1lBQ04sSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJO1lBQ2YsUUFBUSxFQUFFLEVBQUU7WUFDWixJQUFJLEVBQUUsU0FBUztZQUNmLElBQUksRUFBRSxTQUFTO1NBQ2xCLENBQUM7UUFDRixJQUFJLFFBQVEsS0FBSyxNQUFNO1lBQ25CLE9BQU8sQ0FBQyxRQUFRLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFFL0IsUUFBUSxHQUFHLE9BQU8sQ0FBQztRQUNuQixNQUFNLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUU5QixJQUFJLGlCQUFVLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQztZQUNyQixFQUFFLENBQUMsWUFBWSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztRQUVoQyxPQUFPLEdBQUcsTUFBTSxDQUFDO0lBQ3JCLENBQUMsQ0FBQyxDQUFDO0lBRUgsT0FBTztRQUNILE9BQU8sU0FBQTtRQUNQLElBQUksTUFBQTtLQUNQLENBQUM7QUFDTixDQUFDO0FBdkNELGdDQXVDQztBQUVELFNBQVMsT0FBTyxDQUFDLElBQWMsRUFBRSxJQUFjO0lBQzNDLEdBQUc7UUFDQyxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztRQUNqQixJQUFJLEdBQUcsSUFBSSxDQUFDLE1BQU8sQ0FBQztLQUN2QixRQUFRLElBQUksS0FBSyxJQUFJLENBQUMsTUFBTSxFQUFFO0FBQ25DLENBQUMifQ==
--- a/node_modules/tsutils/util/index.d.ts
+++ b/node_modules/tsutils/util/index.d.ts
@ -0,0 +1,5 @@
+export * from './util';
+export * from './usage';
+export * from './control-flow';
+export * from './type';
+export * from './convert-ast';
--- a/node_modules/tsutils/util/index.js
+++ b/node_modules/tsutils/util/index.js
@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./util"), exports);
+tslib_1.__exportStar(require("./usage"), exports);
+tslib_1.__exportStar(require("./control-flow"), exports);
+tslib_1.__exportStar(require("./type"), exports);
+tslib_1.__exportStar(require("./convert-ast"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpREFBdUI7QUFDdkIsa0RBQXdCO0FBQ3hCLHlEQUErQjtBQUMvQixpREFBdUI7QUFDdkIsd0RBQThCIn0=
--- a/node_modules/tsutils/util/type.d.ts
+++ b/node_modules/tsutils/util/type.d.ts
@ -0,0 +1,9 @@
+import * as ts from 'typescript';
+export declare function isEmptyObjectType(type: ts.Type): type is ts.ObjectType;
+export declare function removeOptionalityFromType(checker: ts.TypeChecker, type: ts.Type): ts.Type;
+export declare function isTypeAssignableToNumber(checker: ts.TypeChecker, type: ts.Type): boolean;
+export declare function isTypeAssignableToString(checker: ts.TypeChecker, type: ts.Type): boolean;
+export declare function getCallSignaturesOfType(type: ts.Type): ReadonlyArray<ts.Signature>;
+export declare function unionTypeParts(type: ts.Type): ts.Type[];
+export declare function isThenableType(checker: ts.TypeChecker, node: ts.Expression, type?: ts.Type): boolean;
+export declare function isFalsyType(type: ts.Type): boolean;
--- a/node_modules/tsutils/util/type.js
+++ b/node_modules/tsutils/util/type.js
--- a/node_modules/tsutils/util/usage.d.ts
+++ b/node_modules/tsutils/util/usage.d.ts
@ -0,0 +1,30 @@
+import * as ts from 'typescript';
+export interface VariableInfo {
+    domain: DeclarationDomain;
+    exported: boolean;
+    uses: VariableUse[];
+    inGlobalScope: boolean;
+    declarations: ts.Identifier[];
+}
+export interface VariableUse {
+    domain: UsageDomain;
+    location: ts.Identifier;
+}
+export declare const enum DeclarationDomain {
+    Namespace = 1,
+    Type = 2,
+    Value = 4,
+    Import = 8,
+    Any = 7
+}
+export declare const enum UsageDomain {
+    Namespace = 1,
+    Type = 2,
+    Value = 4,
+    ValueOrNamespace = 5,
+    Any = 7,
+    TypeQuery = 8
+}
+export declare function getUsageDomain(node: ts.Identifier): UsageDomain | undefined;
+export declare function getDeclarationDomain(node: ts.Identifier): DeclarationDomain | undefined;
+export declare function collectVariableUsage(sourceFile: ts.SourceFile): Map<ts.Identifier, VariableInfo>;
--- a/node_modules/tsutils/util/usage.js
+++ b/node_modules/tsutils/util/usage.js
--- a/node_modules/tsutils/util/util.d.ts
+++ b/node_modules/tsutils/util/util.d.ts
@ -0,0 +1,121 @@
+import * as ts from 'typescript';
+import { NodeWrap } from './convert-ast';
+export * from './control-flow';
+export declare function getChildOfKind<T extends ts.SyntaxKind>(node: ts.Node, kind: T, sourceFile?: ts.SourceFile): ts.Token<T> | undefined;
+export declare function isTokenKind(kind: ts.SyntaxKind): boolean;
+export declare function isNodeKind(kind: ts.SyntaxKind): boolean;
+export declare function isAssignmentKind(kind: ts.SyntaxKind): boolean;
+export declare function isTypeNodeKind(kind: ts.SyntaxKind): boolean;
+export declare function isJsDocKind(kind: ts.SyntaxKind): boolean;
+export declare function isThisParameter(parameter: ts.ParameterDeclaration): boolean;
+export declare function getModifier(node: ts.Node, kind: ts.Modifier['kind']): ts.Modifier | undefined;
+export declare function hasModifier(modifiers: ts.ModifiersArray | undefined, ...kinds: Array<ts.Modifier['kind']>): boolean;
+export declare function isParameterProperty(node: ts.ParameterDeclaration): boolean;
+export declare function hasAccessModifier(node: ts.ClassElement | ts.ParameterDeclaration): boolean;
+export declare const isNodeFlagSet: (node: ts.Node, flag: ts.NodeFlags) => boolean;
+export declare const isTypeFlagSet: (type: ts.Type, flag: ts.TypeFlags) => boolean;
+export declare const isSymbolFlagSet: (symbol: ts.Symbol, flag: ts.SymbolFlags) => boolean;
+export declare function isObjectFlagSet(objectType: ts.ObjectType, flag: ts.ObjectFlags): boolean;
+export declare function isModifierFlagSet(node: ts.Declaration, flag: ts.ModifierFlags): boolean;
+export declare function isModifierFlagSet(node: ts.Node, flag: ts.ModifierFlags): boolean;
+export declare function isModfierFlagSet(node: ts.Node, flag: ts.ModifierFlags): boolean;
+export declare function getPreviousStatement(statement: ts.Statement): ts.Statement | undefined;
+export declare function getNextStatement(statement: ts.Statement): ts.Statement | undefined;
+export declare function getPreviousToken(node: ts.Node, sourceFile?: ts.SourceFile): ts.Node | undefined;
+export declare function getNextToken(node: ts.Node, sourceFile?: ts.SourceFile): ts.Node | undefined;
+export declare function getTokenAtPosition(parent: ts.Node, pos: number, sourceFile?: ts.SourceFile): ts.Node | undefined;
+export declare function getCommentAtPosition(sourceFile: ts.SourceFile, pos: number, parent?: ts.Node): ts.CommentRange | undefined;
+export declare function isPositionInComment(sourceFile: ts.SourceFile, pos: number, parent?: ts.Node): boolean;
+export declare function getWrappedNodeAtPosition(wrap: NodeWrap, pos: number): NodeWrap | undefined;
+export declare function getPropertyName(propertyName: ts.PropertyName): string | undefined;
+export declare function forEachDestructuringIdentifier<T>(pattern: ts.BindingPattern, fn: (element: ts.BindingElement & {
+    name: ts.Identifier;
+}) => T): T | undefined;
+export declare function forEachDeclaredVariable<T>(declarationList: ts.VariableDeclarationList, cb: (element: (ts.VariableDeclaration | ts.BindingElement) & {
+    name: ts.Identifier;
+}) => T): T | undefined;
+export declare const enum VariableDeclarationKind {
+    Var = 0,
+    Let = 1,
+    Const = 2
+}
+export declare function getVariableDeclarationKind(declarationList: ts.VariableDeclarationList): VariableDeclarationKind;
+export declare function isBlockScopedVariableDeclarationList(declarationList: ts.VariableDeclarationList): boolean;
+export declare function isBlockScopedVariableDeclaration(declaration: ts.VariableDeclaration): boolean;
+export declare const enum ScopeBoundary {
+    None = 0,
+    Function = 1,
+    Block = 2
+}
+export declare function isScopeBoundary(node: ts.Node): ScopeBoundary;
+export declare function isFunctionScopeBoundary(node: ts.Node): boolean;
+export declare function isBlockScopeBoundary(node: ts.Node): boolean;
+export declare function hasOwnThisReference(node: ts.Node): boolean;
+export declare function isFunctionWithBody(node: ts.Node): node is ts.FunctionLikeDeclaration;
+export declare function forEachToken(node: ts.Node, cb: (node: ts.Node) => void, sourceFile?: ts.SourceFile): void;
+export declare type ForEachTokenCallback = (fullText: string, kind: ts.SyntaxKind, range: ts.TextRange, parent: ts.Node) => void;
+export declare function forEachTokenWithTrivia(node: ts.Node, cb: ForEachTokenCallback, sourceFile?: ts.SourceFile): void;
+export declare type ForEachCommentCallback = (fullText: string, comment: ts.CommentRange) => void;
+export declare function forEachComment(node: ts.Node, cb: ForEachCommentCallback, sourceFile?: ts.SourceFile): void;
+export interface LineRange extends ts.TextRange {
+    contentLength: number;
+}
+export declare function getLineRanges(sourceFile: ts.SourceFile): LineRange[];
+export declare function getLineBreakStyle(sourceFile: ts.SourceFile): "\n" | "\r\n";
+export declare function isValidIdentifier(text: string): boolean;
+export declare function isValidPropertyAccess(text: string): boolean;
+export declare function isValidPropertyName(text: string): boolean;
+export declare function isValidNumericLiteral(text: string): boolean;
+export declare function isSameLine(sourceFile: ts.SourceFile, pos1: number, pos2: number): boolean;
+export declare const enum SideEffectOptions {
+    None = 0,
+    TaggedTemplate = 1,
+    Constructor = 2,
+    JsxElement = 4
+}
+export declare function hasSideEffects(node: ts.Expression, options?: SideEffectOptions): boolean;
+export declare function getDeclarationOfBindingElement(node: ts.BindingElement): ts.VariableDeclaration | ts.ParameterDeclaration;
+export declare function isExpressionValueUsed(node: ts.Expression): boolean;
+export declare function isReassignmentTarget(node: ts.Expression): boolean;
+export declare function getIdentifierText(node: ts.Identifier): string;
+export declare function canHaveJsDoc(node: ts.Node): node is ts.HasJSDoc;
+export declare function getJsDoc(node: ts.Node, sourceFile?: ts.SourceFile): ts.JSDoc[];
+export declare function parseJsDocOfNode(node: ts.Node, considerTrailingComments?: boolean, sourceFile?: ts.SourceFile): ts.JSDoc[];
+export declare const enum ImportKind {
+    ImportDeclaration = 1,
+    ImportEquals = 2,
+    ExportFrom = 4,
+    DynamicImport = 8,
+    Require = 16,
+    ImportType = 32,
+    All = 63,
+    AllImports = 59,
+    AllStaticImports = 3,
+    AllImportExpressions = 24,
+    AllRequireLike = 18
+}
+export declare const enum ImportOptions {
+    ImportDeclaration = 1,
+    ImportEquals = 2,
+    ExportFrom = 4,
+    DynamicImport = 8,
+    Require = 16,
+    All = 31,
+    AllImports = 27,
+    AllStaticImports = 3,
+    AllDynamic = 24,
+    AllRequireLike = 18
+}
+export declare function findImports(sourceFile: ts.SourceFile, kinds: ImportKind): ts.LiteralExpression[];
+export declare function findImports(sourceFile: ts.SourceFile, options: ImportOptions): ts.LiteralExpression[];
+export declare function isStatementInAmbientContext(node: ts.Statement): boolean;
+export declare function isAmbientModuleBlock(node: ts.Node): node is ts.ModuleBlock;
+export declare function getIIFE(func: ts.FunctionExpression | ts.ArrowFunction): ts.CallExpression | undefined;
+export declare type StrictCompilerOption = 'noImplicitAny' | 'noImplicitThis' | 'strictNullChecks' | 'strictFunctionTypes' | 'strictPropertyInitialization' | 'alwaysStrict';
+export declare function isStrictCompilerOptionEnabled(options: ts.CompilerOptions, option: StrictCompilerOption): boolean;
+export declare type BooleanCompilerOptions = {
+    [K in keyof ts.CompilerOptions]: NonNullable<ts.CompilerOptions[K]> extends boolean ? K : never;
+} extends {
+    [_ in keyof ts.CompilerOptions]: infer U;
+} ? U : never;
+export declare function isCompilerOptionEnabled(options: ts.CompilerOptions, option: BooleanCompilerOptions | 'stripInternal'): boolean;
--- a/node_modules/tsutils/util/util.js
+++ b/node_modules/tsutils/util/util.js
--- a/node_modules/tsutils/yarn.lock
+++ b/node_modules/tsutils/yarn.lock