add linting (and some initial fixes)

19 files changed, 1812 insertions, 0 deletions

diff --git a/node_modules/tsutils/.npmignore b/node_modules/tsutils/.npmignore
new file mode 100644
index 000000000..adb797021
--- /dev/null
+++ b/node_modules/tsutils/.npmignore
@@ -0,0 +1,5 @@
+.gitignore
+*.json
+*.ts
+!*.d.ts
+/test
\ No newline at end of file
diff --git a/node_modules/tsutils/CHANGELOG.md b/node_modules/tsutils/CHANGELOG.md
new file mode 100644
index 000000000..a09528c90
--- /dev/null
+++ b/node_modules/tsutils/CHANGELOG.md
@@ -0,0 +1,125 @@
+# Change Log
+
+## v2.2.0
+**Bugfixes:**
+* Fixed bit value of `SideEffectOptions.JsxElement` to be a power of 2
+
+**Features:**
+* Added utilities: `getTokenAtPosition` and `isPositionInComment`
+
+## v2.1.0
+**Features:**
+* Added typeguard `isExpression`
+* Added utilities: `hasSideEffects`, `getDeclarationOfBindingElement`
+
+## v2.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')`)
+
+## v1.9.1
+**Bugfixes:**
+* `isObjectFlagSet` now uses the correct `objectFlags` property
+
+## v1.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` 
+
+## v1.8.0
+**Features:**
+* Support peer dependency of typescript nightlies of 2.4.0
+* Added typeguards: `isJsxAttributes`, `isIntersectionTypeNode`, `isTypeOperatorNode`, `isTypePredicateNode`, `isTypeQueryNode`, `isUnionTypeNode`
+
+## v1.7.0
+**Bugfixes:**
+* `isFunctionScopeBoundary` now handles Interfaces, TypeAliases, FunctionSignatures, etc
+
+**Features:**
+* Added utilities: `isThisParameter`, `isSameLine` and `isFunctionWithBody`
+
+## v1.6.0
+**Features:**
+* Add `isValidPropertyAccess`, `isValidNumericLiteral` and `isValidPropertyName`
+
+## v1.5.0
+**Features:**
+* Add `isValidIdentifier`
+
+## v1.4.0
+**Features:**
+* Add `contentLength` property to the result of `getLineRanges`
+
+## v1.3.0
+**Bugfixes:**
+* canHaveLeadingTrivia:
+  * Fix property access on undefined parent reference
+  * Fixes: https://github.com/palantir/tslint/issues/2330
+* hasOwnThisReference: now includes accessors on object literals
+
+**Features:**
+* Typeguards:
+  * isTypeParameterDeclaration
+  * isEnitityName
+
+## v1.2.2
+**Bugfixes:**
+* hasOwnThisReference:
+  * exclude overload signatures of function declarations
+  * add method declarations on object literals
+
+## v1.2.1
+**Bugfixes:**
+* Fix name of isNumericLiteral
+
+## v1.2.0
+**Features:**
+* Typeguards:
+  * isEnumMember
+  * isExpressionWithTypeArguments
+  * isImportSpecifier
+* Utilities:
+  * isJsDocKind, isTypeNodeKind
+* Allow typescript@next in peerDependencies
+
+## v1.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
+
+
+## v1.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
\ No newline at end of file
diff --git a/node_modules/tsutils/LICENSE b/node_modules/tsutils/LICENSE
new file mode 100644
index 000000000..3a990ff40
--- /dev/null
+++ 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.
diff --git a/node_modules/tsutils/README.md b/node_modules/tsutils/README.md
new file mode 100644
index 000000000..785e98609
--- /dev/null
+++ b/node_modules/tsutils/README.md
@@ -0,0 +1,32 @@
+# Utility functions for working with typescript's AST
+
+## 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.
\ No newline at end of file
diff --git a/node_modules/tsutils/index.d.ts b/node_modules/tsutils/index.d.ts
new file mode 100644
index 000000000..26b9ee17c
--- /dev/null
+++ b/node_modules/tsutils/index.d.ts
@@ -0,0 +1,2 @@
+export * from './typeguard';
+export * from './util';
diff --git a/node_modules/tsutils/index.js b/node_modules/tsutils/index.js
new file mode 100644
index 000000000..900227f22
--- /dev/null
+++ b/node_modules/tsutils/index.js
@@ -0,0 +1,8 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./typeguard"));
+__export(require("./util"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLGlDQUE0QjtBQUM1Qiw0QkFBdUIifQ==
\ No newline at end of file
diff --git a/node_modules/tsutils/node_modules/.bin/tsc b/node_modules/tsutils/node_modules/.bin/tsc
new file mode 120000
index 000000000..42fa863b2
--- /dev/null
+++ b/node_modules/tsutils/node_modules/.bin/tsc
@@ -0,0 +1 @@
+../../../typescript/bin/tsc
\ No newline at end of file
diff --git a/node_modules/tsutils/node_modules/.bin/tsserver b/node_modules/tsutils/node_modules/.bin/tsserver
new file mode 120000
index 000000000..39549c0e3
--- /dev/null
+++ b/node_modules/tsutils/node_modules/.bin/tsserver
@@ -0,0 +1 @@
+../../../typescript/bin/tsserver
\ No newline at end of file
diff --git a/node_modules/tsutils/package.json b/node_modules/tsutils/package.json
new file mode 100644
index 000000000..ee8160418
--- /dev/null
+++ b/node_modules/tsutils/package.json
@@ -0,0 +1,40 @@
+{
+  "name": "tsutils",
+  "version": "2.2.0",
+  "description": "utilities for working with typescript's AST",
+  "scripts": {
+    "compile": "rm -rf {,util,typeguard,src,test}/*.js; tsc -p .",
+    "lint": "tslint -p ./tsconfig.json",
+    "test": "mocha test/*Tests.js",
+    "verify": "npm run compile && npm run lint && npm test",
+    "prepublish": "npm run verify"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ajafff/tsutils"
+  },
+  "keywords": [
+    "typescript",
+    "ts",
+    "ast",
+    "typeguard",
+    "utils",
+    "helper",
+    "node"
+  ],
+  "author": "Klaus Meinhardt",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/chai": "^3.5.2",
+    "@types/mocha": "^2.2.41",
+    "@types/node": "^7.0.18",
+    "chai": "^3.5.0",
+    "mocha": "^3.4.1",
+    "tslint": "^5.2.0",
+    "tslint-consistent-codestyle": "^1.2.0",
+    "typescript": "^2.3.0"
+  },
+  "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"
+  }
+}
diff --git a/node_modules/tsutils/typeguard/index.d.ts b/node_modules/tsutils/typeguard/index.d.ts
new file mode 100644
index 000000000..71762921c
--- /dev/null
+++ b/node_modules/tsutils/typeguard/index.d.ts
@@ -0,0 +1,2 @@
+export * from './node';
+export * from './type';
diff --git a/node_modules/tsutils/typeguard/index.js b/node_modules/tsutils/typeguard/index.js
new file mode 100644
index 000000000..7dc6cac25
--- /dev/null
+++ b/node_modules/tsutils/typeguard/index.js
@@ -0,0 +1,8 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./node"));
+__export(require("./type"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLDRCQUF1QjtBQUN2Qiw0QkFBdUIifQ==
\ No newline at end of file
diff --git a/node_modules/tsutils/typeguard/node.d.ts b/node_modules/tsutils/typeguard/node.d.ts
new file mode 100644
index 000000000..0d10a40b8
--- /dev/null
+++ b/node_modules/tsutils/typeguard/node.d.ts
@@ -0,0 +1,138 @@
+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 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 isConditionalExpression(node: ts.Node): node is ts.ConditionalExpression;
+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 isDefaultClause(node: ts.Node): node is ts.DefaultClause;
+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 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 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 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 isJsxElement(node: ts.Node): node is ts.JsxElement;
+export declare function isJsxExpression(node: ts.Node): node is ts.JsxExpression;
+export declare function isJsxOpeningElement(node: ts.Node): node is ts.JsxOpeningElement;
+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 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 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;
diff --git a/node_modules/tsutils/typeguard/node.js b/node_modules/tsutils/typeguard/node.js
new file mode 100644
index 000000000..9431dbbae
--- /dev/null
+++ b/node_modules/tsutils/typeguard/node.js
@@ -0,0 +1,622 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ts = require("typescript");
+function isAccessorDeclaration(node) {
+    return node.kind === ts.SyntaxKind.GetAccessor ||
+        node.kind === ts.SyntaxKind.SetAccessor;
+}
+exports.isAccessorDeclaration = isAccessorDeclaration;
+function isArrayBindingPattern(node) {
+    return node.kind === ts.SyntaxKind.ArrayBindingPattern;
+}
+exports.isArrayBindingPattern = isArrayBindingPattern;
+function isArrayLiteralExpression(node) {
+    return node.kind === ts.SyntaxKind.ArrayLiteralExpression;
+}
+exports.isArrayLiteralExpression = isArrayLiteralExpression;
+function isArrayTypeNode(node) {
+    return node.kind === ts.SyntaxKind.ArrayType;
+}
+exports.isArrayTypeNode = isArrayTypeNode;
+function isArrowFunction(node) {
+    return node.kind === ts.SyntaxKind.ArrowFunction;
+}
+exports.isArrowFunction = isArrowFunction;
+function isAsExpression(node) {
+    return node.kind === ts.SyntaxKind.AsExpression;
+}
+exports.isAsExpression = isAsExpression;
+function isAssertionExpression(node) {
+    return node.kind === ts.SyntaxKind.AsExpression ||
+        node.kind === ts.SyntaxKind.TypeAssertionExpression;
+}
+exports.isAssertionExpression = isAssertionExpression;
+function isAwaitExpression(node) {
+    return node.kind === ts.SyntaxKind.AwaitExpression;
+}
+exports.isAwaitExpression = isAwaitExpression;
+function isBinaryExpression(node) {
+    return node.kind === ts.SyntaxKind.BinaryExpression;
+}
+exports.isBinaryExpression = isBinaryExpression;
+function isBindingElement(node) {
+    return node.kind === ts.SyntaxKind.BindingElement;
+}
+exports.isBindingElement = isBindingElement;
+function isBindingPattern(node) {
+    return node.kind === ts.SyntaxKind.ArrayBindingPattern ||
+        node.kind === ts.SyntaxKind.ObjectBindingPattern;
+}
+exports.isBindingPattern = isBindingPattern;
+function isBlock(node) {
+    return node.kind === ts.SyntaxKind.Block;
+}
+exports.isBlock = isBlock;
+function isBlockLike(node) {
+    return node.statements !== undefined;
+}
+exports.isBlockLike = isBlockLike;
+function isBreakOrContinueStatement(node) {
+    return node.kind === ts.SyntaxKind.BreakStatement ||
+        node.kind === ts.SyntaxKind.ContinueStatement;
+}
+exports.isBreakOrContinueStatement = isBreakOrContinueStatement;
+function isBreakStatement(node) {
+    return node.kind === ts.SyntaxKind.BreakStatement;
+}
+exports.isBreakStatement = isBreakStatement;
+function isCallExpression(node) {
+    return node.kind === ts.SyntaxKind.CallExpression;
+}
+exports.isCallExpression = isCallExpression;
+function isCallSignatureDeclaration(node) {
+    return node.kind === ts.SyntaxKind.CallSignature;
+}
+exports.isCallSignatureDeclaration = isCallSignatureDeclaration;
+function isCaseBlock(node) {
+    return node.kind === ts.SyntaxKind.CaseBlock;
+}
+exports.isCaseBlock = isCaseBlock;
+function isCaseClause(node) {
+    return node.kind === ts.SyntaxKind.CaseClause;
+}
+exports.isCaseClause = isCaseClause;
+function isCaseOrDefaultClause(node) {
+    return node.kind === ts.SyntaxKind.CaseClause ||
+        node.kind === ts.SyntaxKind.DefaultClause;
+}
+exports.isCaseOrDefaultClause = isCaseOrDefaultClause;
+function isCatchClause(node) {
+    return node.kind === ts.SyntaxKind.CatchClause;
+}
+exports.isCatchClause = isCatchClause;
+function isClassDeclaration(node) {
+    return node.kind === ts.SyntaxKind.ClassDeclaration;
+}
+exports.isClassDeclaration = isClassDeclaration;
+function isClassExpression(node) {
+    return node.kind === ts.SyntaxKind.ClassExpression;
+}
+exports.isClassExpression = isClassExpression;
+function isClassLikeDeclaration(node) {
+    return node.kind === ts.SyntaxKind.ClassDeclaration ||
+        node.kind === ts.SyntaxKind.ClassExpression;
+}
+exports.isClassLikeDeclaration = isClassLikeDeclaration;
+function isConditionalExpression(node) {
+    return node.kind === ts.SyntaxKind.ConditionalExpression;
+}
+exports.isConditionalExpression = isConditionalExpression;
+function isConstructorDeclaration(node) {
+    return node.kind === ts.SyntaxKind.Constructor;
+}
+exports.isConstructorDeclaration = isConstructorDeclaration;
+function isConstructorTypeNode(node) {
+    return node.kind === ts.SyntaxKind.ConstructorType;
+}
+exports.isConstructorTypeNode = isConstructorTypeNode;
+function isConstructSignatureDeclaration(node) {
+    return node.kind === ts.SyntaxKind.ConstructSignature;
+}
+exports.isConstructSignatureDeclaration = isConstructSignatureDeclaration;
+function isContinueStatement(node) {
+    return node.kind === ts.SyntaxKind.ContinueStatement;
+}
+exports.isContinueStatement = isContinueStatement;
+function isComputedPropertyName(node) {
+    return node.kind === ts.SyntaxKind.ComputedPropertyName;
+}
+exports.isComputedPropertyName = isComputedPropertyName;
+function isDebuggerStatement(node) {
+    return node.kind === ts.SyntaxKind.DebuggerStatement;
+}
+exports.isDebuggerStatement = isDebuggerStatement;
+function isDefaultClause(node) {
+    return node.kind === ts.SyntaxKind.DefaultClause;
+}
+exports.isDefaultClause = isDefaultClause;
+function isDoStatement(node) {
+    return node.kind === ts.SyntaxKind.DoStatement;
+}
+exports.isDoStatement = isDoStatement;
+function isElementAccessExpression(node) {
+    return node.kind === ts.SyntaxKind.ElementAccessExpression;
+}
+exports.isElementAccessExpression = isElementAccessExpression;
+function isEmptyStatement(node) {
+    return node.kind === ts.SyntaxKind.EmptyStatement;
+}
+exports.isEmptyStatement = isEmptyStatement;
+function isEntityName(node) {
+    return node.kind === ts.SyntaxKind.Identifier || isQualifiedName(node);
+}
+exports.isEntityName = isEntityName;
+function isEntityNameExpression(node) {
+    return node.kind === ts.SyntaxKind.Identifier ||
+        isPropertyAccessExpression(node) && isEntityNameExpression(node.expression);
+}
+exports.isEntityNameExpression = isEntityNameExpression;
+function isEnumDeclaration(node) {
+    return node.kind === ts.SyntaxKind.EnumDeclaration;
+}
+exports.isEnumDeclaration = isEnumDeclaration;
+function isEnumMember(node) {
+    return node.kind === ts.SyntaxKind.EnumMember;
+}
+exports.isEnumMember = isEnumMember;
+function isExportAssignment(node) {
+    return node.kind === ts.SyntaxKind.ExportAssignment;
+}
+exports.isExportAssignment = isExportAssignment;
+function isExportDeclaration(node) {
+    return node.kind === ts.SyntaxKind.ExportDeclaration;
+}
+exports.isExportDeclaration = isExportDeclaration;
+function isExportSpecifier(node) {
+    return node.kind === ts.SyntaxKind.ExportSpecifier;
+}
+exports.isExportSpecifier = isExportSpecifier;
+function isExpression(node) {
+    switch (node.kind) {
+        case ts.SyntaxKind.ArrayLiteralExpression:
+        case ts.SyntaxKind.ArrowFunction:
+        case ts.SyntaxKind.AsExpression:
+        case ts.SyntaxKind.AwaitExpression:
+        case ts.SyntaxKind.BinaryExpression:
+        case ts.SyntaxKind.CallExpression:
+        case ts.SyntaxKind.ClassExpression:
+        case ts.SyntaxKind.ConditionalExpression:
+        case ts.SyntaxKind.DeleteExpression:
+        case ts.SyntaxKind.ElementAccessExpression:
+        case ts.SyntaxKind.FalseKeyword:
+        case ts.SyntaxKind.FunctionExpression:
+        case ts.SyntaxKind.Identifier:
+        case ts.SyntaxKind.JsxElement:
+        case ts.SyntaxKind.JsxExpression:
+        case ts.SyntaxKind.JsxOpeningElement:
+        case ts.SyntaxKind.JsxSelfClosingElement:
+        case ts.SyntaxKind.MetaProperty:
+        case ts.SyntaxKind.NewExpression:
+        case ts.SyntaxKind.NonNullExpression:
+        case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
+        case ts.SyntaxKind.NullKeyword:
+        case ts.SyntaxKind.NumericLiteral:
+        case ts.SyntaxKind.ObjectLiteralExpression:
+        case ts.SyntaxKind.OmittedExpression:
+        case ts.SyntaxKind.ParenthesizedExpression:
+        case ts.SyntaxKind.PostfixUnaryExpression:
+        case ts.SyntaxKind.PrefixUnaryExpression:
+        case ts.SyntaxKind.PropertyAccessExpression:
+        case ts.SyntaxKind.RegularExpressionLiteral:
+        case ts.SyntaxKind.SpreadElement:
+        case ts.SyntaxKind.StringLiteral:
+        case ts.SyntaxKind.SuperKeyword:
+        case ts.SyntaxKind.TaggedTemplateExpression:
+        case ts.SyntaxKind.TemplateExpression:
+        case ts.SyntaxKind.ThisKeyword:
+        case ts.SyntaxKind.TrueKeyword:
+        case ts.SyntaxKind.TypeAssertionExpression:
+        case ts.SyntaxKind.TypeOfExpression:
+        case ts.SyntaxKind.VoidExpression:
+        case ts.SyntaxKind.YieldExpression:
+            return true;
+        default:
+            return false;
+    }
+}
+exports.isExpression = isExpression;
+function isExpressionStatement(node) {
+    return node.kind === ts.SyntaxKind.ExpressionStatement;
+}
+exports.isExpressionStatement = isExpressionStatement;
+function isExpressionWithTypeArguments(node) {
+    return node.kind === ts.SyntaxKind.ExpressionWithTypeArguments;
+}
+exports.isExpressionWithTypeArguments = isExpressionWithTypeArguments;
+function isExternalModuleReference(node) {
+    return node.kind === ts.SyntaxKind.ExternalModuleReference;
+}
+exports.isExternalModuleReference = isExternalModuleReference;
+function isForInStatement(node) {
+    return node.kind === ts.SyntaxKind.ForInStatement;
+}
+exports.isForInStatement = isForInStatement;
+function isForOfStatement(node) {
+    return node.kind === ts.SyntaxKind.ForOfStatement;
+}
+exports.isForOfStatement = isForOfStatement;
+function isForStatement(node) {
+    return node.kind === ts.SyntaxKind.ForStatement;
+}
+exports.isForStatement = isForStatement;
+function isFunctionDeclaration(node) {
+    return node.kind === ts.SyntaxKind.FunctionDeclaration;
+}
+exports.isFunctionDeclaration = isFunctionDeclaration;
+function isFunctionExpression(node) {
+    return node.kind === ts.SyntaxKind.FunctionExpression;
+}
+exports.isFunctionExpression = isFunctionExpression;
+function isFunctionTypeNode(node) {
+    return node.kind === ts.SyntaxKind.FunctionType;
+}
+exports.isFunctionTypeNode = isFunctionTypeNode;
+function isGetAccessorDeclaration(node) {
+    return node.kind === ts.SyntaxKind.GetAccessor;
+}
+exports.isGetAccessorDeclaration = isGetAccessorDeclaration;
+function isIdentifier(node) {
+    return node.kind === ts.SyntaxKind.Identifier;
+}
+exports.isIdentifier = isIdentifier;
+function isIfStatement(node) {
+    return node.kind === ts.SyntaxKind.IfStatement;
+}
+exports.isIfStatement = isIfStatement;
+function isImportClause(node) {
+    return node.kind === ts.SyntaxKind.ImportClause;
+}
+exports.isImportClause = isImportClause;
+function isImportDeclaration(node) {
+    return node.kind === ts.SyntaxKind.ImportDeclaration;
+}
+exports.isImportDeclaration = isImportDeclaration;
+function isImportEqualsDeclaration(node) {
+    return node.kind === ts.SyntaxKind.ImportEqualsDeclaration;
+}
+exports.isImportEqualsDeclaration = isImportEqualsDeclaration;
+function isImportSpecifier(node) {
+    return node.kind === ts.SyntaxKind.ImportSpecifier;
+}
+exports.isImportSpecifier = isImportSpecifier;
+function isIndexedAccessTypeNode(node) {
+    return node.kind === ts.SyntaxKind.IndexedAccessType;
+}
+exports.isIndexedAccessTypeNode = isIndexedAccessTypeNode;
+function isIndexSignatureDeclaration(node) {
+    return node.kind === ts.SyntaxKind.IndexSignature;
+}
+exports.isIndexSignatureDeclaration = isIndexSignatureDeclaration;
+function isInterfaceDeclaration(node) {
+    return node.kind === ts.SyntaxKind.InterfaceDeclaration;
+}
+exports.isInterfaceDeclaration = isInterfaceDeclaration;
+function isIntersectionTypeNode(node) {
+    return node.kind === ts.SyntaxKind.IntersectionType;
+}
+exports.isIntersectionTypeNode = isIntersectionTypeNode;
+function isIterationStatement(node) {
+    switch (node.kind) {
+        case ts.SyntaxKind.ForStatement:
+        case ts.SyntaxKind.ForOfStatement:
+        case ts.SyntaxKind.ForInStatement:
+        case ts.SyntaxKind.WhileStatement:
+        case ts.SyntaxKind.DoStatement:
+            return true;
+        default:
+            return false;
+    }
+}
+exports.isIterationStatement = isIterationStatement;
+function isJsxAttribute(node) {
+    return node.kind === ts.SyntaxKind.JsxAttribute;
+}
+exports.isJsxAttribute = isJsxAttribute;
+function isJsxAttributeLike(node) {
+    return node.kind === ts.SyntaxKind.JsxAttribute ||
+        node.kind === ts.SyntaxKind.JsxSpreadAttribute;
+}
+exports.isJsxAttributeLike = isJsxAttributeLike;
+function isJsxAttributes(node) {
+    return node.kind === ts.SyntaxKind.JsxAttributes;
+}
+exports.isJsxAttributes = isJsxAttributes;
+function isJsxClosingElement(node) {
+    return node.kind === ts.SyntaxKind.JsxClosingElement;
+}
+exports.isJsxClosingElement = isJsxClosingElement;
+function isJsxElement(node) {
+    return node.kind === ts.SyntaxKind.JsxElement;
+}
+exports.isJsxElement = isJsxElement;
+function isJsxExpression(node) {
+    return node.kind === ts.SyntaxKind.JsxExpression;
+}
+exports.isJsxExpression = isJsxExpression;
+function isJsxOpeningElement(node) {
+    return node.kind === ts.SyntaxKind.JsxOpeningElement;
+}
+exports.isJsxOpeningElement = isJsxOpeningElement;
+function isJsxOpeningLikeElement(node) {
+    return node.kind === ts.SyntaxKind.JsxOpeningElement ||
+        node.kind === ts.SyntaxKind.JsxSelfClosingElement;
+}
+exports.isJsxOpeningLikeElement = isJsxOpeningLikeElement;
+function isJsxSelfClosingElement(node) {
+    return node.kind === ts.SyntaxKind.JsxSelfClosingElement;
+}
+exports.isJsxSelfClosingElement = isJsxSelfClosingElement;
+function isJsxSpreadAttribute(node) {
+    return node.kind === ts.SyntaxKind.JsxSpreadAttribute;
+}
+exports.isJsxSpreadAttribute = isJsxSpreadAttribute;
+function isJsxText(node) {
+    return node.kind === ts.SyntaxKind.JsxText;
+}
+exports.isJsxText = isJsxText;
+function isLabeledStatement(node) {
+    return node.kind === ts.SyntaxKind.LabeledStatement;
+}
+exports.isLabeledStatement = isLabeledStatement;
+function isLiteralExpression(node) {
+    return node.kind >= ts.SyntaxKind.FirstLiteralToken &&
+        node.kind <= ts.SyntaxKind.LastLiteralToken;
+}
+exports.isLiteralExpression = isLiteralExpression;
+function isMetaProperty(node) {
+    return node.kind === ts.SyntaxKind.MetaProperty;
+}
+exports.isMetaProperty = isMetaProperty;
+function isMethodDeclaration(node) {
+    return node.kind === ts.SyntaxKind.MethodDeclaration;
+}
+exports.isMethodDeclaration = isMethodDeclaration;
+function isMethodSignature(node) {
+    return node.kind === ts.SyntaxKind.MethodSignature;
+}
+exports.isMethodSignature = isMethodSignature;
+function isModuleBlock(node) {
+    return node.kind === ts.SyntaxKind.ModuleBlock;
+}
+exports.isModuleBlock = isModuleBlock;
+function isModuleDeclaration(node) {
+    return node.kind === ts.SyntaxKind.ModuleDeclaration;
+}
+exports.isModuleDeclaration = isModuleDeclaration;
+function isNamedExports(node) {
+    return node.kind === ts.SyntaxKind.NamedExports;
+}
+exports.isNamedExports = isNamedExports;
+function isNamedImports(node) {
+    return node.kind === ts.SyntaxKind.NamedImports;
+}
+exports.isNamedImports = isNamedImports;
+function isNamespaceDeclaration(node) {
+    return isModuleDeclaration(node) &&
+        node.name.kind === ts.SyntaxKind.Identifier &&
+        node.body !== undefined &&
+        (node.body.kind === ts.SyntaxKind.ModuleBlock ||
+            isNamespaceDeclaration(node.body));
+}
+exports.isNamespaceDeclaration = isNamespaceDeclaration;
+function isNamespaceImport(node) {
+    return node.kind === ts.SyntaxKind.NamespaceImport;
+}
+exports.isNamespaceImport = isNamespaceImport;
+function isNamespaceExportDeclaration(node) {
+    return node.kind === ts.SyntaxKind.NamespaceExportDeclaration;
+}
+exports.isNamespaceExportDeclaration = isNamespaceExportDeclaration;
+function isNewExpression(node) {
+    return node.kind === ts.SyntaxKind.NewExpression;
+}
+exports.isNewExpression = isNewExpression;
+function isNonNullExpression(node) {
+    return node.kind === ts.SyntaxKind.NonNullExpression;
+}
+exports.isNonNullExpression = isNonNullExpression;
+function isNoSubstitutionTemplateLiteral(node) {
+    return node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+exports.isNoSubstitutionTemplateLiteral = isNoSubstitutionTemplateLiteral;
+function isNumericLiteral(node) {
+    return node.kind === ts.SyntaxKind.NumericLiteral;
+}
+exports.isNumericLiteral = isNumericLiteral;
+function isObjectBindingPattern(node) {
+    return node.kind === ts.SyntaxKind.ObjectBindingPattern;
+}
+exports.isObjectBindingPattern = isObjectBindingPattern;
+function isObjectLiteralExpression(node) {
+    return node.kind === ts.SyntaxKind.ObjectLiteralExpression;
+}
+exports.isObjectLiteralExpression = isObjectLiteralExpression;
+function isOmittedExpression(node) {
+    return node.kind === ts.SyntaxKind.OmittedExpression;
+}
+exports.isOmittedExpression = isOmittedExpression;
+function isParameterDeclaration(node) {
+    return node.kind === ts.SyntaxKind.Parameter;
+}
+exports.isParameterDeclaration = isParameterDeclaration;
+function isParenthesizedExpression(node) {
+    return node.kind === ts.SyntaxKind.ParenthesizedExpression;
+}
+exports.isParenthesizedExpression = isParenthesizedExpression;
+function isPostfixUnaryExpression(node) {
+    return node.kind === ts.SyntaxKind.PostfixUnaryExpression;
+}
+exports.isPostfixUnaryExpression = isPostfixUnaryExpression;
+function isPrefixUnaryExpression(node) {
+    return node.kind === ts.SyntaxKind.PrefixUnaryExpression;
+}
+exports.isPrefixUnaryExpression = isPrefixUnaryExpression;
+function isPropertyAccessExpression(node) {
+    return node.kind === ts.SyntaxKind.PropertyAccessExpression;
+}
+exports.isPropertyAccessExpression = isPropertyAccessExpression;
+function isPropertyAssignment(node) {
+    return node.kind === ts.SyntaxKind.PropertyAssignment;
+}
+exports.isPropertyAssignment = isPropertyAssignment;
+function isPropertyDeclaration(node) {
+    return node.kind === ts.SyntaxKind.PropertyDeclaration;
+}
+exports.isPropertyDeclaration = isPropertyDeclaration;
+function isPropertySignature(node) {
+    return node.kind === ts.SyntaxKind.PropertySignature;
+}
+exports.isPropertySignature = isPropertySignature;
+function isQualifiedName(node) {
+    return node.kind === ts.SyntaxKind.QualifiedName;
+}
+exports.isQualifiedName = isQualifiedName;
+function isRegularExpressionLiteral(node) {
+    return node.kind === ts.SyntaxKind.RegularExpressionLiteral;
+}
+exports.isRegularExpressionLiteral = isRegularExpressionLiteral;
+function isReturnStatement(node) {
+    return node.kind === ts.SyntaxKind.ReturnStatement;
+}
+exports.isReturnStatement = isReturnStatement;
+function isSetAccessorDeclaration(node) {
+    return node.kind === ts.SyntaxKind.SetAccessor;
+}
+exports.isSetAccessorDeclaration = isSetAccessorDeclaration;
+function isShorthandPropertyAssignment(node) {
+    return node.kind === ts.SyntaxKind.ShorthandPropertyAssignment;
+}
+exports.isShorthandPropertyAssignment = isShorthandPropertyAssignment;
+function isSignatureDeclaration(node) {
+    return node.parameters !== undefined;
+}
+exports.isSignatureDeclaration = isSignatureDeclaration;
+function isSourceFile(node) {
+    return node.kind === ts.SyntaxKind.SourceFile;
+}
+exports.isSourceFile = isSourceFile;
+function isSpreadAssignment(node) {
+    return node.kind === ts.SyntaxKind.SpreadAssignment;
+}
+exports.isSpreadAssignment = isSpreadAssignment;
+function isSpreadElement(node) {
+    return node.kind === ts.SyntaxKind.SpreadElement;
+}
+exports.isSpreadElement = isSpreadElement;
+function isStringLiteral(node) {
+    return node.kind === ts.SyntaxKind.StringLiteral;
+}
+exports.isStringLiteral = isStringLiteral;
+function isSwitchStatement(node) {
+    return node.kind === ts.SyntaxKind.SwitchStatement;
+}
+exports.isSwitchStatement = isSwitchStatement;
+function isSyntaxList(node) {
+    return node.kind === ts.SyntaxKind.SyntaxList;
+}
+exports.isSyntaxList = isSyntaxList;
+function isTaggedTemplateExpression(node) {
+    return node.kind === ts.SyntaxKind.TaggedTemplateExpression;
+}
+exports.isTaggedTemplateExpression = isTaggedTemplateExpression;
+function isTemplateExpression(node) {
+    return node.kind === ts.SyntaxKind.TemplateExpression;
+}
+exports.isTemplateExpression = isTemplateExpression;
+function isTemplateLiteral(node) {
+    return node.kind === ts.SyntaxKind.TemplateExpression ||
+        node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+exports.isTemplateLiteral = isTemplateLiteral;
+function isTextualLiteral(node) {
+    return node.kind === ts.SyntaxKind.StringLiteral ||
+        node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+exports.isTextualLiteral = isTextualLiteral;
+function isThrowStatement(node) {
+    return node.kind === ts.SyntaxKind.ThrowStatement;
+}
+exports.isThrowStatement = isThrowStatement;
+function isTryStatement(node) {
+    return node.kind === ts.SyntaxKind.TryStatement;
+}
+exports.isTryStatement = isTryStatement;
+function isTupleTypeNode(node) {
+    return node.kind === ts.SyntaxKind.TupleType;
+}
+exports.isTupleTypeNode = isTupleTypeNode;
+function isTypeAliasDeclaration(node) {
+    return node.kind === ts.SyntaxKind.TypeAliasDeclaration;
+}
+exports.isTypeAliasDeclaration = isTypeAliasDeclaration;
+function isTypeAssertion(node) {
+    return node.kind === ts.SyntaxKind.TypeAssertionExpression;
+}
+exports.isTypeAssertion = isTypeAssertion;
+function isTypeLiteralNode(node) {
+    return node.kind === ts.SyntaxKind.TypeLiteral;
+}
+exports.isTypeLiteralNode = isTypeLiteralNode;
+function isTypeOfExpression(node) {
+    return node.kind === ts.SyntaxKind.TypeOfExpression;
+}
+exports.isTypeOfExpression = isTypeOfExpression;
+function isTypeOperatorNode(node) {
+    return node.kind === ts.SyntaxKind.TypeOperator;
+}
+exports.isTypeOperatorNode = isTypeOperatorNode;
+function isTypeParameterDeclaration(node) {
+    return node.kind === ts.SyntaxKind.TypeParameter;
+}
+exports.isTypeParameterDeclaration = isTypeParameterDeclaration;
+function isTypePredicateNode(node) {
+    return node.kind === ts.SyntaxKind.TypePredicate;
+}
+exports.isTypePredicateNode = isTypePredicateNode;
+function isTypeReferenceNode(node) {
+    return node.kind === ts.SyntaxKind.TypeReference;
+}
+exports.isTypeReferenceNode = isTypeReferenceNode;
+function isTypeQueryNode(node) {
+    return node.kind === ts.SyntaxKind.TypeQuery;
+}
+exports.isTypeQueryNode = isTypeQueryNode;
+function isUnionTypeNode(node) {
+    return node.kind === ts.SyntaxKind.UnionType;
+}
+exports.isUnionTypeNode = isUnionTypeNode;
+function isVariableDeclaration(node) {
+    return node.kind === ts.SyntaxKind.VariableDeclaration;
+}
+exports.isVariableDeclaration = isVariableDeclaration;
+function isVariableStatement(node) {
+    return node.kind === ts.SyntaxKind.VariableStatement;
+}
+exports.isVariableStatement = isVariableStatement;
+function isVariableDeclarationList(node) {
+    return node.kind === ts.SyntaxKind.VariableDeclarationList;
+}
+exports.isVariableDeclarationList = isVariableDeclarationList;
+function isVoidExpression(node) {
+    return node.kind === ts.SyntaxKind.VoidExpression;
+}
+exports.isVoidExpression = isVoidExpression;
+function isWhileStatement(node) {
+    return node.kind === ts.SyntaxKind.WhileStatement;
+}
+exports.isWhileStatement = isWhileStatement;
+function isWithStatement(node) {
+    return node.kind === ts.SyntaxKind.WithStatement;
+}
+exports.isWithStatement = isWithStatement;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node.js","sourceRoot":"","sources":["node.ts"],"names":[],"mappings":";;AAAA,+BAAiC;AAEjC,+BAAsC,IAAa;IAC/C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW;QAC1C,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;AAChD,CAAC;AAHD,sDAGC;AAED,+BAAsC,IAAa;IAC/C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC;AAC3D,CAAC;AAFD,sDAEC;AAED,kCAAyC,IAAa;IAClD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,sBAAsB,CAAC;AAC9D,CAAC;AAFD,4DAEC;AAED,yBAAgC,IAAa;IACzC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC;AACjD,CAAC;AAFD,0CAEC;AAED,yBAAgC,IAAa;IACzC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;AACrD,CAAC;AAFD,0CAEC;AAED,wBAA+B,IAAa;IACxC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;AACpD,CAAC;AAFD,wCAEC;AAED,+BAAsC,IAAa;IAC/C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY;QAC3C,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB,CAAC;AAC5D,CAAC;AAHD,sDAGC;AAED,2BAAkC,IAAa;IAC3C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC;AACvD,CAAC;AAFD,8CAEC;AAED,4BAAmC,IAAa;IAC5C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC;AACxD,CAAC;AAFD,gDAEC;AAED,0BAAiC,IAAa;IAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;AACtD,CAAC;AAFD,4CAEC;AAED,0BAAiC,IAAa;IAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,mBAAmB;QAClD,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,oBAAoB,CAAC;AACzD,CAAC;AAHD,4CAGC;AAED,iBAAwB,IAAa;IACjC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC;AAC7C,CAAC;AAFD,0BAEC;AAED,qBAA4B,IAAa;IACrC,MAAM,CAAO,IAAK,CAAC,UAAU,KAAK,SAAS,CAAC;AAChD,CAAC;AAFD,kCAEC;AAED,oCAA2C,IAAa;IACpD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc;QAC7C,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;AACtD,CAAC;AAHD,gEAGC;AAED,0BAAiC,IAAa;IAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;AACtD,CAAC;AAFD,4CAEC;AAED,0BAAiC,IAAa;IAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;AACtD,CAAC;AAFD,4CAEC;AAED,oCAA2C,IAAa;IACpD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;AACrD,CAAC;AAFD,gEAEC;AAED,qBAA4B,IAAa;IACrC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC;AACjD,CAAC;AAFD,kCAEC;AAED,sBAA6B,IAAa;IACtC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC;AAClD,CAAC;AAFD,oCAEC;AAED,+BAAsC,IAAa;IAC/C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU;QACzC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;AAClD,CAAC;AAHD,sDAGC;AAED,uBAA8B,IAAa;IACvC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;AACnD,CAAC;AAFD,sCAEC;AAED,4BAAmC,IAAa;IAC5C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC;AACxD,CAAC;AAFD,gDAEC;AAED,2BAAkC,IAAa;IAC3C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC;AACvD,CAAC;AAFD,8CAEC;AAED,gCAAuC,IAAa;IAChD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB;QAC/C,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC;AACpD,CAAC;AAHD,wDAGC;AAED,iCAAwC,IAAa;IACjD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,qBAAqB,CAAC;AAC7D,CAAC;AAFD,0DAEC;AAED,kCAAyC,IAAa;IAClD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;AACnD,CAAC;AAFD,4DAEC;AAED,+BAAsC,IAAa;IAC/C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC;AACvD,CAAC;AAFD,sDAEC;AAED,yCAAgD,IAAa;IACzD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC;AAC1D,CAAC;AAFD,0EAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;AACzD,CAAC;AAFD,kDAEC;AAED,gCAAuC,IAAa;IAChD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,oBAAoB,CAAC;AAC5D,CAAC;AAFD,wDAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;AACzD,CAAC;AAFD,kDAEC;AAED,yBAAgC,IAAa;IACzC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;AACrD,CAAC;AAFD,0CAEC;AAED,uBAA8B,IAAa;IACvC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;AACnD,CAAC;AAFD,sCAEC;AAED,mCAA0C,IAAa;IACnD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB,CAAC;AAC/D,CAAC;AAFD,8DAEC;AAED,0BAAiC,IAAa;IAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;AACtD,CAAC;AAFD,4CAEC;AAED,sBAA6B,IAAa;IACtC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC;AAC3E,CAAC;AAFD,oCAEC;AAED,gCAAuC,IAAa;IAChD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU;QACzC,0BAA0B,CAAC,IAAI,CAAC,IAAI,sBAAsB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;AACpF,CAAC;AAHD,wDAGC;AAED,2BAAkC,IAAa;IAC3C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC;AACvD,CAAC;AAFD,8CAEC;AAED,sBAA6B,IAAa;IACtC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC;AAClD,CAAC;AAFD,oCAEC;AAED,4BAAmC,IAAa;IAC5C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC;AACxD,CAAC;AAFD,gDAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;AACzD,CAAC;AAFD,kDAEC;AAED,2BAAkC,IAAa;IAC3C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC;AACvD,CAAC;AAFD,8CAEC;AAED,sBAA6B,IAAa;IACtC,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAChB,KAAK,EAAE,CAAC,UAAU,CAAC,sBAAsB,CAAC;QAC1C,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;QACjC,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;QAChC,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC;QACnC,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC;QACpC,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;QAClC,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC;QACnC,KAAK,EAAE,CAAC,UAAU,CAAC,qBAAqB,CAAC;QACzC,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC;QACpC,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB,CAAC;QAC3C,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;QAChC,KAAK,EAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC;QACtC,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC;QAC9B,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC;QAC9B,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;QACjC,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;QACrC,KAAK,EAAE,CAAC,UAAU,CAAC,qBAAqB,CAAC;QACzC,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;QAChC,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;QACjC,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;QACrC,KAAK,EAAE,CAAC,UAAU,CAAC,6BAA6B,CAAC;QACjD,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;QAC/B,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;QAClC,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB,CAAC;QAC3C,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;QACrC,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB,CAAC;QAC3C,KAAK,EAAE,CAAC,UAAU,CAAC,sBAAsB,CAAC;QAC1C,KAAK,EAAE,CAAC,UAAU,CAAC,qBAAqB,CAAC;QACzC,KAAK,EAAE,CAAC,UAAU,CAAC,wBAAwB,CAAC;QAC5C,KAAK,EAAE,CAAC,UAAU,CAAC,wBAAwB,CAAC;QAC5C,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;QACjC,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;QACjC,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;QAChC,KAAK,EAAE,CAAC,UAAU,CAAC,wBAAwB,CAAC;QAC5C,KAAK,EAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC;QACtC,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;QAC/B,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;QAC/B,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB,CAAC;QAC3C,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC;QACpC,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;QAClC,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe;YAC9B,MAAM,CAAC,IAAI,CAAC;QAChB;YACI,MAAM,CAAC,KAAK,CAAC;IACrB,CAAC;AACL,CAAC;AA/CD,oCA+CC;AAED,+BAAsC,IAAa;IAC/C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC;AAC3D,CAAC;AAFD,sDAEC;AAED,uCAA8C,IAAa;IACvD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,2BAA2B,CAAC;AACnE,CAAC;AAFD,sEAEC;AAED,mCAA0C,IAAa;IACnD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB,CAAC;AAC/D,CAAC;AAFD,8DAEC;AAED,0BAAiC,IAAa;IAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;AACtD,CAAC;AAFD,4CAEC;AAED,0BAAiC,IAAa;IAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;AACtD,CAAC;AAFD,4CAEC;AAED,wBAA+B,IAAa;IACxC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;AACpD,CAAC;AAFD,wCAEC;AAED,+BAAsC,IAAa;IAC/C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC;AAC3D,CAAC;AAFD,sDAEC;AAED,8BAAqC,IAAa;IAC9C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC;AAC1D,CAAC;AAFD,oDAEC;AAED,4BAAmC,IAAa;IAC5C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;AACpD,CAAC;AAFD,gDAEC;AAED,kCAAyC,IAAa;IAClD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;AACnD,CAAC;AAFD,4DAEC;AAED,sBAA6B,IAAa;IACtC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC;AAClD,CAAC;AAFD,oCAEC;AAED,uBAA8B,IAAa;IACvC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;AACnD,CAAC;AAFD,sCAEC;AAED,wBAA+B,IAAa;IACxC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;AACpD,CAAC;AAFD,wCAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;AACzD,CAAC;AAFD,kDAEC;AAED,mCAA0C,IAAa;IACnD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB,CAAC;AAC/D,CAAC;AAFD,8DAEC;AAED,2BAAkC,IAAa;IAC3C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC;AACvD,CAAC;AAFD,8CAEC;AAED,iCAAwC,IAAa;IACjD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;AACzD,CAAC;AAFD,0DAEC;AAED,qCAA4C,IAAa;IACrD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;AACtD,CAAC;AAFD,kEAEC;AAED,gCAAuC,IAAa;IAChD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,oBAAoB,CAAC;AAC5D,CAAC;AAFD,wDAEC;AAED,gCAAuC,IAAa;IAChD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC;AACxD,CAAC;AAFD,wDAEC;AAED,8BAAqC,IAAa;IAC9C,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAChB,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;QAChC,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;QAClC,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;QAClC,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;QAClC,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW;YAC1B,MAAM,CAAC,IAAI,CAAC;QAChB;YACI,MAAM,CAAC,KAAK,CAAC;IACrB,CAAC;AACL,CAAC;AAXD,oDAWC;AAED,wBAA+B,IAAa;IACxC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;AACpD,CAAC;AAFD,wCAEC;AAED,4BAAmC,IAAa;IAC5C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY;QAC3C,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC;AACvD,CAAC;AAHD,gDAGC;AAED,yBAAgC,IAAa;IACzC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;AACrD,CAAC;AAFD,0CAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;AACzD,CAAC;AAFD,kDAEC;AAED,sBAA6B,IAAa;IACtC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC;AAClD,CAAC;AAFD,oCAEC;AAED,yBAAgC,IAAa;IACzC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;AACrD,CAAC;AAFD,0CAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;AACzD,CAAC;AAFD,kDAEC;AAED,iCAAwC,IAAa;IACjD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB;QAChD,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,qBAAqB,CAAC;AAC1D,CAAC;AAHD,0DAGC;AAED,iCAAwC,IAAa;IACjD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,qBAAqB,CAAC;AAC7D,CAAC;AAFD,0DAEC;AAED,8BAAqC,IAAa;IAC9C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC;AAC1D,CAAC;AAFD,oDAEC;AAED,mBAA0B,IAAa;IACnC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC;AAC/C,CAAC;AAFD,8BAEC;AAED,4BAAmC,IAAa;IAC5C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC;AACxD,CAAC;AAFD,gDAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC,UAAU,CAAC,iBAAiB;QAC5C,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC;AACvD,CAAC;AAHD,kDAGC;AAED,wBAA+B,IAAa;IACxC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;AACpD,CAAC;AAFD,wCAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;AACzD,CAAC;AAFD,kDAEC;AAED,2BAAkC,IAAa;IAC3C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC;AACvD,CAAC;AAFD,8CAEC;AAED,uBAA8B,IAAa;IACvC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;AACnD,CAAC;AAFD,sCAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;AACzD,CAAC;AAFD,kDAEC;AAED,wBAA+B,IAAa;IACxC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;AACpD,CAAC;AAFD,wCAEC;AAED,wBAA+B,IAAa;IACxC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;AACpD,CAAC;AAFD,wCAEC;AAED,gCAAuC,IAAa;IAChD,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC;QAC5B,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU;QAC3C,IAAI,CAAC,IAAI,KAAK,SAAS;QACvB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW;YAC5C,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;AAC5C,CAAC;AAND,wDAMC;AAED,2BAAkC,IAAa;IAC3C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC;AACvD,CAAC;AAFD,8CAEC;AAED,sCAA6C,IAAa;IACtD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,0BAA0B,CAAC;AAClE,CAAC;AAFD,oEAEC;AAED,yBAAgC,IAAa;IACzC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;AACrD,CAAC;AAFD,0CAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;AACzD,CAAC;AAFD,kDAEC;AAED,yCAAgD,IAAa;IACzD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,6BAA6B,CAAC;AACrE,CAAC;AAFD,0EAEC;AAED,0BAAiC,IAAa;IAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;AACtD,CAAC;AAFD,4CAEC;AAED,gCAAuC,IAAa;IAChD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,oBAAoB,CAAC;AAC5D,CAAC;AAFD,wDAEC;AAED,mCAA0C,IAAa;IACnD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB,CAAC;AAC/D,CAAC;AAFD,8DAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;AACzD,CAAC;AAFD,kDAEC;AAED,gCAAuC,IAAa;IAChD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC;AACjD,CAAC;AAFD,wDAEC;AAED,mCAA0C,IAAa;IACnD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB,CAAC;AAC/D,CAAC;AAFD,8DAEC;AAED,kCAAyC,IAAa;IAClD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,sBAAsB,CAAC;AAC9D,CAAC;AAFD,4DAEC;AAED,iCAAwC,IAAa;IACjD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,qBAAqB,CAAC;AAC7D,CAAC;AAFD,0DAEC;AAED,oCAA2C,IAAa;IACpD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,wBAAwB,CAAC;AAChE,CAAC;AAFD,gEAEC;AAED,8BAAqC,IAAa;IAC9C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC;AAC1D,CAAC;AAFD,oDAEC;AAED,+BAAsC,IAAa;IAC/C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC;AAC3D,CAAC;AAFD,sDAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;AACzD,CAAC;AAFD,kDAEC;AAED,yBAAgC,IAAa;IACzC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;AACrD,CAAC;AAFD,0CAEC;AAED,oCAA2C,IAAa;IACpD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,wBAAwB,CAAC;AAChE,CAAC;AAFD,gEAEC;AAED,2BAAkC,IAAa;IAC3C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC;AACvD,CAAC;AAFD,8CAEC;AAED,kCAAyC,IAAa;IAClD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;AACnD,CAAC;AAFD,4DAEC;AAED,uCAA8C,IAAa;IACvD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,2BAA2B,CAAC;AACnE,CAAC;AAFD,sEAEC;AAED,gCAAuC,IAAa;IAChD,MAAM,CAAO,IAAK,CAAC,UAAU,KAAK,SAAS,CAAC;AAChD,CAAC;AAFD,wDAEC;AAED,sBAA6B,IAAa;IACtC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC;AAClD,CAAC;AAFD,oCAEC;AAED,4BAAmC,IAAa;IAC5C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC;AACxD,CAAC;AAFD,gDAEC;AAED,yBAAgC,IAAa;IACzC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;AACrD,CAAC;AAFD,0CAEC;AAED,yBAAgC,IAAa;IACzC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;AACrD,CAAC;AAFD,0CAEC;AAED,2BAAkC,IAAa;IAC3C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC;AACvD,CAAC;AAFD,8CAEC;AAED,sBAA6B,IAAa;IACtC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC;AAClD,CAAC;AAFD,oCAEC;AAED,oCAA2C,IAAa;IACpD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,wBAAwB,CAAC;AAChE,CAAC;AAFD,gEAEC;AAED,8BAAqC,IAAa;IAC9C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC;AAC1D,CAAC;AAFD,oDAEC;AAED,2BAAkC,IAAa;IAC3C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,kBAAkB;QACjD,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,6BAA6B,CAAC;AAClE,CAAC;AAHD,8CAGC;AAED,0BAAiC,IAAa;IAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa;QAC5C,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,6BAA6B,CAAC;AAClE,CAAC;AAHD,4CAGC;AAED,0BAAiC,IAAa;IAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;AACtD,CAAC;AAFD,4CAEC;AAED,wBAA+B,IAAa;IACxC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;AACpD,CAAC;AAFD,wCAEC;AAED,yBAAgC,IAAa;IACzC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC;AACjD,CAAC;AAFD,0CAEC;AAED,gCAAuC,IAAa;IAChD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,oBAAoB,CAAC;AAC5D,CAAC;AAFD,wDAEC;AAED,yBAAgC,IAAa;IACzC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB,CAAC;AAC/D,CAAC;AAFD,0CAEC;AAED,2BAAkC,IAAa;IAC3C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;AACnD,CAAC;AAFD,8CAEC;AAED,4BAAmC,IAAa;IAC5C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC;AACxD,CAAC;AAFD,gDAEC;AAED,4BAAmC,IAAa;IAC5C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;AACpD,CAAC;AAFD,gDAEC;AAED,oCAA2C,IAAa;IACpD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;AACrD,CAAC;AAFD,gEAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;AACrD,CAAC;AAFD,kDAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;AACrD,CAAC;AAFD,kDAEC;AAED,yBAAgC,IAAa;IACzC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC;AACjD,CAAC;AAFD,0CAEC;AAED,yBAAgC,IAAa;IACzC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC;AACjD,CAAC;AAFD,0CAEC;AAED,+BAAsC,IAAa;IAC/C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC;AAC3D,CAAC;AAFD,sDAEC;AAED,6BAAoC,IAAa;IAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC;AACzD,CAAC;AAFD,kDAEC;AAED,mCAA0C,IAAa;IACnD,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB,CAAC;AAC/D,CAAC;AAFD,8DAEC;AAED,0BAAiC,IAAa;IAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;AACtD,CAAC;AAFD,4CAEC;AAED,0BAAiC,IAAa;IAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;AACtD,CAAC;AAFD,4CAEC;AAED,yBAAgC,IAAa;IACzC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;AACrD,CAAC;AAFD,0CAEC"}
\ No newline at end of file
diff --git a/node_modules/tsutils/typeguard/type.d.ts b/node_modules/tsutils/typeguard/type.d.ts
new file mode 100644
index 000000000..946b1a071
--- /dev/null
+++ b/node_modules/tsutils/typeguard/type.d.ts
@@ -0,0 +1,14 @@
+import * as ts from 'typescript';
+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 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 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.TypeVariable;
+export declare function isUnionOrIntersectionType(type: ts.Type): type is ts.UnionOrIntersectionType;
+export declare function isUnionType(type: ts.Type): type is ts.UnionType;
diff --git a/node_modules/tsutils/typeguard/type.js b/node_modules/tsutils/typeguard/type.js
new file mode 100644
index 000000000..0a145ab59
--- /dev/null
+++ b/node_modules/tsutils/typeguard/type.js
@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ts = require("typescript");
+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 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.Literal) !== 0;
+}
+exports.isLiteralType = isLiteralType;
+function isObjectType(type) {
+    return (type.flags & ts.TypeFlags.Object) !== 0;
+}
+exports.isObjectType = isObjectType;
+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;
+//# sourceMappingURL=data:application/json;base64,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
\ No newline at end of file
diff --git a/node_modules/tsutils/util/index.d.ts b/node_modules/tsutils/util/index.d.ts
new file mode 100644
index 000000000..bbebd88eb
--- /dev/null
+++ b/node_modules/tsutils/util/index.d.ts
@@ -0,0 +1 @@
+export * from './util';
diff --git a/node_modules/tsutils/util/index.js b/node_modules/tsutils/util/index.js
new file mode 100644
index 000000000..bb780516b
--- /dev/null
+++ b/node_modules/tsutils/util/index.js
@@ -0,0 +1,7 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./util"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLDRCQUF1QiJ9
\ No newline at end of file
diff --git a/node_modules/tsutils/util/util.d.ts b/node_modules/tsutils/util/util.d.ts
new file mode 100644
index 000000000..0ef1a1535
--- /dev/null
+++ b/node_modules/tsutils/util/util.d.ts
@@ -0,0 +1,70 @@
+import * as ts from 'typescript';
+export declare function getChildOfKind(node: ts.Node, kind: ts.SyntaxKind, sourceFile?: ts.SourceFile): ts.Node | 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 hasModifier(modifiers: ts.Modifier[] | 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 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 isPositionInComment(sourceFile: ts.SourceFile, pos: number, parent?: ts.Node): boolean;
+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.VariableLikeDeclaration & {
+    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 declare function endsControlFlow(statement: ts.Statement | ts.BlockLike): boolean;
+export interface LineRange extends ts.TextRange {
+    contentLength: number;
+}
+export declare function getLineRanges(sourceFile: ts.SourceFile): LineRange[];
+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;
diff --git a/node_modules/tsutils/util/util.js b/node_modules/tsutils/util/util.js
new file mode 100644
index 000000000..cc87c67c3
--- /dev/null
+++ b/node_modules/tsutils/util/util.js
@@ -0,0 +1,655 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ts = require("typescript");
+var node_1 = require("../typeguard/node");
+function getChildOfKind(node, kind, sourceFile) {
+    for (var _i = 0, _a = node.getChildren(sourceFile); _i < _a.length; _i++) {
+        var child = _a[_i];
+        if (child.kind === kind)
+            return child;
+    }
+}
+exports.getChildOfKind = getChildOfKind;
+function isTokenKind(kind) {
+    return kind >= ts.SyntaxKind.FirstToken && kind <= ts.SyntaxKind.LastToken;
+}
+exports.isTokenKind = isTokenKind;
+function isNodeKind(kind) {
+    return kind >= ts.SyntaxKind.FirstNode;
+}
+exports.isNodeKind = isNodeKind;
+function isAssignmentKind(kind) {
+    return kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+}
+exports.isAssignmentKind = isAssignmentKind;
+function isTypeNodeKind(kind) {
+    return kind >= ts.SyntaxKind.FirstTypeNode && kind <= ts.SyntaxKind.LastTypeNode;
+}
+exports.isTypeNodeKind = isTypeNodeKind;
+function isJsDocKind(kind) {
+    return kind >= ts.SyntaxKind.FirstJSDocNode && kind <= ts.SyntaxKind.LastJSDocNode;
+}
+exports.isJsDocKind = isJsDocKind;
+function isThisParameter(parameter) {
+    return parameter.name.kind === ts.SyntaxKind.Identifier && parameter.name.originalKeywordKind === ts.SyntaxKind.ThisKeyword;
+}
+exports.isThisParameter = isThisParameter;
+function hasModifier(modifiers) {
+    var kinds = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        kinds[_i - 1] = arguments[_i];
+    }
+    if (modifiers === undefined)
+        return false;
+    for (var _a = 0, modifiers_1 = modifiers; _a < modifiers_1.length; _a++) {
+        var modifier = modifiers_1[_a];
+        if (kinds.indexOf(modifier.kind) !== -1)
+            return true;
+    }
+    return false;
+}
+exports.hasModifier = hasModifier;
+function isParameterProperty(node) {
+    return hasModifier(node.modifiers, ts.SyntaxKind.PublicKeyword, ts.SyntaxKind.ProtectedKeyword, ts.SyntaxKind.PrivateKeyword, ts.SyntaxKind.ReadonlyKeyword);
+}
+exports.isParameterProperty = isParameterProperty;
+function hasAccessModifier(node) {
+    return hasModifier(node.modifiers, ts.SyntaxKind.PublicKeyword, ts.SyntaxKind.ProtectedKeyword, ts.SyntaxKind.PrivateKeyword);
+}
+exports.hasAccessModifier = hasAccessModifier;
+function isFlagSet(obj, flag) {
+    return (obj.flags & flag) !== 0;
+}
+exports.isNodeFlagSet = isFlagSet;
+exports.isTypeFlagSet = isFlagSet;
+exports.isSymbolFlagSet = isFlagSet;
+function isObjectFlagSet(objectType, flag) {
+    return (objectType.objectFlags & flag) !== 0;
+}
+exports.isObjectFlagSet = isObjectFlagSet;
+function isModfierFlagSet(node, flag) {
+    return (ts.getCombinedModifierFlags(node) & flag) !== 0;
+}
+exports.isModfierFlagSet = isModfierFlagSet;
+function getPreviousStatement(statement) {
+    var parent = statement.parent;
+    if (node_1.isBlockLike(parent)) {
+        var index = parent.statements.indexOf(statement);
+        if (index > 0)
+            return parent.statements[index - 1];
+    }
+}
+exports.getPreviousStatement = getPreviousStatement;
+function getNextStatement(statement) {
+    var parent = statement.parent;
+    if (node_1.isBlockLike(parent)) {
+        var index = parent.statements.indexOf(statement);
+        if (index < parent.statements.length)
+            return parent.statements[index + 1];
+    }
+}
+exports.getNextStatement = getNextStatement;
+function getPreviousToken(node, sourceFile) {
+    var parent = node.parent;
+    while (parent !== undefined && parent.pos === node.pos)
+        parent = parent.parent;
+    if (parent === undefined)
+        return;
+    outer: while (true) {
+        var children = parent.getChildren(sourceFile);
+        for (var i = children.length - 1; i >= 0; --i) {
+            var child = children[i];
+            if (child.pos < node.pos && child.kind !== ts.SyntaxKind.JSDocComment) {
+                if (isTokenKind(child.kind))
+                    return child;
+                parent = child;
+                continue outer;
+            }
+        }
+        return;
+    }
+}
+exports.getPreviousToken = getPreviousToken;
+function getNextToken(node, sourceFile) {
+    if (sourceFile === void 0) { sourceFile = node.getSourceFile(); }
+    if (node.kind === ts.SyntaxKind.SourceFile || node.kind === ts.SyntaxKind.EndOfFileToken)
+        return;
+    var end = node.end;
+    node = node.parent;
+    while (node.end === end) {
+        if (node.parent === undefined)
+            return node.endOfFileToken;
+        node = node.parent;
+    }
+    return getTokenAtPositionWorker(node, end + 1, sourceFile);
+}
+exports.getNextToken = getNextToken;
+function getTokenAtPosition(parent, pos, sourceFile) {
+    if (pos < parent.pos || pos > parent.end)
+        return;
+    if (isTokenKind(parent.kind))
+        return parent;
+    if (sourceFile === undefined)
+        sourceFile = parent.getSourceFile();
+    return getTokenAtPositionWorker(parent, pos, sourceFile);
+}
+exports.getTokenAtPosition = getTokenAtPosition;
+function getTokenAtPositionWorker(node, pos, sourceFile) {
+    outer: while (true) {
+        for (var _i = 0, _a = node.getChildren(sourceFile); _i < _a.length; _i++) {
+            var child = _a[_i];
+            if (child.end >= pos && child.kind !== ts.SyntaxKind.JSDocComment) {
+                if (isTokenKind(child.kind))
+                    return child;
+                node = child;
+                continue outer;
+            }
+        }
+        return;
+    }
+}
+function isPositionInComment(sourceFile, pos, parent) {
+    if (parent === void 0) { parent = sourceFile; }
+    var token = getTokenAtPosition(parent, pos, sourceFile);
+    if (token === undefined || pos >= token.end - (ts.tokenToString(token.kind) || '').length)
+        return false;
+    var cb = function (start, end) { return pos >= start && pos < end; };
+    return token.pos !== 0 && ts.forEachTrailingCommentRange(sourceFile.text, token.pos, cb) ||
+        ts.forEachLeadingCommentRange(sourceFile.text, token.pos, cb) === true;
+}
+exports.isPositionInComment = isPositionInComment;
+function getPropertyName(propertyName) {
+    if (propertyName.kind === ts.SyntaxKind.ComputedPropertyName) {
+        if (!node_1.isLiteralExpression(propertyName.expression))
+            return;
+        return propertyName.expression.text;
+    }
+    return propertyName.text;
+}
+exports.getPropertyName = getPropertyName;
+function forEachDestructuringIdentifier(pattern, fn) {
+    for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) {
+        var element = _a[_i];
+        if (element.kind !== ts.SyntaxKind.BindingElement)
+            continue;
+        var result = void 0;
+        if (element.name.kind === ts.SyntaxKind.Identifier) {
+            result = fn(element);
+        }
+        else {
+            result = forEachDestructuringIdentifier(element.name, fn);
+        }
+        if (result)
+            return result;
+    }
+}
+exports.forEachDestructuringIdentifier = forEachDestructuringIdentifier;
+function forEachDeclaredVariable(declarationList, cb) {
+    for (var _i = 0, _a = declarationList.declarations; _i < _a.length; _i++) {
+        var declaration = _a[_i];
+        var result = void 0;
+        if (declaration.name.kind === ts.SyntaxKind.Identifier) {
+            result = cb(declaration);
+        }
+        else {
+            result = forEachDestructuringIdentifier(declaration.name, cb);
+        }
+        if (result)
+            return result;
+    }
+}
+exports.forEachDeclaredVariable = forEachDeclaredVariable;
+var VariableDeclarationKind;
+(function (VariableDeclarationKind) {
+    VariableDeclarationKind[VariableDeclarationKind["Var"] = 0] = "Var";
+    VariableDeclarationKind[VariableDeclarationKind["Let"] = 1] = "Let";
+    VariableDeclarationKind[VariableDeclarationKind["Const"] = 2] = "Const";
+})(VariableDeclarationKind = exports.VariableDeclarationKind || (exports.VariableDeclarationKind = {}));
+function getVariableDeclarationKind(declarationList) {
+    if ((declarationList.flags & ts.NodeFlags.Let) !== 0)
+        return 1;
+    if ((declarationList.flags & ts.NodeFlags.Const) !== 0)
+        return 2;
+    return 0;
+}
+exports.getVariableDeclarationKind = getVariableDeclarationKind;
+function isBlockScopedVariableDeclarationList(declarationList) {
+    return getVariableDeclarationKind(declarationList) !== 0;
+}
+exports.isBlockScopedVariableDeclarationList = isBlockScopedVariableDeclarationList;
+function isBlockScopedVariableDeclaration(declaration) {
+    var parent = declaration.parent;
+    return parent.kind === ts.SyntaxKind.CatchClause ||
+        isBlockScopedVariableDeclarationList(parent);
+}
+exports.isBlockScopedVariableDeclaration = isBlockScopedVariableDeclaration;
+var ScopeBoundary;
+(function (ScopeBoundary) {
+    ScopeBoundary[ScopeBoundary["None"] = 0] = "None";
+    ScopeBoundary[ScopeBoundary["Function"] = 1] = "Function";
+    ScopeBoundary[ScopeBoundary["Block"] = 2] = "Block";
+})(ScopeBoundary = exports.ScopeBoundary || (exports.ScopeBoundary = {}));
+function isScopeBoundary(node) {
+    if (isFunctionScopeBoundary(node))
+        return 1;
+    if (isBlockScopeBoundary(node))
+        return 2;
+    return 0;
+}
+exports.isScopeBoundary = isScopeBoundary;
+function isFunctionScopeBoundary(node) {
+    switch (node.kind) {
+        case ts.SyntaxKind.FunctionExpression:
+        case ts.SyntaxKind.ArrowFunction:
+        case ts.SyntaxKind.Constructor:
+        case ts.SyntaxKind.ModuleDeclaration:
+        case ts.SyntaxKind.ClassDeclaration:
+        case ts.SyntaxKind.ClassExpression:
+        case ts.SyntaxKind.EnumDeclaration:
+        case ts.SyntaxKind.MethodDeclaration:
+        case ts.SyntaxKind.FunctionDeclaration:
+        case ts.SyntaxKind.GetAccessor:
+        case ts.SyntaxKind.SetAccessor:
+        case ts.SyntaxKind.InterfaceDeclaration:
+        case ts.SyntaxKind.TypeAliasDeclaration:
+        case ts.SyntaxKind.MethodSignature:
+        case ts.SyntaxKind.CallSignature:
+        case ts.SyntaxKind.ConstructSignature:
+        case ts.SyntaxKind.ConstructorType:
+        case ts.SyntaxKind.FunctionType:
+        case ts.SyntaxKind.MappedType:
+            return true;
+        case ts.SyntaxKind.SourceFile:
+            return ts.isExternalModule(node);
+        default:
+            return false;
+    }
+}
+exports.isFunctionScopeBoundary = isFunctionScopeBoundary;
+function isBlockScopeBoundary(node) {
+    switch (node.kind) {
+        case ts.SyntaxKind.Block:
+            var parent = node.parent;
+            return parent.kind !== ts.SyntaxKind.CatchClause &&
+                (parent.kind === ts.SyntaxKind.SourceFile ||
+                    !isFunctionScopeBoundary(parent));
+        case ts.SyntaxKind.ForStatement:
+        case ts.SyntaxKind.ForInStatement:
+        case ts.SyntaxKind.ForOfStatement:
+        case ts.SyntaxKind.CaseBlock:
+        case ts.SyntaxKind.CatchClause:
+            return true;
+        default:
+            return false;
+    }
+}
+exports.isBlockScopeBoundary = isBlockScopeBoundary;
+function hasOwnThisReference(node) {
+    switch (node.kind) {
+        case ts.SyntaxKind.ClassDeclaration:
+        case ts.SyntaxKind.ClassExpression:
+        case ts.SyntaxKind.FunctionExpression:
+            return true;
+        case ts.SyntaxKind.FunctionDeclaration:
+            return node.body !== undefined;
+        case ts.SyntaxKind.MethodDeclaration:
+        case ts.SyntaxKind.GetAccessor:
+        case ts.SyntaxKind.SetAccessor:
+            return node.parent.kind === ts.SyntaxKind.ObjectLiteralExpression;
+        default:
+            return false;
+    }
+}
+exports.hasOwnThisReference = hasOwnThisReference;
+function isFunctionWithBody(node) {
+    switch (node.kind) {
+        case ts.SyntaxKind.GetAccessor:
+        case ts.SyntaxKind.SetAccessor:
+        case ts.SyntaxKind.FunctionDeclaration:
+        case ts.SyntaxKind.MethodDeclaration:
+            return node.body !== undefined;
+        case ts.SyntaxKind.FunctionExpression:
+        case ts.SyntaxKind.Constructor:
+        case ts.SyntaxKind.ArrowFunction:
+            return true;
+        default:
+            return false;
+    }
+}
+exports.isFunctionWithBody = isFunctionWithBody;
+function forEachToken(node, cb, sourceFile) {
+    if (sourceFile === void 0) { sourceFile = node.getSourceFile(); }
+    return (function iterate(child) {
+        if (isTokenKind(child.kind))
+            return cb(child);
+        if (child.kind !== ts.SyntaxKind.JSDocComment)
+            return child.getChildren(sourceFile).forEach(iterate);
+    })(node);
+}
+exports.forEachToken = forEachToken;
+function forEachTokenWithTrivia(node, cb, sourceFile) {
+    if (sourceFile === void 0) { sourceFile = node.getSourceFile(); }
+    var fullText = sourceFile.text;
+    var notJsx = sourceFile.languageVariant !== ts.LanguageVariant.JSX;
+    var scanner = ts.createScanner(sourceFile.languageVersion, false, sourceFile.languageVariant, fullText);
+    return forEachToken(node, function (token) {
+        var tokenStart = token.getStart(sourceFile);
+        var end = token.end;
+        if (tokenStart !== token.pos && (notJsx || canHaveLeadingTrivia(token))) {
+            scanner.setTextPos(token.pos);
+            var position = void 0;
+            do {
+                var kind = scanner.scan();
+                position = scanner.getTextPos();
+                cb(fullText, kind, { pos: scanner.getTokenPos(), end: position }, token.parent);
+            } while (position < tokenStart);
+        }
+        return cb(fullText, token.kind, { end: end, pos: tokenStart }, token.parent);
+    }, sourceFile);
+}
+exports.forEachTokenWithTrivia = forEachTokenWithTrivia;
+function forEachComment(node, cb, sourceFile) {
+    if (sourceFile === void 0) { sourceFile = node.getSourceFile(); }
+    var fullText = sourceFile.text;
+    var notJsx = sourceFile.languageVariant !== ts.LanguageVariant.JSX;
+    return forEachToken(node, function (token) {
+        if (notJsx || canHaveLeadingTrivia(token))
+            ts.forEachLeadingCommentRange(fullText, token.pos, commentCallback);
+        if (notJsx || canHaveTrailingTrivia(token))
+            return ts.forEachTrailingCommentRange(fullText, token.end, commentCallback);
+    }, sourceFile);
+    function commentCallback(pos, end, kind) {
+        return cb(fullText, { pos: pos, end: end, kind: kind });
+    }
+}
+exports.forEachComment = forEachComment;
+function canHaveLeadingTrivia(_a) {
+    var kind = _a.kind, parent = _a.parent;
+    if (kind === ts.SyntaxKind.OpenBraceToken)
+        return parent.kind !== ts.SyntaxKind.JsxExpression || parent.parent.kind !== ts.SyntaxKind.JsxElement;
+    if (kind === ts.SyntaxKind.LessThanToken) {
+        if (parent.kind === ts.SyntaxKind.JsxClosingElement)
+            return false;
+        if (parent.kind === ts.SyntaxKind.JsxOpeningElement || parent.kind === ts.SyntaxKind.JsxSelfClosingElement)
+            return parent.parent.parent.kind !== ts.SyntaxKind.JsxElement;
+    }
+    return kind !== ts.SyntaxKind.JsxText;
+}
+function canHaveTrailingTrivia(_a) {
+    var kind = _a.kind, parent = _a.parent;
+    if (kind === ts.SyntaxKind.CloseBraceToken)
+        return parent.kind !== ts.SyntaxKind.JsxExpression || parent.parent.kind !== ts.SyntaxKind.JsxElement;
+    if (kind === ts.SyntaxKind.GreaterThanToken) {
+        if (parent.kind === ts.SyntaxKind.JsxOpeningElement)
+            return false;
+        if (parent.kind === ts.SyntaxKind.JsxClosingElement || parent.kind === ts.SyntaxKind.JsxSelfClosingElement)
+            return parent.parent.parent.kind !== ts.SyntaxKind.JsxElement;
+    }
+    return kind !== ts.SyntaxKind.JsxText;
+}
+function endsControlFlow(statement) {
+    return getControlFlowEnd(statement) !== 0;
+}
+exports.endsControlFlow = endsControlFlow;
+var StatementType;
+(function (StatementType) {
+    StatementType[StatementType["None"] = 0] = "None";
+    StatementType[StatementType["Break"] = 1] = "Break";
+    StatementType[StatementType["Other"] = 2] = "Other";
+})(StatementType || (StatementType = {}));
+function getControlFlowEnd(statement) {
+    while (node_1.isBlockLike(statement)) {
+        if (statement.statements.length === 0)
+            return 0;
+        statement = statement.statements[statement.statements.length - 1];
+    }
+    return hasReturnBreakContinueThrow(statement);
+}
+function hasReturnBreakContinueThrow(statement) {
+    switch (statement.kind) {
+        case ts.SyntaxKind.ReturnStatement:
+        case ts.SyntaxKind.ContinueStatement:
+        case ts.SyntaxKind.ThrowStatement:
+            return 2;
+        case ts.SyntaxKind.BreakStatement:
+            return 1;
+    }
+    if (node_1.isIfStatement(statement)) {
+        if (statement.elseStatement === undefined)
+            return 0;
+        var then = getControlFlowEnd(statement.thenStatement);
+        if (!then)
+            return then;
+        return Math.min(then, getControlFlowEnd(statement.elseStatement));
+    }
+    if (node_1.isSwitchStatement(statement)) {
+        var hasDefault = false;
+        var type = 0;
+        for (var _i = 0, _a = statement.caseBlock.clauses; _i < _a.length; _i++) {
+            var clause = _a[_i];
+            type = getControlFlowEnd(clause);
+            if (type === 1)
+                return 0;
+            if (clause.kind === ts.SyntaxKind.DefaultClause)
+                hasDefault = true;
+        }
+        return hasDefault && type !== 0 ? 2 : 0;
+    }
+    return 0;
+}
+function getLineRanges(sourceFile) {
+    var lineStarts = sourceFile.getLineStarts();
+    var result = [];
+    var length = lineStarts.length;
+    var sourceText = sourceFile.text;
+    var pos = 0;
+    for (var i = 1; i < length; ++i) {
+        var end = lineStarts[i];
+        result.push({
+            pos: pos,
+            end: end,
+            contentLength: end - pos - (sourceText[end - 2] === '\r' ? 2 : 1),
+        });
+        pos = end;
+    }
+    result.push({
+        pos: pos,
+        end: sourceFile.end,
+        contentLength: sourceFile.end - pos,
+    });
+    return result;
+}
+exports.getLineRanges = getLineRanges;
+var scanner;
+function scanToken(text) {
+    if (scanner === undefined)
+        scanner = ts.createScanner(ts.ScriptTarget.Latest, false);
+    scanner.setText(text);
+    scanner.scan();
+    return scanner;
+}
+function isValidIdentifier(text) {
+    var scan = scanToken(text);
+    return scan.isIdentifier() && scan.getTextPos() === text.length;
+}
+exports.isValidIdentifier = isValidIdentifier;
+function isValidPropertyAccess(text) {
+    if (!ts.isIdentifierStart(text.charCodeAt(0), ts.ScriptTarget.Latest))
+        return false;
+    for (var i = 1; i < text.length; ++i) {
+        if (!ts.isIdentifierPart(text.charCodeAt(i), ts.ScriptTarget.Latest))
+            return false;
+    }
+    return true;
+}
+exports.isValidPropertyAccess = isValidPropertyAccess;
+function isValidPropertyName(text) {
+    if (isValidPropertyAccess(text)) {
+        return true;
+    }
+    var scan = scanToken(text);
+    return scan.getTextPos() === text.length &&
+        scan.getToken() === ts.SyntaxKind.NumericLiteral && scan.getTokenValue() === text;
+}
+exports.isValidPropertyName = isValidPropertyName;
+function isValidNumericLiteral(text) {
+    var scan = scanToken(text);
+    return scan.getToken() === ts.SyntaxKind.NumericLiteral && scan.getTextPos() === text.length;
+}
+exports.isValidNumericLiteral = isValidNumericLiteral;
+function isSameLine(sourceFile, pos1, pos2) {
+    return ts.getLineAndCharacterOfPosition(sourceFile, pos1).line
+        === ts.getLineAndCharacterOfPosition(sourceFile, pos2).line;
+}
+exports.isSameLine = isSameLine;
+var SideEffectOptions;
+(function (SideEffectOptions) {
+    SideEffectOptions[SideEffectOptions["None"] = 0] = "None";
+    SideEffectOptions[SideEffectOptions["TaggedTemplate"] = 1] = "TaggedTemplate";
+    SideEffectOptions[SideEffectOptions["Constructor"] = 2] = "Constructor";
+    SideEffectOptions[SideEffectOptions["JsxElement"] = 4] = "JsxElement";
+})(SideEffectOptions = exports.SideEffectOptions || (exports.SideEffectOptions = {}));
+function hasSideEffects(node, options) {
+    switch (node.kind) {
+        case ts.SyntaxKind.CallExpression:
+        case ts.SyntaxKind.PostfixUnaryExpression:
+        case ts.SyntaxKind.AwaitExpression:
+        case ts.SyntaxKind.YieldExpression:
+        case ts.SyntaxKind.DeleteExpression:
+            return true;
+        case ts.SyntaxKind.TypeAssertionExpression:
+        case ts.SyntaxKind.AsExpression:
+        case ts.SyntaxKind.ParenthesizedExpression:
+        case ts.SyntaxKind.NonNullExpression:
+        case ts.SyntaxKind.VoidExpression:
+        case ts.SyntaxKind.TypeOfExpression:
+        case ts.SyntaxKind.PropertyAccessExpression:
+        case ts.SyntaxKind.SpreadElement:
+        case ts.SyntaxKind.PartiallyEmittedExpression:
+            return hasSideEffects(node.expression, options);
+        case ts.SyntaxKind.BinaryExpression:
+            return isAssignmentKind(node.operatorToken.kind) ||
+                hasSideEffects(node.left, options) ||
+                hasSideEffects(node.right, options);
+        case ts.SyntaxKind.PrefixUnaryExpression:
+            switch (node.operator) {
+                case ts.SyntaxKind.PlusPlusToken:
+                case ts.SyntaxKind.MinusMinusToken:
+                    return true;
+                default:
+                    return hasSideEffects(node.operand, options);
+            }
+        case ts.SyntaxKind.ElementAccessExpression:
+            return hasSideEffects(node.expression, options) ||
+                node.argumentExpression !== undefined &&
+                    hasSideEffects(node.argumentExpression, options);
+        case ts.SyntaxKind.ConditionalExpression:
+            return hasSideEffects(node.condition, options) ||
+                hasSideEffects(node.whenTrue, options) ||
+                hasSideEffects(node.whenFalse, options);
+        case ts.SyntaxKind.NewExpression:
+            if (options & 2 || hasSideEffects(node.expression, options))
+                return true;
+            if (node.arguments !== undefined)
+                for (var _i = 0, _a = node.arguments; _i < _a.length; _i++) {
+                    var child = _a[_i];
+                    if (hasSideEffects(child, options))
+                        return true;
+                }
+            return false;
+        case ts.SyntaxKind.TaggedTemplateExpression:
+            if (options & 1 || hasSideEffects(node.tag, options))
+                return true;
+            node = node.template;
+        case ts.SyntaxKind.TemplateExpression:
+            for (var _b = 0, _c = node.templateSpans; _b < _c.length; _b++) {
+                var child = _c[_b];
+                if (hasSideEffects(child.expression, options))
+                    return true;
+            }
+            return false;
+        case ts.SyntaxKind.ClassExpression:
+            return classExpressionHasSideEffects(node, options);
+        case ts.SyntaxKind.ArrayLiteralExpression:
+            for (var _d = 0, _e = node.elements; _d < _e.length; _d++) {
+                var child = _e[_d];
+                if (hasSideEffects(child, options))
+                    return true;
+            }
+            return false;
+        case ts.SyntaxKind.ObjectLiteralExpression:
+            for (var _f = 0, _g = node.properties; _f < _g.length; _f++) {
+                var child = _g[_f];
+                if (child.name !== undefined && child.name.kind === ts.SyntaxKind.ComputedPropertyName &&
+                    hasSideEffects(child.name.expression, options))
+                    return true;
+                switch (child.kind) {
+                    case ts.SyntaxKind.PropertyAssignment:
+                        if (hasSideEffects(child.initializer, options))
+                            return true;
+                        break;
+                    case ts.SyntaxKind.SpreadAssignment:
+                        if (hasSideEffects(child.expression, options))
+                            return true;
+                        break;
+                }
+            }
+            return false;
+        case ts.SyntaxKind.JsxExpression:
+            return node.expression !== undefined && hasSideEffects(node.expression, options);
+        case ts.SyntaxKind.JsxElement:
+            for (var _h = 0, _j = node.children; _h < _j.length; _h++) {
+                var child = _j[_h];
+                if (child.kind !== ts.SyntaxKind.JsxText && hasSideEffects(child, options))
+                    return true;
+            }
+            node = node.openingElement;
+        case ts.SyntaxKind.JsxSelfClosingElement:
+        case ts.SyntaxKind.JsxOpeningElement:
+            if (options & 4)
+                return true;
+            for (var _k = 0, _l = getJsxAttributes(node); _k < _l.length; _k++) {
+                var child = _l[_k];
+                if (child.kind === ts.SyntaxKind.JsxSpreadAttribute) {
+                    if (hasSideEffects(child.expression, options))
+                        return true;
+                }
+                else if (child.initializer !== undefined && hasSideEffects(child.initializer, options)) {
+                    return true;
+                }
+            }
+            return false;
+        default:
+            return false;
+    }
+}
+exports.hasSideEffects = hasSideEffects;
+function getJsxAttributes(openElement) {
+    var attributes = openElement.attributes;
+    return Array.isArray(attributes) ? attributes : attributes.properties;
+}
+function classExpressionHasSideEffects(node, options) {
+    if (node.heritageClauses !== undefined && node.heritageClauses[0].token === ts.SyntaxKind.ExtendsKeyword)
+        for (var _i = 0, _a = node.heritageClauses[0].types; _i < _a.length; _i++) {
+            var base = _a[_i];
+            if (hasSideEffects(base.expression, options))
+                return true;
+        }
+    for (var _b = 0, _c = node.members; _b < _c.length; _b++) {
+        var child = _c[_b];
+        if (child.name !== undefined && child.name.kind === ts.SyntaxKind.ComputedPropertyName &&
+            hasSideEffects(child.name.expression, options) ||
+            node_1.isPropertyDeclaration(child) && child.initializer !== undefined &&
+                hasSideEffects(child.initializer, options))
+            return true;
+    }
+    return false;
+}
+function getDeclarationOfBindingElement(node) {
+    var parent = node.parent.parent;
+    while (parent.kind === ts.SyntaxKind.BindingElement)
+        parent = parent.parent.parent;
+    return parent;
+}
+exports.getDeclarationOfBindingElement = getDeclarationOfBindingElement;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["util.ts"],"names":[],"mappings":"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"}
\ No newline at end of file