Deployed the page to Github Pages.

node_modules/tsutils/util/control-flow.d.ts

@@ -0,0 +1,9 @@
+import * as ts from 'typescript';
+export declare function endsControlFlow(statement: ts.Statement | ts.BlockLike): boolean;
+export declare type ControlFlowStatement = ts.BreakStatement | ts.ContinueStatement | ts.ReturnStatement | ts.ThrowStatement;
+export interface ControlFlowEnd {
+    readonly statements: ReadonlyArray<ControlFlowStatement>;
+    readonly end: boolean;
+}
+export declare function getControlFlowEnd(statement: ts.Statement | ts.BlockLike): ControlFlowEnd;
+export declare function getControlFlowEnd(statement: ts.Statement | ts.BlockLike, label?: ts.Identifier): ControlFlowEnd;

node_modules/tsutils/util/convert-ast.d.ts

@@ -0,0 +1,19 @@
+import * as ts from 'typescript';
+export interface NodeWrap {
+    node: ts.Node;
+    kind: ts.SyntaxKind;
+    children: NodeWrap[];
+    next?: NodeWrap;
+    skip?: NodeWrap;
+    parent?: NodeWrap;
+}
+export interface WrappedAst extends NodeWrap {
+    next: NodeWrap;
+    skip: undefined;
+    parent: undefined;
+}
+export interface ConvertedAst {
+    wrapped: WrappedAst;
+    flat: ReadonlyArray<ts.Node>;
+}
+export declare function convertAst(sourceFile: ts.SourceFile): ConvertedAst;

