brighterscript 1.0.0-alpha.13 → 1.0.0-alpha.16

package/dist/lexer/Lexer.spec.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint no-template-curly-in-string: 0 */
 const chai_1 = require("chai");
-const _1 = require(".");
+const TokenKind_1 = require("./TokenKind");
 const Lexer_1 = require("./Lexer");
 const Token_1 = require("./Token");
 const Parser_spec_1 = require("../parser/Parser.spec");
@@ -12,36 +12,36 @@ describe('lexer', () => {
     it('recognizes namespace keywords', () => {
         let { tokens } = Lexer_1.Lexer.scan('namespace end namespace endnamespace end   namespace');
         (0, chai_1.expect)(tokens.map(x => x.kind)).to.eql([
-            _1.TokenKind.Namespace,
-            _1.TokenKind.EndNamespace,
-            _1.TokenKind.EndNamespace,
-            _1.TokenKind.EndNamespace,
-            _1.TokenKind.Eof
+            TokenKind_1.TokenKind.Namespace,
+            TokenKind_1.TokenKind.EndNamespace,
+            TokenKind_1.TokenKind.EndNamespace,
+            TokenKind_1.TokenKind.EndNamespace,
+            TokenKind_1.TokenKind.Eof
         ]);
     });
     it('recognizes the callfunc operator', () => {
         let { tokens } = Lexer_1.Lexer.scan('@.');
-        (0, chai_1.expect)(tokens[0].kind).to.equal(_1.TokenKind.Callfunc);
+        (0, chai_1.expect)(tokens[0].kind).to.equal(TokenKind_1.TokenKind.Callfunc);
     });
     it('recognizes the import token', () => {
         let { tokens } = Lexer_1.Lexer.scan('import');
-        (0, chai_1.expect)(tokens[0].kind).to.eql(_1.TokenKind.Import);
+        (0, chai_1.expect)(tokens[0].kind).to.eql(TokenKind_1.TokenKind.Import);
     });
     it('recognizes library token', () => {
         let { tokens } = Lexer_1.Lexer.scan('library');
-        (0, chai_1.expect)(tokens[0].kind).to.eql(_1.TokenKind.Library);
+        (0, chai_1.expect)(tokens[0].kind).to.eql(TokenKind_1.TokenKind.Library);
     });
     it('recognizes the question mark operator', () => {
         let { tokens } = Lexer_1.Lexer.scan('?');
-        (0, chai_1.expect)(tokens[0].kind).to.equal(_1.TokenKind.Question);
+        (0, chai_1.expect)(tokens[0].kind).to.equal(TokenKind_1.TokenKind.Question);
     });
     it('produces an at symbol token', () => {
         let { tokens } = Lexer_1.Lexer.scan('@');
-        (0, chai_1.expect)(tokens[0].kind).to.equal(_1.TokenKind.At);
+        (0, chai_1.expect)(tokens[0].kind).to.equal(TokenKind_1.TokenKind.At);
     });
     it('produces a semicolon token', () => {
         let { tokens } = Lexer_1.Lexer.scan(';');
-        (0, chai_1.expect)(tokens[0].kind).to.equal(_1.TokenKind.Semicolon);
+        (0, chai_1.expect)(tokens[0].kind).to.equal(TokenKind_1.TokenKind.Semicolon);
     });
     it('emits error on unknown character type', () => {
         let { diagnostics } = Lexer_1.Lexer.scan('\0');
@@ -49,26 +49,26 @@ describe('lexer', () => {
     });
     it('includes an end-of-file marker', () => {
         let { tokens } = Lexer_1.Lexer.scan('');
-        (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([_1.TokenKind.Eof]);
+        (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([TokenKind_1.TokenKind.Eof]);
     });
     it('ignores tabs and spaces', () => {
         let { tokens } = Lexer_1.Lexer.scan('\t\t  \t     \t');
-        (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([_1.TokenKind.Eof]);
+        (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([TokenKind_1.TokenKind.Eof]);
     });
     it('retains every single newline', () => {
         let { tokens } = Lexer_1.Lexer.scan('\n\n\'foo\n\n\nprint 2\n\n');
         (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-            _1.TokenKind.Newline,
-            _1.TokenKind.Newline,
-            _1.TokenKind.Comment,
-            _1.TokenKind.Newline,
-            _1.TokenKind.Newline,
-            _1.TokenKind.Newline,
-            _1.TokenKind.Print,
-            _1.TokenKind.IntegerLiteral,
-            _1.TokenKind.Newline,
-            _1.TokenKind.Newline,
-            _1.TokenKind.Eof
+            TokenKind_1.TokenKind.Newline,
+            TokenKind_1.TokenKind.Newline,
+            TokenKind_1.TokenKind.Comment,
+            TokenKind_1.TokenKind.Newline,
+            TokenKind_1.TokenKind.Newline,
+            TokenKind_1.TokenKind.Newline,
+            TokenKind_1.TokenKind.Print,
+            TokenKind_1.TokenKind.IntegerLiteral,
+            TokenKind_1.TokenKind.Newline,
+            TokenKind_1.TokenKind.Newline,
+            TokenKind_1.TokenKind.Eof
         ]);
     });
     it('does not insert double newlines with the windows \\r\\n newline', () => {
@@ -80,14 +80,14 @@ describe('lexer', () => {
             '   end if\r\n' +
             'end function\r\n').tokens.map(x => x.kind);
         (0, chai_1.expect)(kinds).to.eql([
-            _1.TokenKind.Function, _1.TokenKind.Identifier, _1.TokenKind.LeftParen, _1.TokenKind.RightParen, _1.TokenKind.As, _1.TokenKind.String, _1.TokenKind.Newline,
-            _1.TokenKind.If, _1.TokenKind.True, _1.TokenKind.Then, _1.TokenKind.Newline,
-            _1.TokenKind.Print, _1.TokenKind.IntegerLiteral, _1.TokenKind.Newline,
-            _1.TokenKind.Else, _1.TokenKind.Newline,
-            _1.TokenKind.Print, _1.TokenKind.IntegerLiteral, _1.TokenKind.Newline,
-            _1.TokenKind.EndIf, _1.TokenKind.Newline,
-            _1.TokenKind.EndFunction, _1.TokenKind.Newline,
-            _1.TokenKind.Eof
+            TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.LeftParen, TokenKind_1.TokenKind.RightParen, TokenKind_1.TokenKind.As, TokenKind_1.TokenKind.String, TokenKind_1.TokenKind.Newline,
+            TokenKind_1.TokenKind.If, TokenKind_1.TokenKind.True, TokenKind_1.TokenKind.Then, TokenKind_1.TokenKind.Newline,
+            TokenKind_1.TokenKind.Print, TokenKind_1.TokenKind.IntegerLiteral, TokenKind_1.TokenKind.Newline,
+            TokenKind_1.TokenKind.Else, TokenKind_1.TokenKind.Newline,
+            TokenKind_1.TokenKind.Print, TokenKind_1.TokenKind.IntegerLiteral, TokenKind_1.TokenKind.Newline,
+            TokenKind_1.TokenKind.EndIf, TokenKind_1.TokenKind.Newline,
+            TokenKind_1.TokenKind.EndFunction, TokenKind_1.TokenKind.Newline,
+            TokenKind_1.TokenKind.Eof
         ]);
     });
     it('computes range properly both with and without whitespace', () => {
@@ -95,7 +95,7 @@ describe('lexer', () => {
             .map(x => (0, Parser_spec_1.rangeToArray)(x.range));
         let withWhitespace = Lexer_1.Lexer.scan(`sub Main()\n    bob = true\nend sub`).tokens
             //filter out the whitespace...we only care that it was computed during the scan
-            .filter(x => x.kind !== _1.TokenKind.Whitespace)
+            .filter(x => x.kind !== TokenKind_1.TokenKind.Whitespace)
             .map(x => (0, Parser_spec_1.rangeToArray)(x.range));
         /*eslint-disable */
         let expectedLocations = [
@@ -126,26 +126,26 @@ describe('lexer', () => {
     it('correctly splits the elseif token', () => {
         let { tokens } = Lexer_1.Lexer.scan('else if elseif else   if');
         (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-            _1.TokenKind.Else,
-            _1.TokenKind.If,
-            _1.TokenKind.Else,
-            _1.TokenKind.If,
-            _1.TokenKind.Else,
-            _1.TokenKind.If,
-            _1.TokenKind.Eof
+            TokenKind_1.TokenKind.Else,
+            TokenKind_1.TokenKind.If,
+            TokenKind_1.TokenKind.Else,
+            TokenKind_1.TokenKind.If,
+            TokenKind_1.TokenKind.Else,
+            TokenKind_1.TokenKind.If,
+            TokenKind_1.TokenKind.Eof
         ]);
     });
     it('gives the `as` keyword its own TokenKind', () => {
         let { tokens } = Lexer_1.Lexer.scan('as');
-        (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([_1.TokenKind.As, _1.TokenKind.Eof]);
+        (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([TokenKind_1.TokenKind.As, TokenKind_1.TokenKind.Eof]);
     });
     it('gives the `stop` keyword its own TokenKind', () => {
         let { tokens } = Lexer_1.Lexer.scan('stop');
-        (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([_1.TokenKind.Stop, _1.TokenKind.Eof]);
+        (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([TokenKind_1.TokenKind.Stop, TokenKind_1.TokenKind.Eof]);
     });
     it('does not alias \'?\' to \'print\' - the parser will do that', () => {
         let { tokens } = Lexer_1.Lexer.scan('?2');
-        (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([_1.TokenKind.Question, _1.TokenKind.IntegerLiteral, _1.TokenKind.Eof]);
+        (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([TokenKind_1.TokenKind.Question, TokenKind_1.TokenKind.IntegerLiteral, TokenKind_1.TokenKind.Eof]);
     });
     describe('comments', () => {
         it('does not include carriage return character', () => {
@@ -157,7 +157,7 @@ describe('lexer', () => {
                 'comment
                 REM some comment
             `).tokens
-                .filter(x => ![_1.TokenKind.Newline, _1.TokenKind.Eof].includes(x.kind))
+                .filter(x => ![TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Eof].includes(x.kind))
                 .map(x => x.text);
             (0, chai_1.expect)(text).to.eql([
                 `'comment`,
@@ -207,14 +207,14 @@ describe('lexer', () => {
             let tokens = Lexer_1.Lexer.scan(`
                 'comment
                 REM some comment
-            `).tokens.filter(x => ![_1.TokenKind.Newline, _1.TokenKind.Eof].includes(x.kind));
+            `).tokens.filter(x => ![TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Eof].includes(x.kind));
             (0, chai_1.expect)(tokens[0].range).to.eql(vscode_languageserver_1.Range.create(1, 16, 1, 24));
             (0, chai_1.expect)(tokens[1].range).to.eql(vscode_languageserver_1.Range.create(2, 16, 2, 32));
         });
         it('finds correct location for newlines', () => {
             let tokens = Lexer_1.Lexer.scan('sub\nsub\r\nsub\n\n').tokens
                 //ignore the Eof token
-                .filter(x => x.kind !== _1.TokenKind.Eof);
+                .filter(x => x.kind !== TokenKind_1.TokenKind.Eof);
             (0, chai_1.expect)(tokens.map(x => x.range)).to.eql([
                 vscode_languageserver_1.Range.create(0, 0, 0, 3),
                 vscode_languageserver_1.Range.create(0, 3, 0, 4),
@@ -237,91 +237,91 @@ describe('lexer', () => {
                     end if 'comment
                 end sub
             `);
-            let comments = tokens.filter(x => x.kind === _1.TokenKind.Comment);
+            let comments = tokens.filter(x => x.kind === TokenKind_1.TokenKind.Comment);
             (0, chai_1.expect)(comments).to.be.lengthOf(1);
             (0, chai_1.expect)(comments[0].range).to.eql(vscode_languageserver_1.Range.create(8, 27, 8, 35));
         });
         it('ignores everything after `\'`', () => {
             let { tokens } = Lexer_1.Lexer.scan('= \' (');
-            (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([_1.TokenKind.Equal, _1.TokenKind.Comment, _1.TokenKind.Eof]);
+            (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([TokenKind_1.TokenKind.Equal, TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Eof]);
         });
         it('ignores everything after `REM`', () => {
             let { tokens } = Lexer_1.Lexer.scan('= REM (');
-            (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([_1.TokenKind.Equal, _1.TokenKind.Comment, _1.TokenKind.Eof]);
+            (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([TokenKind_1.TokenKind.Equal, TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Eof]);
         });
         it('ignores everything after `rem`', () => {
             let { tokens } = Lexer_1.Lexer.scan('= rem (');
-            (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([_1.TokenKind.Equal, _1.TokenKind.Comment, _1.TokenKind.Eof]);
+            (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([TokenKind_1.TokenKind.Equal, TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Eof]);
         });
     }); // comments
     describe('non-literals', () => {
         it('reads parens & braces', () => {
             let { tokens } = Lexer_1.Lexer.scan('(){}');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.LeftParen,
-                _1.TokenKind.RightParen,
-                _1.TokenKind.LeftCurlyBrace,
-                _1.TokenKind.RightCurlyBrace,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.LeftParen,
+                TokenKind_1.TokenKind.RightParen,
+                TokenKind_1.TokenKind.LeftCurlyBrace,
+                TokenKind_1.TokenKind.RightCurlyBrace,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('reads operators', () => {
             let { tokens } = Lexer_1.Lexer.scan('^ - + * MOD / \\ -- ++');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.Caret,
-                _1.TokenKind.Minus,
-                _1.TokenKind.Plus,
-                _1.TokenKind.Star,
-                _1.TokenKind.Mod,
-                _1.TokenKind.Forwardslash,
-                _1.TokenKind.Backslash,
-                _1.TokenKind.MinusMinus,
-                _1.TokenKind.PlusPlus,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.Caret,
+                TokenKind_1.TokenKind.Minus,
+                TokenKind_1.TokenKind.Plus,
+                TokenKind_1.TokenKind.Star,
+                TokenKind_1.TokenKind.Mod,
+                TokenKind_1.TokenKind.Forwardslash,
+                TokenKind_1.TokenKind.Backslash,
+                TokenKind_1.TokenKind.MinusMinus,
+                TokenKind_1.TokenKind.PlusPlus,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('reads bitshift operators', () => {
             let { tokens } = Lexer_1.Lexer.scan('<< >> <<');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.LeftShift,
-                _1.TokenKind.RightShift,
-                _1.TokenKind.LeftShift,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.LeftShift,
+                TokenKind_1.TokenKind.RightShift,
+                TokenKind_1.TokenKind.LeftShift,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('reads bitshift assignment operators', () => {
             let { tokens } = Lexer_1.Lexer.scan('<<= >>=');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.LeftShiftEqual,
-                _1.TokenKind.RightShiftEqual,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.LeftShiftEqual,
+                TokenKind_1.TokenKind.RightShiftEqual,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('reads comparators', () => {
             let { tokens } = Lexer_1.Lexer.scan('< <= > >= = <>');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.Less,
-                _1.TokenKind.LessEqual,
-                _1.TokenKind.Greater,
-                _1.TokenKind.GreaterEqual,
-                _1.TokenKind.Equal,
-                _1.TokenKind.LessGreater,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.Less,
+                TokenKind_1.TokenKind.LessEqual,
+                TokenKind_1.TokenKind.Greater,
+                TokenKind_1.TokenKind.GreaterEqual,
+                TokenKind_1.TokenKind.Equal,
+                TokenKind_1.TokenKind.LessGreater,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
     }); // non-literals
     describe('string literals', () => {
         it('produces string literal tokens', () => {
             let { tokens } = Lexer_1.Lexer.scan(`"hello world"`);
-            (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([_1.TokenKind.StringLiteral, _1.TokenKind.Eof]);
+            (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([TokenKind_1.TokenKind.StringLiteral, TokenKind_1.TokenKind.Eof]);
         });
         it(`safely escapes " literals`, () => {
             let { tokens } = Lexer_1.Lexer.scan(`"the cat says ""meow"""`);
-            (0, chai_1.expect)(tokens[0].kind).to.equal(_1.TokenKind.StringLiteral);
+            (0, chai_1.expect)(tokens[0].kind).to.equal(TokenKind_1.TokenKind.StringLiteral);
         });
         it('captures text to end of line for unterminated strings with LF', () => {
             let { tokens } = Lexer_1.Lexer.scan(`"unterminated!\n`);
-            (0, chai_1.expect)(tokens[0].kind).to.eql(_1.TokenKind.StringLiteral);
+            (0, chai_1.expect)(tokens[0].kind).to.eql(TokenKind_1.TokenKind.StringLiteral);
         });
         it('captures text to end of line for unterminated strings with CRLF', () => {
             let { tokens } = Lexer_1.Lexer.scan(`"unterminated!\r\n`);
@@ -339,18 +339,18 @@ describe('lexer', () => {
         it('supports escaped chars', () => {
             let { tokens } = Lexer_1.Lexer.scan('`\\n\\`\\r\\n`');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.BackTick,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.BackTick,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.Eof
             ]);
             (0, chai_1.expect)(tokens.map(x => x.charCode).filter(x => !!x)).to.eql([
                 10,
@@ -362,27 +362,27 @@ describe('lexer', () => {
         it('prevents expressions when escaping the dollar sign', () => {
             let { tokens } = Lexer_1.Lexer.scan('`\\${just text}`');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.BackTick,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.BackTick,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('supports escaping unicode char codes', () => {
             let { tokens } = Lexer_1.Lexer.scan('`\\c1\\c12\\c123`');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.BackTick,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.BackTick,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.Eof
             ]);
             (0, chai_1.expect)(tokens.map(x => x.charCode).filter(x => !!x)).to.eql([
                 1,
@@ -393,26 +393,26 @@ describe('lexer', () => {
         it('converts doublequote to EscapedCharCodeLiteral', () => {
             let { tokens } = Lexer_1.Lexer.scan('`"`');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.BackTick,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.BackTick,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.Eof
             ]);
             (0, chai_1.expect)(tokens[2].charCode).to.equal(34);
         });
         it(`safely escapes \` literals`, () => {
             let { tokens } = Lexer_1.Lexer.scan('`the cat says \\`meow\\` a lot`');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.BackTick,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.BackTick,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.Eof
             ]);
             (0, chai_1.expect)(tokens.map(x => x.text)).to.eql([
                 '`',
@@ -428,24 +428,24 @@ describe('lexer', () => {
         it('produces template string literal tokens', () => {
             let { tokens } = Lexer_1.Lexer.scan('`hello world`');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.BackTick,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.BackTick,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.Eof
             ]);
             (0, chai_1.expect)(tokens[1].text).to.deep.equal('hello world');
         });
         it('collects quasis outside and expressions inside of template strings', () => {
             let { tokens } = Lexer_1.Lexer.scan('`hello ${"world"}!`');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.BackTick,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.TemplateStringExpressionBegin,
-                _1.TokenKind.StringLiteral,
-                _1.TokenKind.TemplateStringExpressionEnd,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.BackTick,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.TemplateStringExpressionBegin,
+                TokenKind_1.TokenKind.StringLiteral,
+                TokenKind_1.TokenKind.TemplateStringExpressionEnd,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.Eof
             ]);
             (0, chai_1.expect)(tokens[1].text).to.deep.equal(`hello `);
         });
@@ -467,130 +467,130 @@ describe('lexer', () => {
                 end function
             `);
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.Newline,
-                _1.TokenKind.Function,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.LeftParen,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.RightParen,
-                _1.TokenKind.Newline,
-                _1.TokenKind.Return,
-                _1.TokenKind.BackTick,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.TemplateStringExpressionBegin,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Dot,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.TemplateStringExpressionEnd,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.TemplateStringExpressionBegin,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Dot,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.TemplateStringExpressionEnd,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.TemplateStringExpressionBegin,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Dot,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Dot,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Dot,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Dot,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.TemplateStringExpressionEnd,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.BackTick,
-                _1.TokenKind.Newline,
-                _1.TokenKind.EndFunction,
-                _1.TokenKind.Newline,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.Newline,
+                TokenKind_1.TokenKind.Function,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.LeftParen,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.RightParen,
+                TokenKind_1.TokenKind.Newline,
+                TokenKind_1.TokenKind.Return,
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.TemplateStringExpressionBegin,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Dot,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.TemplateStringExpressionEnd,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.TemplateStringExpressionBegin,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Dot,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.TemplateStringExpressionEnd,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.TemplateStringExpressionBegin,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Dot,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Dot,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Dot,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Dot,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.TemplateStringExpressionEnd,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.Newline,
+                TokenKind_1.TokenKind.EndFunction,
+                TokenKind_1.TokenKind.Newline,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('complicated example', () => {
             let { tokens } = Lexer_1.Lexer.scan('`hello ${"world"}!I am a ${"template" + "string"} and I am very ${["pleased"][0]} to meet you ${m.top.getChildCount()}.The end`');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.eql([
-                _1.TokenKind.BackTick,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.TemplateStringExpressionBegin,
-                _1.TokenKind.StringLiteral,
-                _1.TokenKind.TemplateStringExpressionEnd,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.TemplateStringExpressionBegin,
-                _1.TokenKind.StringLiteral,
-                _1.TokenKind.Plus,
-                _1.TokenKind.StringLiteral,
-                _1.TokenKind.TemplateStringExpressionEnd,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.TemplateStringExpressionBegin,
-                _1.TokenKind.LeftSquareBracket,
-                _1.TokenKind.StringLiteral,
-                _1.TokenKind.RightSquareBracket,
-                _1.TokenKind.LeftSquareBracket,
-                _1.TokenKind.IntegerLiteral,
-                _1.TokenKind.RightSquareBracket,
-                _1.TokenKind.TemplateStringExpressionEnd,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.TemplateStringExpressionBegin,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Dot,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Dot,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.LeftParen,
-                _1.TokenKind.RightParen,
-                _1.TokenKind.TemplateStringExpressionEnd,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.BackTick,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.TemplateStringExpressionBegin,
+                TokenKind_1.TokenKind.StringLiteral,
+                TokenKind_1.TokenKind.TemplateStringExpressionEnd,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.TemplateStringExpressionBegin,
+                TokenKind_1.TokenKind.StringLiteral,
+                TokenKind_1.TokenKind.Plus,
+                TokenKind_1.TokenKind.StringLiteral,
+                TokenKind_1.TokenKind.TemplateStringExpressionEnd,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.TemplateStringExpressionBegin,
+                TokenKind_1.TokenKind.LeftSquareBracket,
+                TokenKind_1.TokenKind.StringLiteral,
+                TokenKind_1.TokenKind.RightSquareBracket,
+                TokenKind_1.TokenKind.LeftSquareBracket,
+                TokenKind_1.TokenKind.IntegerLiteral,
+                TokenKind_1.TokenKind.RightSquareBracket,
+                TokenKind_1.TokenKind.TemplateStringExpressionEnd,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.TemplateStringExpressionBegin,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Dot,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Dot,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.LeftParen,
+                TokenKind_1.TokenKind.RightParen,
+                TokenKind_1.TokenKind.TemplateStringExpressionEnd,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('allows multiline strings', () => {
             let { tokens } = Lexer_1.Lexer.scan('`multi-line\n\n`');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.BackTick,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.BackTick,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.Eof
             ]);
             (0, chai_1.expect)(tokens.map(x => x.text)).to.eql([
                 '`',
@@ -611,161 +611,161 @@ describe('lexer', () => {
                     kind: x.kind
                 };
             })).to.eql([
-                { range: vscode_languageserver_1.Range.create(0, 0, 0, 3), kind: _1.TokenKind.IntegerLiteral },
-                { range: vscode_languageserver_1.Range.create(0, 4, 0, 5), kind: _1.TokenKind.BackTick },
-                { range: vscode_languageserver_1.Range.create(0, 5, 0, 10), kind: _1.TokenKind.TemplateStringQuasi },
-                { range: vscode_languageserver_1.Range.create(0, 10, 0, 11), kind: _1.TokenKind.EscapedCharCodeLiteral },
-                { range: vscode_languageserver_1.Range.create(1, 0, 1, 4), kind: _1.TokenKind.TemplateStringQuasi },
-                { range: vscode_languageserver_1.Range.create(1, 4, 1, 5), kind: _1.TokenKind.EscapedCharCodeLiteral },
-                { range: vscode_languageserver_1.Range.create(1, 5, 1, 6), kind: _1.TokenKind.EscapedCharCodeLiteral },
-                { range: vscode_languageserver_1.Range.create(2, 0, 2, 7), kind: _1.TokenKind.TemplateStringQuasi },
-                { range: vscode_languageserver_1.Range.create(2, 7, 2, 8), kind: _1.TokenKind.BackTick },
-                { range: vscode_languageserver_1.Range.create(2, 9, 2, 13), kind: _1.TokenKind.True },
-                { range: vscode_languageserver_1.Range.create(2, 13, 2, 14), kind: _1.TokenKind.Newline },
-                { range: vscode_languageserver_1.Range.create(3, 0, 3, 5), kind: _1.TokenKind.False },
-                { range: vscode_languageserver_1.Range.create(3, 5, 3, 6), kind: _1.TokenKind.Eof }
+                { range: vscode_languageserver_1.Range.create(0, 0, 0, 3), kind: TokenKind_1.TokenKind.IntegerLiteral },
+                { range: vscode_languageserver_1.Range.create(0, 4, 0, 5), kind: TokenKind_1.TokenKind.BackTick },
+                { range: vscode_languageserver_1.Range.create(0, 5, 0, 10), kind: TokenKind_1.TokenKind.TemplateStringQuasi },
+                { range: vscode_languageserver_1.Range.create(0, 10, 0, 11), kind: TokenKind_1.TokenKind.EscapedCharCodeLiteral },
+                { range: vscode_languageserver_1.Range.create(1, 0, 1, 4), kind: TokenKind_1.TokenKind.TemplateStringQuasi },
+                { range: vscode_languageserver_1.Range.create(1, 4, 1, 5), kind: TokenKind_1.TokenKind.EscapedCharCodeLiteral },
+                { range: vscode_languageserver_1.Range.create(1, 5, 1, 6), kind: TokenKind_1.TokenKind.EscapedCharCodeLiteral },
+                { range: vscode_languageserver_1.Range.create(2, 0, 2, 7), kind: TokenKind_1.TokenKind.TemplateStringQuasi },
+                { range: vscode_languageserver_1.Range.create(2, 7, 2, 8), kind: TokenKind_1.TokenKind.BackTick },
+                { range: vscode_languageserver_1.Range.create(2, 9, 2, 13), kind: TokenKind_1.TokenKind.True },
+                { range: vscode_languageserver_1.Range.create(2, 13, 2, 14), kind: TokenKind_1.TokenKind.Newline },
+                { range: vscode_languageserver_1.Range.create(3, 0, 3, 5), kind: TokenKind_1.TokenKind.False },
+                { range: vscode_languageserver_1.Range.create(3, 5, 3, 6), kind: TokenKind_1.TokenKind.Eof }
             ]);
         });
         it('Example that tripped up the expression tests', () => {
             let { tokens } = Lexer_1.Lexer.scan('`I am a complex example\n${a.isRunning(["a","b","c"])}\nmore ${m.finish(true)}`');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.BackTick,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.TemplateStringExpressionBegin,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Dot,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.LeftParen,
-                _1.TokenKind.LeftSquareBracket,
-                _1.TokenKind.StringLiteral,
-                _1.TokenKind.Comma,
-                _1.TokenKind.StringLiteral,
-                _1.TokenKind.Comma,
-                _1.TokenKind.StringLiteral,
-                _1.TokenKind.RightSquareBracket,
-                _1.TokenKind.RightParen,
-                _1.TokenKind.TemplateStringExpressionEnd,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.EscapedCharCodeLiteral,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.TemplateStringExpressionBegin,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Dot,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.LeftParen,
-                _1.TokenKind.True,
-                _1.TokenKind.RightParen,
-                _1.TokenKind.TemplateStringExpressionEnd,
-                _1.TokenKind.TemplateStringQuasi,
-                _1.TokenKind.BackTick,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.TemplateStringExpressionBegin,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Dot,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.LeftParen,
+                TokenKind_1.TokenKind.LeftSquareBracket,
+                TokenKind_1.TokenKind.StringLiteral,
+                TokenKind_1.TokenKind.Comma,
+                TokenKind_1.TokenKind.StringLiteral,
+                TokenKind_1.TokenKind.Comma,
+                TokenKind_1.TokenKind.StringLiteral,
+                TokenKind_1.TokenKind.RightSquareBracket,
+                TokenKind_1.TokenKind.RightParen,
+                TokenKind_1.TokenKind.TemplateStringExpressionEnd,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.EscapedCharCodeLiteral,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.TemplateStringExpressionBegin,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Dot,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.LeftParen,
+                TokenKind_1.TokenKind.True,
+                TokenKind_1.TokenKind.RightParen,
+                TokenKind_1.TokenKind.TemplateStringExpressionEnd,
+                TokenKind_1.TokenKind.TemplateStringQuasi,
+                TokenKind_1.TokenKind.BackTick,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
     }); // string literals
     describe('double literals', () => {
         it('respects \'#\' suffix', () => {
             let d = Lexer_1.Lexer.scan('123#').tokens[0];
-            (0, chai_1.expect)(d.kind).to.equal(_1.TokenKind.DoubleLiteral);
+            (0, chai_1.expect)(d.kind).to.equal(TokenKind_1.TokenKind.DoubleLiteral);
             (0, chai_1.expect)(d.text).to.eql('123#');
         });
         it('forces literals >= 10 digits into doubles', () => {
             let d = Lexer_1.Lexer.scan('0000000005').tokens[0];
-            (0, chai_1.expect)(d.kind).to.equal(_1.TokenKind.DoubleLiteral);
+            (0, chai_1.expect)(d.kind).to.equal(TokenKind_1.TokenKind.DoubleLiteral);
             (0, chai_1.expect)(d.text).to.eql('0000000005');
         });
         it('forces literals with \'D\' in exponent into doubles', () => {
             let d = Lexer_1.Lexer.scan('2.5d3').tokens[0];
-            (0, chai_1.expect)(d.kind).to.equal(_1.TokenKind.DoubleLiteral);
+            (0, chai_1.expect)(d.kind).to.equal(TokenKind_1.TokenKind.DoubleLiteral);
             (0, chai_1.expect)(d.text).to.eql('2.5d3');
         });
         it('allows digits before `.` to be elided', () => {
             let f = Lexer_1.Lexer.scan('.123#').tokens[0];
-            (0, chai_1.expect)(f.kind).to.equal(_1.TokenKind.DoubleLiteral);
+            (0, chai_1.expect)(f.kind).to.equal(TokenKind_1.TokenKind.DoubleLiteral);
             (0, chai_1.expect)(f.text).to.eql('.123#');
         });
         it('allows digits after `.` to be elided', () => {
             let f = Lexer_1.Lexer.scan('12.#').tokens[0];
-            (0, chai_1.expect)(f.kind).to.equal(_1.TokenKind.DoubleLiteral);
+            (0, chai_1.expect)(f.kind).to.equal(TokenKind_1.TokenKind.DoubleLiteral);
             (0, chai_1.expect)(f.text).to.eql('12.#');
         });
     });
     describe('float literals', () => {
         it('respects \'!\' suffix', () => {
             let f = Lexer_1.Lexer.scan('0.00000008!').tokens[0];
-            (0, chai_1.expect)(f.kind).to.equal(_1.TokenKind.FloatLiteral);
+            (0, chai_1.expect)(f.kind).to.equal(TokenKind_1.TokenKind.FloatLiteral);
             // Floating precision will make this *not* equal
             (0, chai_1.expect)(f.text).not.to.equal(8e-8);
             (0, chai_1.expect)(f.text).to.eql('0.00000008!');
         });
         it('forces literals with a decimal into floats', () => {
             let f = Lexer_1.Lexer.scan('1.0').tokens[0];
-            (0, chai_1.expect)(f.kind).to.equal(_1.TokenKind.FloatLiteral);
+            (0, chai_1.expect)(f.kind).to.equal(TokenKind_1.TokenKind.FloatLiteral);
             (0, chai_1.expect)(f.text).to.equal('1.0');
         });
         it('forces literals with \'E\' in exponent into floats', () => {
             let f = Lexer_1.Lexer.scan('2.5e3').tokens[0];
-            (0, chai_1.expect)(f.kind).to.equal(_1.TokenKind.FloatLiteral);
+            (0, chai_1.expect)(f.kind).to.equal(TokenKind_1.TokenKind.FloatLiteral);
             (0, chai_1.expect)(f.text).to.eql('2.5e3');
         });
         it('supports larger-than-supported-precision floats to be defined with exponents', () => {
             let f = Lexer_1.Lexer.scan('2.3659475627512424e-38').tokens[0];
-            (0, chai_1.expect)(f.kind).to.equal(_1.TokenKind.FloatLiteral);
+            (0, chai_1.expect)(f.kind).to.equal(TokenKind_1.TokenKind.FloatLiteral);
             (0, chai_1.expect)(f.text).to.eql('2.3659475627512424e-38');
         });
         it('allows digits before `.` to be elided', () => {
             let f = Lexer_1.Lexer.scan('.123').tokens[0];
-            (0, chai_1.expect)(f.kind).to.equal(_1.TokenKind.FloatLiteral);
+            (0, chai_1.expect)(f.kind).to.equal(TokenKind_1.TokenKind.FloatLiteral);
             (0, chai_1.expect)(f.text).to.equal('.123');
         });
         it('allows digits after `.` to be elided', () => {
             let f = Lexer_1.Lexer.scan('12.').tokens[0];
-            (0, chai_1.expect)(f.kind).to.equal(_1.TokenKind.FloatLiteral);
+            (0, chai_1.expect)(f.kind).to.equal(TokenKind_1.TokenKind.FloatLiteral);
             (0, chai_1.expect)(f.text).to.equal('12.');
         });
     });
     describe('long integer literals', () => {
         it('respects \'&\' suffix', () => {
             let f = Lexer_1.Lexer.scan('1&').tokens[0];
-            (0, chai_1.expect)(f.kind).to.equal(_1.TokenKind.LongIntegerLiteral);
+            (0, chai_1.expect)(f.kind).to.equal(TokenKind_1.TokenKind.LongIntegerLiteral);
             (0, chai_1.expect)(f.text).to.eql('1&');
         });
         it('supports hexadecimal literals', () => {
             let i = Lexer_1.Lexer.scan('&hf00d&').tokens[0];
-            (0, chai_1.expect)(i.kind).to.equal(_1.TokenKind.LongIntegerLiteral);
+            (0, chai_1.expect)(i.kind).to.equal(TokenKind_1.TokenKind.LongIntegerLiteral);
             (0, chai_1.expect)(i.text).to.equal('&hf00d&');
         });
         it('allows very long Int64 literals', () => {
             let li = Lexer_1.Lexer.scan('9876543210&').tokens[0];
-            (0, chai_1.expect)(li.kind).to.equal(_1.TokenKind.LongIntegerLiteral);
+            (0, chai_1.expect)(li.kind).to.equal(TokenKind_1.TokenKind.LongIntegerLiteral);
             (0, chai_1.expect)(li.text).to.equal('9876543210&');
         });
         it('forces literals with \'&\' suffix into Int64s', () => {
             let li = Lexer_1.Lexer.scan('123&').tokens[0];
-            (0, chai_1.expect)(li.kind).to.equal(_1.TokenKind.LongIntegerLiteral);
+            (0, chai_1.expect)(li.kind).to.equal(TokenKind_1.TokenKind.LongIntegerLiteral);
             (0, chai_1.expect)(li.text).to.deep.equal('123&');
         });
     });
     describe('integer literals', () => {
         it('respects \'%\' suffix', () => {
             let f = Lexer_1.Lexer.scan('1%').tokens[0];
-            (0, chai_1.expect)(f.kind).to.equal(_1.TokenKind.IntegerLiteral);
+            (0, chai_1.expect)(f.kind).to.equal(TokenKind_1.TokenKind.IntegerLiteral);
             (0, chai_1.expect)(f.text).to.eql('1%');
         });
         it('does not allow decimal numbers to end with %', () => {
             let f = Lexer_1.Lexer.scan('1.2%').tokens[0];
-            (0, chai_1.expect)(f.kind).to.equal(_1.TokenKind.FloatLiteral);
+            (0, chai_1.expect)(f.kind).to.equal(TokenKind_1.TokenKind.FloatLiteral);
             (0, chai_1.expect)(f.text).to.eql('1.2');
         });
         it('supports hexadecimal literals', () => {
             let i = Lexer_1.Lexer.scan('&hFf').tokens[0];
-            (0, chai_1.expect)(i.kind).to.equal(_1.TokenKind.IntegerLiteral);
+            (0, chai_1.expect)(i.kind).to.equal(TokenKind_1.TokenKind.IntegerLiteral);
             (0, chai_1.expect)(i.text).to.deep.equal('&hFf');
         });
         it('falls back to a regular integer', () => {
             let i = Lexer_1.Lexer.scan('123').tokens[0];
-            (0, chai_1.expect)(i.kind).to.equal(_1.TokenKind.IntegerLiteral);
+            (0, chai_1.expect)(i.kind).to.equal(TokenKind_1.TokenKind.IntegerLiteral);
             (0, chai_1.expect)(i.text).to.deep.equal('123');
         });
     });
@@ -774,18 +774,18 @@ describe('lexer', () => {
             (0, chai_1.expect)(Lexer_1.Lexer.scan(`
                 void boolean integer longinteger float double string object interface invalid dynamic
             `.trim()).tokens.map(x => x.kind)).to.eql([
-                _1.TokenKind.Void,
-                _1.TokenKind.Boolean,
-                _1.TokenKind.Integer,
-                _1.TokenKind.LongInteger,
-                _1.TokenKind.Float,
-                _1.TokenKind.Double,
-                _1.TokenKind.String,
-                _1.TokenKind.Object,
-                _1.TokenKind.Interface,
-                _1.TokenKind.Invalid,
-                _1.TokenKind.Dynamic,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.Void,
+                TokenKind_1.TokenKind.Boolean,
+                TokenKind_1.TokenKind.Integer,
+                TokenKind_1.TokenKind.LongInteger,
+                TokenKind_1.TokenKind.Float,
+                TokenKind_1.TokenKind.Double,
+                TokenKind_1.TokenKind.String,
+                TokenKind_1.TokenKind.Object,
+                TokenKind_1.TokenKind.Interface,
+                TokenKind_1.TokenKind.Invalid,
+                TokenKind_1.TokenKind.Dynamic,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
     });
@@ -795,57 +795,57 @@ describe('lexer', () => {
             // if we find any that we've missed
             let { tokens } = Lexer_1.Lexer.scan('and then or if else endif return true false line_num');
             (0, chai_1.expect)(tokens.map(w => w.kind)).to.deep.equal([
-                _1.TokenKind.And,
-                _1.TokenKind.Then,
-                _1.TokenKind.Or,
-                _1.TokenKind.If,
-                _1.TokenKind.Else,
-                _1.TokenKind.EndIf,
-                _1.TokenKind.Return,
-                _1.TokenKind.True,
-                _1.TokenKind.False,
-                _1.TokenKind.LineNumLiteral,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.And,
+                TokenKind_1.TokenKind.Then,
+                TokenKind_1.TokenKind.Or,
+                TokenKind_1.TokenKind.If,
+                TokenKind_1.TokenKind.Else,
+                TokenKind_1.TokenKind.EndIf,
+                TokenKind_1.TokenKind.Return,
+                TokenKind_1.TokenKind.True,
+                TokenKind_1.TokenKind.False,
+                TokenKind_1.TokenKind.LineNumLiteral,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('matches multi-word keywords', () => {
             let { tokens } = Lexer_1.Lexer.scan('end if end while End Sub end Function Exit wHILe');
             (0, chai_1.expect)(tokens.map(w => w.kind)).to.deep.equal([
-                _1.TokenKind.EndIf,
-                _1.TokenKind.EndWhile,
-                _1.TokenKind.EndSub,
-                _1.TokenKind.EndFunction,
-                _1.TokenKind.ExitWhile,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.EndIf,
+                TokenKind_1.TokenKind.EndWhile,
+                TokenKind_1.TokenKind.EndSub,
+                TokenKind_1.TokenKind.EndFunction,
+                TokenKind_1.TokenKind.ExitWhile,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('accepts \'exit for\' but not \'exitfor\'', () => {
             let { tokens } = Lexer_1.Lexer.scan('exit for exitfor');
             (0, chai_1.expect)(tokens.map(w => w.kind)).to.deep.equal([
-                _1.TokenKind.ExitFor,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.ExitFor,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('matches keywords with silly capitalization', () => {
             let { tokens } = Lexer_1.Lexer.scan('iF ELSE eNDIf FUncTioN');
             (0, chai_1.expect)(tokens.map(w => w.kind)).to.deep.equal([
-                _1.TokenKind.If,
-                _1.TokenKind.Else,
-                _1.TokenKind.EndIf,
-                _1.TokenKind.Function,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.If,
+                TokenKind_1.TokenKind.Else,
+                TokenKind_1.TokenKind.EndIf,
+                TokenKind_1.TokenKind.Function,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('allows alpha-numeric (plus \'_\') identifiers', () => {
             let identifier = Lexer_1.Lexer.scan('_abc_123_').tokens[0];
-            (0, chai_1.expect)(identifier.kind).to.equal(_1.TokenKind.Identifier);
+            (0, chai_1.expect)(identifier.kind).to.equal(TokenKind_1.TokenKind.Identifier);
             (0, chai_1.expect)(identifier.text).to.equal('_abc_123_');
         });
         it('allows identifiers with trailing type designators', () => {
             let { tokens } = Lexer_1.Lexer.scan('lorem$ ipsum% dolor! sit# amet&');
-            let identifiers = tokens.filter(t => t.kind !== _1.TokenKind.Eof);
-            (0, chai_1.expect)(identifiers.every(t => t.kind === _1.TokenKind.Identifier));
+            let identifiers = tokens.filter(t => t.kind !== TokenKind_1.TokenKind.Eof);
+            (0, chai_1.expect)(identifiers.every(t => t.kind === TokenKind_1.TokenKind.Identifier));
             (0, chai_1.expect)(identifiers.map(t => t.text)).to.deep.equal([
                 'lorem$',
                 'ipsum%',
@@ -859,19 +859,19 @@ describe('lexer', () => {
         it('reads constant declarations', () => {
             let { tokens } = Lexer_1.Lexer.scan('#const foo true');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.HashConst,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.True,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.HashConst,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.True,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('reads constant aliases', () => {
             let { tokens } = Lexer_1.Lexer.scan('#const bar foo');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.HashConst,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.HashConst,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('reads conditional directives', () => {
@@ -885,19 +885,19 @@ describe('lexer', () => {
             `, {
                 includeWhitespace: false
             });
-            (0, chai_1.expect)(tokens.map(t => t.kind).filter(x => x !== _1.TokenKind.Newline)).to.deep.equal([
-                _1.TokenKind.HashIf,
-                _1.TokenKind.HashElseIf,
-                _1.TokenKind.HashElseIf,
-                _1.TokenKind.HashElse,
-                _1.TokenKind.HashEndIf,
-                _1.TokenKind.HashEndIf,
-                _1.TokenKind.Eof
+            (0, chai_1.expect)(tokens.map(t => t.kind).filter(x => x !== TokenKind_1.TokenKind.Newline)).to.deep.equal([
+                TokenKind_1.TokenKind.HashIf,
+                TokenKind_1.TokenKind.HashElseIf,
+                TokenKind_1.TokenKind.HashElseIf,
+                TokenKind_1.TokenKind.HashElse,
+                TokenKind_1.TokenKind.HashEndIf,
+                TokenKind_1.TokenKind.HashEndIf,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('treats text "constructor" as an identifier', () => {
             let lexer = Lexer_1.Lexer.scan(`function constructor()\nend function`);
-            (0, chai_1.expect)(lexer.tokens[1].kind).to.equal(_1.TokenKind.Identifier);
+            (0, chai_1.expect)(lexer.tokens[1].kind).to.equal(TokenKind_1.TokenKind.Identifier);
         });
         it('reads upper case conditional directives', () => {
             let { tokens } = Lexer_1.Lexer.scan(`
@@ -910,25 +910,25 @@ describe('lexer', () => {
             `, {
                 includeWhitespace: false
             });
-            (0, chai_1.expect)(tokens.map(t => t.kind).filter(x => x !== _1.TokenKind.Newline)).to.deep.equal([
-                _1.TokenKind.HashIf,
-                _1.TokenKind.HashElseIf,
-                _1.TokenKind.HashElseIf,
-                _1.TokenKind.HashElse,
-                _1.TokenKind.HashEndIf,
-                _1.TokenKind.HashEndIf,
-                _1.TokenKind.Eof
+            (0, chai_1.expect)(tokens.map(t => t.kind).filter(x => x !== TokenKind_1.TokenKind.Newline)).to.deep.equal([
+                TokenKind_1.TokenKind.HashIf,
+                TokenKind_1.TokenKind.HashElseIf,
+                TokenKind_1.TokenKind.HashElseIf,
+                TokenKind_1.TokenKind.HashElse,
+                TokenKind_1.TokenKind.HashEndIf,
+                TokenKind_1.TokenKind.HashEndIf,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('supports various spacings between #endif', () => {
             let { tokens } = Lexer_1.Lexer.scan('#endif #end if #end\tif #end  if #end\t\t if');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.HashEndIf,
-                _1.TokenKind.HashEndIf,
-                _1.TokenKind.HashEndIf,
-                _1.TokenKind.HashEndIf,
-                _1.TokenKind.HashEndIf,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.HashEndIf,
+                TokenKind_1.TokenKind.HashEndIf,
+                TokenKind_1.TokenKind.HashEndIf,
+                TokenKind_1.TokenKind.HashEndIf,
+                TokenKind_1.TokenKind.HashEndIf,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('reads forced compilation diagnostics with messages', () => {
@@ -936,11 +936,11 @@ describe('lexer', () => {
                 includeWhitespace: true
             });
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.HashError,
-                _1.TokenKind.Whitespace,
-                _1.TokenKind.HashErrorMessage,
-                _1.TokenKind.Newline,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.HashError,
+                TokenKind_1.TokenKind.Whitespace,
+                TokenKind_1.TokenKind.HashErrorMessage,
+                TokenKind_1.TokenKind.Newline,
+                TokenKind_1.TokenKind.Eof
             ]);
             (0, chai_1.expect)(tokens[2].text).to.equal('a message goes here');
         });
@@ -984,26 +984,26 @@ describe('lexer', () => {
         it('supports various spacing between for each', () => {
             let { tokens } = Lexer_1.Lexer.scan('for each for  each for    each for\teach for\t each for \teach for \t each');
             (0, chai_1.expect)(tokens.map(t => t.kind)).to.deep.equal([
-                _1.TokenKind.ForEach,
-                _1.TokenKind.ForEach,
-                _1.TokenKind.ForEach,
-                _1.TokenKind.ForEach,
-                _1.TokenKind.ForEach,
-                _1.TokenKind.ForEach,
-                _1.TokenKind.ForEach,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.ForEach,
+                TokenKind_1.TokenKind.ForEach,
+                TokenKind_1.TokenKind.ForEach,
+                TokenKind_1.TokenKind.ForEach,
+                TokenKind_1.TokenKind.ForEach,
+                TokenKind_1.TokenKind.ForEach,
+                TokenKind_1.TokenKind.ForEach,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
     });
     it('detects rem when used as keyword', () => {
         let { tokens } = Lexer_1.Lexer.scan('person.rem=true');
         (0, chai_1.expect)(tokens.map(t => t.kind)).to.eql([
-            _1.TokenKind.Identifier,
-            _1.TokenKind.Dot,
-            _1.TokenKind.Identifier,
-            _1.TokenKind.Equal,
-            _1.TokenKind.True,
-            _1.TokenKind.Eof
+            TokenKind_1.TokenKind.Identifier,
+            TokenKind_1.TokenKind.Dot,
+            TokenKind_1.TokenKind.Identifier,
+            TokenKind_1.TokenKind.Equal,
+            TokenKind_1.TokenKind.True,
+            TokenKind_1.TokenKind.Eof
         ]);
         //verify the location of `rem`
         (0, chai_1.expect)(tokens.map(t => [t.range.start.character, t.range.end.character])).to.eql([
@@ -1018,61 +1018,69 @@ describe('lexer', () => {
     describe('isToken', () => {
         it('works', () => {
             let range = vscode_languageserver_1.Range.create(0, 0, 0, 2);
-            (0, chai_1.expect)((0, Token_1.isToken)({ kind: _1.TokenKind.And, text: 'and', range: range })).is.true;
+            (0, chai_1.expect)((0, Token_1.isToken)({ kind: TokenKind_1.TokenKind.And, text: 'and', range: range })).is.true;
             (0, chai_1.expect)((0, Token_1.isToken)({ text: 'and', range: range })).is.false;
         });
     });
+    it('recognizes enum-related keywords', () => {
+        (0, chai_1.expect)(Lexer_1.Lexer.scan('enum end enum endenum').tokens.map(x => x.kind)).to.eql([
+            TokenKind_1.TokenKind.Enum,
+            TokenKind_1.TokenKind.EndEnum,
+            TokenKind_1.TokenKind.EndEnum,
+            TokenKind_1.TokenKind.Eof
+        ]);
+    });
     it('recognizes class-related keywords', () => {
         (0, chai_1.expect)(Lexer_1.Lexer.scan('class public protected private end class endclass new override').tokens.map(x => x.kind)).to.eql([
-            _1.TokenKind.Class,
-            _1.TokenKind.Public,
-            _1.TokenKind.Protected,
-            _1.TokenKind.Private,
-            _1.TokenKind.EndClass,
-            _1.TokenKind.EndClass,
-            _1.TokenKind.New,
-            _1.TokenKind.Override,
-            _1.TokenKind.Eof
+            TokenKind_1.TokenKind.Class,
+            TokenKind_1.TokenKind.Public,
+            TokenKind_1.TokenKind.Protected,
+            TokenKind_1.TokenKind.Private,
+            TokenKind_1.TokenKind.EndClass,
+            TokenKind_1.TokenKind.EndClass,
+            TokenKind_1.TokenKind.New,
+            TokenKind_1.TokenKind.Override,
+            TokenKind_1.TokenKind.Eof
         ]);
     });
     describe('whitespace', () => {
         it('preserves the exact number of whitespace characterswhitespace', () => {
             let { tokens } = Lexer_1.Lexer.scan('   ', { includeWhitespace: true });
             (0, chai_1.expect)(tokens[0]).to.include({
-                kind: _1.TokenKind.Whitespace,
+                kind: TokenKind_1.TokenKind.Whitespace,
                 text: '   '
             });
         });
         it('tokenizes whitespace between things', () => {
             let { tokens } = Lexer_1.Lexer.scan('sub main ( ) \n end sub', { includeWhitespace: true });
             (0, chai_1.expect)(tokens.map(x => x.kind)).to.eql([
-                _1.TokenKind.Sub,
-                _1.TokenKind.Whitespace,
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Whitespace,
-                _1.TokenKind.LeftParen,
-                _1.TokenKind.Whitespace,
-                _1.TokenKind.RightParen,
-                _1.TokenKind.Whitespace,
-                _1.TokenKind.Newline,
-                _1.TokenKind.Whitespace,
-                _1.TokenKind.EndSub,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.Sub,
+                TokenKind_1.TokenKind.Whitespace,
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Whitespace,
+                TokenKind_1.TokenKind.LeftParen,
+                TokenKind_1.TokenKind.Whitespace,
+                TokenKind_1.TokenKind.RightParen,
+                TokenKind_1.TokenKind.Whitespace,
+                TokenKind_1.TokenKind.Newline,
+                TokenKind_1.TokenKind.Whitespace,
+                TokenKind_1.TokenKind.EndSub,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
     });
     it('identifies brighterscript source literals', () => {
         let { tokens } = Lexer_1.Lexer.scan('LINE_NUM SOURCE_FILE_PATH SOURCE_LINE_NUM FUNCTION_NAME SOURCE_FUNCTION_NAME SOURCE_LOCATION PKG_PATH PKG_LOCATION');
         (0, chai_1.expect)(tokens.map(x => x.kind)).to.eql([
-            _1.TokenKind.LineNumLiteral,
-            _1.TokenKind.SourceFilePathLiteral,
-            _1.TokenKind.SourceLineNumLiteral,
-            _1.TokenKind.FunctionNameLiteral,
-            _1.TokenKind.SourceFunctionNameLiteral,
-            _1.TokenKind.SourceLocationLiteral,
-            _1.TokenKind.PkgPathLiteral,
-            _1.TokenKind.PkgLocationLiteral,
-            _1.TokenKind.Eof
+            TokenKind_1.TokenKind.LineNumLiteral,
+            TokenKind_1.TokenKind.SourceFilePathLiteral,
+            TokenKind_1.TokenKind.SourceLineNumLiteral,
+            TokenKind_1.TokenKind.FunctionNameLiteral,
+            TokenKind_1.TokenKind.SourceFunctionNameLiteral,
+            TokenKind_1.TokenKind.SourceLocationLiteral,
+            TokenKind_1.TokenKind.PkgPathLiteral,
+            TokenKind_1.TokenKind.PkgLocationLiteral,
+            TokenKind_1.TokenKind.Eof
         ]);
     });
     it('properly tracks leadingWhitespace', () => {
@@ -1089,12 +1097,12 @@ describe('lexer', () => {
     it('properly detects try/catch tokens', () => {
         const { tokens } = Lexer_1.Lexer.scan(`try catch endtry end try throw`, { includeWhitespace: false });
         (0, chai_1.expect)(tokens.map(x => x.kind)).to.eql([
-            _1.TokenKind.Try,
-            _1.TokenKind.Catch,
-            _1.TokenKind.EndTry,
-            _1.TokenKind.EndTry,
-            _1.TokenKind.Throw,
-            _1.TokenKind.Eof
+            TokenKind_1.TokenKind.Try,
+            TokenKind_1.TokenKind.Catch,
+            TokenKind_1.TokenKind.EndTry,
+            TokenKind_1.TokenKind.EndTry,
+            TokenKind_1.TokenKind.Throw,
+            TokenKind_1.TokenKind.Eof
         ]);
     });
     describe('regular expression literals', () => {
@@ -1119,29 +1127,29 @@ describe('lexer', () => {
                 includeWhitespace: false
             });
             (0, chai_1.expect)(tokens.map(x => x.kind)).to.eql([
-                _1.TokenKind.Identifier,
-                _1.TokenKind.Equal,
-                _1.TokenKind.IntegerLiteral,
-                _1.TokenKind.Forwardslash,
-                _1.TokenKind.IntegerLiteral,
-                _1.TokenKind.Plus,
-                _1.TokenKind.IntegerLiteral,
-                _1.TokenKind.Forwardslash,
-                _1.TokenKind.IntegerLiteral,
-                _1.TokenKind.Plus,
-                _1.TokenKind.IntegerLiteral,
-                _1.TokenKind.Forwardslash,
-                _1.TokenKind.IntegerLiteral,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.Equal,
+                TokenKind_1.TokenKind.IntegerLiteral,
+                TokenKind_1.TokenKind.Forwardslash,
+                TokenKind_1.TokenKind.IntegerLiteral,
+                TokenKind_1.TokenKind.Plus,
+                TokenKind_1.TokenKind.IntegerLiteral,
+                TokenKind_1.TokenKind.Forwardslash,
+                TokenKind_1.TokenKind.IntegerLiteral,
+                TokenKind_1.TokenKind.Plus,
+                TokenKind_1.TokenKind.IntegerLiteral,
+                TokenKind_1.TokenKind.Forwardslash,
+                TokenKind_1.TokenKind.IntegerLiteral,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('only captures alphanumeric flags', () => {
             (0, chai_1.expect)(Lexer_1.Lexer.scan('speak(/a/)').tokens.map(x => x.kind)).to.eql([
-                _1.TokenKind.Identifier,
-                _1.TokenKind.LeftParen,
-                _1.TokenKind.RegexLiteral,
-                _1.TokenKind.RightParen,
-                _1.TokenKind.Eof
+                TokenKind_1.TokenKind.Identifier,
+                TokenKind_1.TokenKind.LeftParen,
+                TokenKind_1.TokenKind.RegexLiteral,
+                TokenKind_1.TokenKind.RightParen,
+                TokenKind_1.TokenKind.Eof
             ]);
         });
         it('handles escape characters properly', () => {