node_modules/tsutils/util/convert-ast.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ts = require("typescript");
+var util_1 = require("./util");
+function convertAst(sourceFile) {
+    var wrapped = {
+        node: sourceFile,
+        parent: undefined,
+        kind: ts.SyntaxKind.SourceFile,
+        children: [],
+        next: undefined,
+        skip: undefined,
+    };
+    var flat = [];
+    var current = wrapped;
+    var previous = current;
+    ts.forEachChild(sourceFile, function wrap(node) {
+        flat.push(node);
+        var parent = current;
+        previous.next = current = {
+            node: node,
+            parent: parent,
+            kind: node.kind,
+            children: [],
+            next: undefined,
+            skip: undefined,
+        };
+        if (previous !== parent)
+            setSkip(previous, current);
+        previous = current;
+        parent.children.push(current);
+        if (util_1.isNodeKind(node.kind))
+            ts.forEachChild(node, wrap);
+        current = parent;
+    });
+    return {
+        wrapped: wrapped,
+        flat: flat,
+    };
+}
+exports.convertAst = convertAst;
+function setSkip(node, skip) {
+    do {
+        node.skip = skip;
+        node = node.parent;
+    } while (node !== skip.parent);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udmVydC1hc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjb252ZXJ0LWFzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLCtCQUFpQztBQUNqQywrQkFBb0M7QUFtQ3BDLFNBQWdCLFVBQVUsQ0FBQyxVQUF5QjtJQUNoRCxJQUFNLE9BQU8sR0FBZTtRQUN4QixJQUFJLEVBQUUsVUFBVTtRQUNoQixNQUFNLEVBQUUsU0FBUztRQUNqQixJQUFJLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxVQUFVO1FBQzlCLFFBQVEsRUFBRSxFQUFFO1FBQ1osSUFBSSxFQUFPLFNBQVM7UUFDcEIsSUFBSSxFQUFFLFNBQVM7S0FDbEIsQ0FBQztJQUNGLElBQU0sSUFBSSxHQUFjLEVBQUUsQ0FBQztJQUMzQixJQUFJLE9BQU8sR0FBYSxPQUFPLENBQUM7SUFDaEMsSUFBSSxRQUFRLEdBQUcsT0FBTyxDQUFDO0lBQ3ZCLEVBQUUsQ0FBQyxZQUFZLENBQUMsVUFBVSxFQUFFLFNBQVMsSUFBSSxDQUFDLElBQUk7UUFDMUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNoQixJQUFNLE1BQU0sR0FBRyxPQUFPLENBQUM7UUFDdkIsUUFBUSxDQUFDLElBQUksR0FBRyxPQUFPLEdBQUc7WUFDdEIsSUFBSSxNQUFBO1lBQ0osTUFBTSxRQUFBO1lBQ04sSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJO1lBQ2YsUUFBUSxFQUFFLEVBQUU7WUFDWixJQUFJLEVBQUUsU0FBUztZQUNmLElBQUksRUFBRSxTQUFTO1NBQ2xCLENBQUM7UUFDRixJQUFJLFFBQVEsS0FBSyxNQUFNO1lBQ25CLE9BQU8sQ0FBQyxRQUFRLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFFL0IsUUFBUSxHQUFHLE9BQU8sQ0FBQztRQUNuQixNQUFNLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUU5QixJQUFJLGlCQUFVLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQztZQUNyQixFQUFFLENBQUMsWUFBWSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztRQUVoQyxPQUFPLEdBQUcsTUFBTSxDQUFDO0lBQ3JCLENBQUMsQ0FBQyxDQUFDO0lBRUgsT0FBTztRQUNILE9BQU8sU0FBQTtRQUNQLElBQUksTUFBQTtLQUNQLENBQUM7QUFDTixDQUFDO0FBdkNELGdDQXVDQztBQUVELFNBQVMsT0FBTyxDQUFDLElBQWMsRUFBRSxJQUFjO0lBQzNDLEdBQUc7UUFDQyxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztRQUNqQixJQUFJLEdBQUcsSUFBSSxDQUFDLE1BQU8sQ0FBQztLQUN2QixRQUFRLElBQUksS0FBSyxJQUFJLENBQUMsTUFBTSxFQUFFO0FBQ25DLENBQUMifQ==

node_modules/tsutils/util/index.d.ts

@@ -0,0 +1,5 @@
+export * from './util';
+export * from './usage';
+export * from './control-flow';
+export * from './type';
+export * from './convert-ast';

node_modules/tsutils/util/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./util"), exports);
+tslib_1.__exportStar(require("./usage"), exports);
+tslib_1.__exportStar(require("./control-flow"), exports);
+tslib_1.__exportStar(require("./type"), exports);
+tslib_1.__exportStar(require("./convert-ast"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpREFBdUI7QUFDdkIsa0RBQXdCO0FBQ3hCLHlEQUErQjtBQUMvQixpREFBdUI7QUFDdkIsd0RBQThCIn0=

node_modules/tsutils/util/type.d.ts

@@ -0,0 +1,9 @@
+import * as ts from 'typescript';
+export declare function isEmptyObjectType(type: ts.Type): type is ts.ObjectType;
+export declare function removeOptionalityFromType(checker: ts.TypeChecker, type: ts.Type): ts.Type;
+export declare function isTypeAssignableToNumber(checker: ts.TypeChecker, type: ts.Type): boolean;
+export declare function isTypeAssignableToString(checker: ts.TypeChecker, type: ts.Type): boolean;
+export declare function getCallSignaturesOfType(type: ts.Type): ReadonlyArray<ts.Signature>;
+export declare function unionTypeParts(type: ts.Type): ts.Type[];
+export declare function isThenableType(checker: ts.TypeChecker, node: ts.Expression, type?: ts.Type): boolean;
+export declare function isFalsyType(type: ts.Type): boolean;

node_modules/tsutils/util/usage.d.ts

@@ -0,0 +1,30 @@
+import * as ts from 'typescript';
+export interface VariableInfo {
+    domain: DeclarationDomain;
+    exported: boolean;
+    uses: VariableUse[];
+    inGlobalScope: boolean;
+    declarations: ts.Identifier[];
+}
+export interface VariableUse {
+    domain: UsageDomain;
+    location: ts.Identifier;
+}
+export declare const enum DeclarationDomain {
+    Namespace = 1,
+    Type = 2,
+    Value = 4,
+    Import = 8,
+    Any = 7
+}
+export declare const enum UsageDomain {
+    Namespace = 1,
+    Type = 2,
+    Value = 4,
+    ValueOrNamespace = 5,
+    Any = 7,
+    TypeQuery = 8
+}
+export declare function getUsageDomain(node: ts.Identifier): UsageDomain | undefined;
+export declare function getDeclarationDomain(node: ts.Identifier): DeclarationDomain | undefined;
+export declare function collectVariableUsage(sourceFile: ts.SourceFile): Map<ts.Identifier, VariableInfo>;

node_modules/tsutils/util/util.d.ts

@@ -0,0 +1,121 @@
+import * as ts from 'typescript';
+import { NodeWrap } from './convert-ast';
+export * from './control-flow';
+export declare function getChildOfKind<T extends ts.SyntaxKind>(node: ts.Node, kind: T, sourceFile?: ts.SourceFile): ts.Token<T> | undefined;
+export declare function isTokenKind(kind: ts.SyntaxKind): boolean;
+export declare function isNodeKind(kind: ts.SyntaxKind): boolean;
+export declare function isAssignmentKind(kind: ts.SyntaxKind): boolean;
+export declare function isTypeNodeKind(kind: ts.SyntaxKind): boolean;
+export declare function isJsDocKind(kind: ts.SyntaxKind): boolean;
+export declare function isThisParameter(parameter: ts.ParameterDeclaration): boolean;
+export declare function getModifier(node: ts.Node, kind: ts.Modifier['kind']): ts.Modifier | undefined;
+export declare function hasModifier(modifiers: ts.ModifiersArray | undefined, ...kinds: Array<ts.Modifier['kind']>): boolean;
+export declare function isParameterProperty(node: ts.ParameterDeclaration): boolean;
+export declare function hasAccessModifier(node: ts.ClassElement | ts.ParameterDeclaration): boolean;
+export declare const isNodeFlagSet: (node: ts.Node, flag: ts.NodeFlags) => boolean;
+export declare const isTypeFlagSet: (type: ts.Type, flag: ts.TypeFlags) => boolean;
+export declare const isSymbolFlagSet: (symbol: ts.Symbol, flag: ts.SymbolFlags) => boolean;
+export declare function isObjectFlagSet(objectType: ts.ObjectType, flag: ts.ObjectFlags): boolean;
+export declare function isModifierFlagSet(node: ts.Declaration, flag: ts.ModifierFlags): boolean;
+export declare function isModifierFlagSet(node: ts.Node, flag: ts.ModifierFlags): boolean;
+export declare function isModfierFlagSet(node: ts.Node, flag: ts.ModifierFlags): boolean;
+export declare function getPreviousStatement(statement: ts.Statement): ts.Statement | undefined;
+export declare function getNextStatement(statement: ts.Statement): ts.Statement | undefined;
+export declare function getPreviousToken(node: ts.Node, sourceFile?: ts.SourceFile): ts.Node | undefined;
+export declare function getNextToken(node: ts.Node, sourceFile?: ts.SourceFile): ts.Node | undefined;
+export declare function getTokenAtPosition(parent: ts.Node, pos: number, sourceFile?: ts.SourceFile): ts.Node | undefined;
+export declare function getCommentAtPosition(sourceFile: ts.SourceFile, pos: number, parent?: ts.Node): ts.CommentRange | undefined;
+export declare function isPositionInComment(sourceFile: ts.SourceFile, pos: number, parent?: ts.Node): boolean;
+export declare function getWrappedNodeAtPosition(wrap: NodeWrap, pos: number): NodeWrap | undefined;
+export declare function getPropertyName(propertyName: ts.PropertyName): string | undefined;
+export declare function forEachDestructuringIdentifier<T>(pattern: ts.BindingPattern, fn: (element: ts.BindingElement & {
+    name: ts.Identifier;
+}) => T): T | undefined;
+export declare function forEachDeclaredVariable<T>(declarationList: ts.VariableDeclarationList, cb: (element: (ts.VariableDeclaration | ts.BindingElement) & {
+    name: ts.Identifier;
+}) => T): T | undefined;
+export declare const enum VariableDeclarationKind {
+    Var = 0,
+    Let = 1,
+    Const = 2
+}
+export declare function getVariableDeclarationKind(declarationList: ts.VariableDeclarationList): VariableDeclarationKind;
+export declare function isBlockScopedVariableDeclarationList(declarationList: ts.VariableDeclarationList): boolean;
+export declare function isBlockScopedVariableDeclaration(declaration: ts.VariableDeclaration): boolean;
+export declare const enum ScopeBoundary {
+    None = 0,
+    Function = 1,
+    Block = 2
+}
+export declare function isScopeBoundary(node: ts.Node): ScopeBoundary;
+export declare function isFunctionScopeBoundary(node: ts.Node): boolean;
+export declare function isBlockScopeBoundary(node: ts.Node): boolean;
+export declare function hasOwnThisReference(node: ts.Node): boolean;
+export declare function isFunctionWithBody(node: ts.Node): node is ts.FunctionLikeDeclaration;
+export declare function forEachToken(node: ts.Node, cb: (node: ts.Node) => void, sourceFile?: ts.SourceFile): void;
+export declare type ForEachTokenCallback = (fullText: string, kind: ts.SyntaxKind, range: ts.TextRange, parent: ts.Node) => void;
+export declare function forEachTokenWithTrivia(node: ts.Node, cb: ForEachTokenCallback, sourceFile?: ts.SourceFile): void;
+export declare type ForEachCommentCallback = (fullText: string, comment: ts.CommentRange) => void;
+export declare function forEachComment(node: ts.Node, cb: ForEachCommentCallback, sourceFile?: ts.SourceFile): void;
+export interface LineRange extends ts.TextRange {
+    contentLength: number;
+}
+export declare function getLineRanges(sourceFile: ts.SourceFile): LineRange[];
+export declare function getLineBreakStyle(sourceFile: ts.SourceFile): "\n" | "\r\n";
+export declare function isValidIdentifier(text: string): boolean;
+export declare function isValidPropertyAccess(text: string): boolean;
+export declare function isValidPropertyName(text: string): boolean;
+export declare function isValidNumericLiteral(text: string): boolean;
+export declare function isSameLine(sourceFile: ts.SourceFile, pos1: number, pos2: number): boolean;
+export declare const enum SideEffectOptions {
+    None = 0,
+    TaggedTemplate = 1,
+    Constructor = 2,
+    JsxElement = 4
+}
+export declare function hasSideEffects(node: ts.Expression, options?: SideEffectOptions): boolean;
+export declare function getDeclarationOfBindingElement(node: ts.BindingElement): ts.VariableDeclaration | ts.ParameterDeclaration;
+export declare function isExpressionValueUsed(node: ts.Expression): boolean;
+export declare function isReassignmentTarget(node: ts.Expression): boolean;
+export declare function getIdentifierText(node: ts.Identifier): string;
+export declare function canHaveJsDoc(node: ts.Node): node is ts.HasJSDoc;
+export declare function getJsDoc(node: ts.Node, sourceFile?: ts.SourceFile): ts.JSDoc[];
+export declare function parseJsDocOfNode(node: ts.Node, considerTrailingComments?: boolean, sourceFile?: ts.SourceFile): ts.JSDoc[];
+export declare const enum ImportKind {
+    ImportDeclaration = 1,
+    ImportEquals = 2,
+    ExportFrom = 4,
+    DynamicImport = 8,
+    Require = 16,
+    ImportType = 32,
+    All = 63,
+    AllImports = 59,
+    AllStaticImports = 3,
+    AllImportExpressions = 24,
+    AllRequireLike = 18
+}
+export declare const enum ImportOptions {
+    ImportDeclaration = 1,
+    ImportEquals = 2,
+    ExportFrom = 4,
+    DynamicImport = 8,
+    Require = 16,
+    All = 31,
+    AllImports = 27,
+    AllStaticImports = 3,
+    AllDynamic = 24,
+    AllRequireLike = 18
+}
+export declare function findImports(sourceFile: ts.SourceFile, kinds: ImportKind): ts.LiteralExpression[];
+export declare function findImports(sourceFile: ts.SourceFile, options: ImportOptions): ts.LiteralExpression[];
+export declare function isStatementInAmbientContext(node: ts.Statement): boolean;
+export declare function isAmbientModuleBlock(node: ts.Node): node is ts.ModuleBlock;
+export declare function getIIFE(func: ts.FunctionExpression | ts.ArrowFunction): ts.CallExpression | undefined;
+export declare type StrictCompilerOption = 'noImplicitAny' | 'noImplicitThis' | 'strictNullChecks' | 'strictFunctionTypes' | 'strictPropertyInitialization' | 'alwaysStrict';
+export declare function isStrictCompilerOptionEnabled(options: ts.CompilerOptions, option: StrictCompilerOption): boolean;
+export declare type BooleanCompilerOptions = {
+    [K in keyof ts.CompilerOptions]: NonNullable<ts.CompilerOptions[K]> extends boolean ? K : never;
+} extends {
+    [_ in keyof ts.CompilerOptions]: infer U;
+} ? U : never;
+export declare function isCompilerOptionEnabled(options: ts.CompilerOptions, option: BooleanCompilerOptions | 'stripInternal'): boolean;