@auscope/angular2parse 4.0.1 → 17.0.0

package/{esm2020 → esm2022}/lib/angular/compiler/chars.mjs

@@ -1,78 +1,78 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-export const $EOF = 0;
-export const $TAB = 9;
-export const $LF = 10;
-export const $VTAB = 11;
-export const $FF = 12;
-export const $CR = 13;
-export const $SPACE = 32;
-export const $BANG = 33;
-export const $DQ = 34;
-export const $HASH = 35;
-export const $$ = 36;
-export const $PERCENT = 37;
-export const $AMPERSAND = 38;
-export const $SQ = 39;
-export const $LPAREN = 40;
-export const $RPAREN = 41;
-export const $STAR = 42;
-export const $PLUS = 43;
-export const $COMMA = 44;
-export const $MINUS = 45;
-export const $PERIOD = 46;
-export const $SLASH = 47;
-export const $COLON = 58;
-export const $SEMICOLON = 59;
-export const $LT = 60;
-export const $EQ = 61;
-export const $GT = 62;
-export const $QUESTION = 63;
-export const $0 = 48;
-export const $9 = 57;
-export const $A = 65;
-export const $E = 69;
-export const $F = 70;
-export const $X = 88;
-export const $Z = 90;
-export const $LBRACKET = 91;
-export const $BACKSLASH = 92;
-export const $RBRACKET = 93;
-export const $CARET = 94;
-export const $_ = 95;
-export const $a = 97;
-export const $e = 101;
-export const $f = 102;
-export const $n = 110;
-export const $r = 114;
-export const $t = 116;
-export const $u = 117;
-export const $v = 118;
-export const $x = 120;
-export const $z = 122;
-export const $LBRACE = 123;
-export const $BAR = 124;
-export const $RBRACE = 125;
-export const $NBSP = 160;
-export const $PIPE = 124;
-export const $TILDA = 126;
-export const $AT = 64;
-export const $BT = 96;
-export function isWhitespace(code) {
-    return (code >= $TAB && code <= $SPACE) || (code == $NBSP);
-}
-export function isDigit(code) {
-    return $0 <= code && code <= $9;
-}
-export function isAsciiLetter(code) {
-    return code >= $a && code <= $z || code >= $A && code <= $Z;
-}
-export function isAsciiHexDigit(code) {
-    return code >= $a && code <= $f || code >= $A && code <= $F || isDigit(code);
-}
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export const $EOF = 0;
+export const $TAB = 9;
+export const $LF = 10;
+export const $VTAB = 11;
+export const $FF = 12;
+export const $CR = 13;
+export const $SPACE = 32;
+export const $BANG = 33;
+export const $DQ = 34;
+export const $HASH = 35;
+export const $$ = 36;
+export const $PERCENT = 37;
+export const $AMPERSAND = 38;
+export const $SQ = 39;
+export const $LPAREN = 40;
+export const $RPAREN = 41;
+export const $STAR = 42;
+export const $PLUS = 43;
+export const $COMMA = 44;
+export const $MINUS = 45;
+export const $PERIOD = 46;
+export const $SLASH = 47;
+export const $COLON = 58;
+export const $SEMICOLON = 59;
+export const $LT = 60;
+export const $EQ = 61;
+export const $GT = 62;
+export const $QUESTION = 63;
+export const $0 = 48;
+export const $9 = 57;
+export const $A = 65;
+export const $E = 69;
+export const $F = 70;
+export const $X = 88;
+export const $Z = 90;
+export const $LBRACKET = 91;
+export const $BACKSLASH = 92;
+export const $RBRACKET = 93;
+export const $CARET = 94;
+export const $_ = 95;
+export const $a = 97;
+export const $e = 101;
+export const $f = 102;
+export const $n = 110;
+export const $r = 114;
+export const $t = 116;
+export const $u = 117;
+export const $v = 118;
+export const $x = 120;
+export const $z = 122;
+export const $LBRACE = 123;
+export const $BAR = 124;
+export const $RBRACE = 125;
+export const $NBSP = 160;
+export const $PIPE = 124;
+export const $TILDA = 126;
+export const $AT = 64;
+export const $BT = 96;
+export function isWhitespace(code) {
+    return (code >= $TAB && code <= $SPACE) || (code == $NBSP);
+}
+export function isDigit(code) {
+    return $0 <= code && code <= $9;
+}
+export function isAsciiLetter(code) {
+    return code >= $a && code <= $z || code >= $A && code <= $Z;
+}
+export function isAsciiHexDigit(code) {
+    return code >= $a && code <= $f || code >= $A && code <= $F || isDigit(code);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/compiler/interpolation-config.mjs

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { assertInterpolationSymbols } from './assertions';
+export class InterpolationConfig {
+    static fromArray(markers) {
+        if (!markers) {
+            return DEFAULT_INTERPOLATION_CONFIG;
+        }
+        assertInterpolationSymbols('interpolation', markers);
+        return new InterpolationConfig(markers[0], markers[1]);
+    }
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+    }
+    ;
+}
+export const DEFAULT_INTERPOLATION_CONFIG = new InterpolationConfig('{{', '}}');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJwb2xhdGlvbi1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyMnBhcnNlL3NyYy9saWIvYW5ndWxhci9jb21waWxlci9pbnRlcnBvbGF0aW9uLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsMEJBQTBCLEVBQUMsTUFBTSxjQUFjLENBQUM7QUFFeEQsTUFBTSxPQUFPLG1CQUFtQjtJQUM1QixNQUFNLENBQUMsU0FBUyxDQUFDLE9BQXlCO1FBQ3RDLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNYLE9BQU8sNEJBQTRCLENBQUM7UUFDeEMsQ0FBQztRQUVELDBCQUEwQixDQUFDLGVBQWUsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUNyRCxPQUFPLElBQUksbUJBQW1CLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzNELENBQUM7SUFFRCxZQUFtQixLQUFhLEVBQVMsR0FBVztRQUFqQyxVQUFLLEdBQUwsS0FBSyxDQUFRO1FBQVMsUUFBRyxHQUFILEdBQUcsQ0FBUTtJQUFFLENBQUM7SUFBQSxDQUFDO0NBQzNEO0FBRUQsTUFBTSxDQUFDLE1BQU0sNEJBQTRCLEdBQ3JDLElBQUksbUJBQW1CLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge2Fzc2VydEludGVycG9sYXRpb25TeW1ib2xzfSBmcm9tICcuL2Fzc2VydGlvbnMnO1xuXG5leHBvcnQgY2xhc3MgSW50ZXJwb2xhdGlvbkNvbmZpZyB7XG4gICAgc3RhdGljIGZyb21BcnJheShtYXJrZXJzOiBbc3RyaW5nLCBzdHJpbmddKTogSW50ZXJwb2xhdGlvbkNvbmZpZyB7XG4gICAgICAgIGlmICghbWFya2Vycykge1xuICAgICAgICAgICAgcmV0dXJuIERFRkFVTFRfSU5URVJQT0xBVElPTl9DT05GSUc7XG4gICAgICAgIH1cblxuICAgICAgICBhc3NlcnRJbnRlcnBvbGF0aW9uU3ltYm9scygnaW50ZXJwb2xhdGlvbicsIG1hcmtlcnMpO1xuICAgICAgICByZXR1cm4gbmV3IEludGVycG9sYXRpb25Db25maWcobWFya2Vyc1swXSwgbWFya2Vyc1sxXSk7XG4gICAgfVxuXG4gICAgY29uc3RydWN0b3IocHVibGljIHN0YXJ0OiBzdHJpbmcsIHB1YmxpYyBlbmQ6IHN0cmluZyl7fTtcbn1cblxuZXhwb3J0IGNvbnN0IERFRkFVTFRfSU5URVJQT0xBVElPTl9DT05GSUc6IEludGVycG9sYXRpb25Db25maWcgPVxuICAgIG5ldyBJbnRlcnBvbGF0aW9uQ29uZmlnKCd7eycsICd9fScpOyJdfQ==

package/esm2022/lib/angular/compiler/lexer.mjs

@@ -0,0 +1,344 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as chars from './chars';
+import { NumberWrapper } from '../facade/lang';
+export var TokenType;
+(function (TokenType) {
+    TokenType[TokenType["Character"] = 0] = "Character";
+    TokenType[TokenType["Identifier"] = 1] = "Identifier";
+    TokenType[TokenType["Keyword"] = 2] = "Keyword";
+    TokenType[TokenType["String"] = 3] = "String";
+    TokenType[TokenType["Operator"] = 4] = "Operator";
+    TokenType[TokenType["Number"] = 5] = "Number";
+    TokenType[TokenType["Error"] = 6] = "Error";
+})(TokenType || (TokenType = {}));
+const KEYWORDS = ['var', 'let', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this'];
+export class Lexer {
+    tokenize(text) {
+        const scanner = new _Scanner(text);
+        const tokens = [];
+        let token = scanner.scanToken();
+        while (token != null) {
+            tokens.push(token);
+            token = scanner.scanToken();
+        }
+        return tokens;
+    }
+}
+export class Token {
+    constructor(index, type, numValue, strValue) {
+        this.index = index;
+        this.type = type;
+        this.numValue = numValue;
+        this.strValue = strValue;
+    }
+    isCharacter(code) {
+        return this.type == TokenType.Character && this.numValue == code;
+    }
+    isNumber() { return this.type == TokenType.Number; }
+    isString() { return this.type == TokenType.String; }
+    isOperator(operater) {
+        return this.type == TokenType.Operator && this.strValue == operater;
+    }
+    isIdentifier() { return this.type == TokenType.Identifier; }
+    isKeyword() { return this.type == TokenType.Keyword; }
+    isKeywordLet() { return this.type == TokenType.Keyword && this.strValue == 'let'; }
+    isKeywordNull() { return this.type == TokenType.Keyword && this.strValue == 'null'; }
+    isKeywordUndefined() {
+        return this.type == TokenType.Keyword && this.strValue == 'undefined';
+    }
+    isKeywordTrue() { return this.type == TokenType.Keyword && this.strValue == 'true'; }
+    isKeywordFalse() { return this.type == TokenType.Keyword && this.strValue == 'false'; }
+    isKeywordThis() { return this.type == TokenType.Keyword && this.strValue == 'this'; }
+    isError() { return this.type == TokenType.Error; }
+    toNumber() { return this.type == TokenType.Number ? this.numValue : -1; }
+    toString() {
+        switch (this.type) {
+            case TokenType.Character:
+            case TokenType.Identifier:
+            case TokenType.Keyword:
+            case TokenType.Operator:
+            case TokenType.String:
+            case TokenType.Error:
+                return this.strValue;
+            case TokenType.Number:
+                return this.numValue.toString();
+            default:
+                return null;
+        }
+    }
+}
+function newCharacterToken(index, code) {
+    return new Token(index, TokenType.Character, code, String.fromCharCode(code));
+}
+function newIdentifierToken(index, text) {
+    return new Token(index, TokenType.Identifier, 0, text);
+}
+function newKeywordToken(index, text) {
+    return new Token(index, TokenType.Keyword, 0, text);
+}
+function newOperatorToken(index, text) {
+    return new Token(index, TokenType.Operator, 0, text);
+}
+function newStringToken(index, text) {
+    return new Token(index, TokenType.String, 0, text);
+}
+function newNumberToken(index, n) {
+    return new Token(index, TokenType.Number, n, '');
+}
+function newErrorToken(index, message) {
+    return new Token(index, TokenType.Error, 0, message);
+}
+export const EOF = new Token(-1, TokenType.Character, 0, '');
+class _Scanner {
+    constructor(input) {
+        this.input = input;
+        this.peek = 0;
+        this.index = -1;
+        this.length = input.length;
+        this.advance();
+    }
+    advance() {
+        this.peek = ++this.index >= this.length ? chars.$EOF : this.input.charCodeAt(this.index);
+    }
+    scanToken() {
+        const input = this.input, length = this.length;
+        let peek = this.peek, index = this.index;
+        // Skip whitespace.
+        while (peek <= chars.$SPACE) {
+            if (++index >= length) {
+                peek = chars.$EOF;
+                break;
+            }
+            else {
+                peek = input.charCodeAt(index);
+            }
+        }
+        this.peek = peek;
+        this.index = index;
+        if (index >= length) {
+            return null;
+        }
+        // Handle identifiers and numbers.
+        if (isIdentifierStart(peek))
+            return this.scanIdentifier();
+        if (chars.isDigit(peek))
+            return this.scanNumber(index);
+        const start = index;
+        switch (peek) {
+            case chars.$PERIOD:
+                this.advance();
+                return chars.isDigit(this.peek) ? this.scanNumber(start) :
+                    newCharacterToken(start, chars.$PERIOD);
+            case chars.$LPAREN:
+            case chars.$RPAREN:
+            case chars.$LBRACE:
+            case chars.$RBRACE:
+            case chars.$LBRACKET:
+            case chars.$RBRACKET:
+            case chars.$COMMA:
+            case chars.$COLON:
+            case chars.$SEMICOLON:
+                return this.scanCharacter(start, peek);
+            case chars.$SQ:
+            case chars.$DQ:
+                return this.scanString();
+            case chars.$HASH:
+            case chars.$PLUS:
+            case chars.$MINUS:
+            case chars.$STAR:
+            case chars.$SLASH:
+            case chars.$PERCENT:
+            case chars.$CARET:
+                return this.scanOperator(start, String.fromCharCode(peek));
+            case chars.$QUESTION:
+                return this.scanComplexOperator(start, '?', chars.$PERIOD, '.');
+            case chars.$LT:
+            case chars.$GT:
+                return this.scanComplexOperator(start, String.fromCharCode(peek), chars.$EQ, '=');
+            case chars.$BANG:
+            case chars.$EQ:
+                return this.scanComplexOperator(start, String.fromCharCode(peek), chars.$EQ, '=', chars.$EQ, '=');
+            case chars.$AMPERSAND:
+                return this.scanComplexOperator(start, '&', chars.$AMPERSAND, '&');
+            case chars.$BAR:
+                return this.scanComplexOperator(start, '|', chars.$BAR, '|');
+            case chars.$NBSP:
+                while (chars.isWhitespace(this.peek))
+                    this.advance();
+                return this.scanToken();
+        }
+        this.advance();
+        return this.error(`Unexpected character [${String.fromCharCode(peek)}]`, 0);
+    }
+    scanCharacter(start, code) {
+        this.advance();
+        return newCharacterToken(start, code);
+    }
+    scanOperator(start, str) {
+        this.advance();
+        return newOperatorToken(start, str);
+    }
+    /**
+     * Tokenize a 2/3 char long operator
+     *
+     * @param start start index in the expression
+     * @param one first symbol (always part of the operator)
+     * @param twoCode code point for the second symbol
+     * @param two second symbol (part of the operator when the second code point matches)
+     * @param threeCode code point for the third symbol
+     * @param three third symbol (part of the operator when provided and matches source expression)
+     * @returns {Token}
+     */
+    scanComplexOperator(start, one, twoCode, two, threeCode, three) {
+        this.advance();
+        let str = one;
+        if (this.peek == twoCode) {
+            this.advance();
+            str += two;
+        }
+        if (threeCode != null && this.peek == threeCode) {
+            this.advance();
+            str += three;
+        }
+        return newOperatorToken(start, str);
+    }
+    scanIdentifier() {
+        const start = this.index;
+        this.advance();
+        while (isIdentifierPart(this.peek))
+            this.advance();
+        const str = this.input.substring(start, this.index);
+        return KEYWORDS.indexOf(str) > -1 ? newKeywordToken(start, str) :
+            newIdentifierToken(start, str);
+    }
+    scanNumber(start) {
+        let simple = (this.index === start);
+        this.advance(); // Skip initial digit.
+        while (true) {
+            if (chars.isDigit(this.peek)) {
+                // Do nothing.
+            }
+            else if (this.peek == chars.$PERIOD) {
+                simple = false;
+            }
+            else if (isExponentStart(this.peek)) {
+                this.advance();
+                if (isExponentSign(this.peek))
+                    this.advance();
+                if (!chars.isDigit(this.peek))
+                    return this.error('Invalid exponent', -1);
+                simple = false;
+            }
+            else {
+                break;
+            }
+            this.advance();
+        }
+        const str = this.input.substring(start, this.index);
+        const value = simple ? NumberWrapper.parseIntAutoRadix(str) : parseFloat(str);
+        return newNumberToken(start, value);
+    }
+    scanString() {
+        const start = this.index;
+        const quote = this.peek;
+        this.advance(); // Skip initial quote.
+        let buffer = '';
+        let marker = this.index;
+        const input = this.input;
+        while (this.peek != quote) {
+            if (this.peek == chars.$BACKSLASH) {
+                buffer += input.substring(marker, this.index);
+                this.advance();
+                let unescapedCode;
+                // Workaround for TS2.1-introduced type strictness
+                this.peek = this.peek;
+                if (this.peek == chars.$u) {
+                    // 4 character hex code for unicode character.
+                    const hex = input.substring(this.index + 1, this.index + 5);
+                    if (/^[0-9a-f]+$/i.test(hex)) {
+                        unescapedCode = parseInt(hex, 16);
+                    }
+                    else {
+                        return this.error(`Invalid unicode escape [\\u${hex}]`, 0);
+                    }
+                    for (let i = 0; i < 5; i++) {
+                        this.advance();
+                    }
+                }
+                else {
+                    unescapedCode = unescape(this.peek);
+                    this.advance();
+                }
+                buffer += String.fromCharCode(unescapedCode);
+                marker = this.index;
+            }
+            else if (this.peek == chars.$EOF) {
+                return this.error('Unterminated quote', 0);
+            }
+            else {
+                this.advance();
+            }
+        }
+        const last = input.substring(marker, this.index);
+        this.advance(); // Skip terminating quote.
+        return newStringToken(start, buffer + last);
+    }
+    error(message, offset) {
+        const position = this.index + offset;
+        return newErrorToken(position, `Lexer Error: ${message} at column ${position} in expression [${this.input}]`);
+    }
+}
+function isIdentifierStart(code) {
+    return (chars.$a <= code && code <= chars.$z) || (chars.$A <= code && code <= chars.$Z) ||
+        (code == chars.$_) || (code == chars.$$);
+}
+export function isIdentifier(input) {
+    if (input.length == 0)
+        return false;
+    const scanner = new _Scanner(input);
+    if (!isIdentifierStart(scanner.peek))
+        return false;
+    scanner.advance();
+    while (scanner.peek !== chars.$EOF) {
+        if (!isIdentifierPart(scanner.peek))
+            return false;
+        scanner.advance();
+    }
+    return true;
+}
+function isIdentifierPart(code) {
+    return chars.isAsciiLetter(code) || chars.isDigit(code) || (code == chars.$_) ||
+        (code == chars.$$);
+}
+function isExponentStart(code) {
+    return code == chars.$e || code == chars.$E;
+}
+function isExponentSign(code) {
+    return code == chars.$MINUS || code == chars.$PLUS;
+}
+export function isQuote(code) {
+    return code === chars.$SQ || code === chars.$DQ || code === chars.$BT;
+}
+function unescape(code) {
+    switch (code) {
+        case chars.$n:
+            return chars.$LF;
+        case chars.$f:
+            return chars.$FF;
+        case chars.$r:
+            return chars.$CR;
+        case chars.$t:
+            return chars.$TAB;
+        case chars.$v:
+            return chars.$VTAB;
+        default:
+            return code;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lexer.js","sourceRoot":"","sources":["../../../../../../projects/angular2parse/src/lib/angular/compiler/lexer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as chars from './chars';\nimport {NumberWrapper} from '../facade/lang';\n\nexport enum TokenType {\n    Character,\n    Identifier,\n    Keyword,\n    String,\n    Operator,\n    Number,\n    Error\n}\n\nconst KEYWORDS = ['var', 'let', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this'];\n\nexport class Lexer {\n    tokenize(text: string): Token[] {\n        const scanner = new _Scanner(text);\n        const tokens: Token[] = [];\n        let token = scanner.scanToken();\n        while (token != null) {\n            tokens.push(token);\n            token = scanner.scanToken();\n        }\n        return tokens;\n    }\n}\n\nexport class Token {\n    constructor(\n        public index: number, public type: TokenType, public numValue: number,\n        public strValue: string) {}\n\n    isCharacter(code: number): boolean {\n        return this.type == TokenType.Character && this.numValue == code;\n    }\n\n    isNumber(): boolean { return this.type == TokenType.Number; }\n\n    isString(): boolean { return this.type == TokenType.String; }\n\n    isOperator(operater: string): boolean {\n        return this.type == TokenType.Operator && this.strValue == operater;\n    }\n\n    isIdentifier(): boolean { return this.type == TokenType.Identifier; }\n\n    isKeyword(): boolean { return this.type == TokenType.Keyword; }\n\n    isKeywordLet(): boolean { return this.type == TokenType.Keyword && this.strValue == 'let'; }\n\n    isKeywordNull(): boolean { return this.type == TokenType.Keyword && this.strValue == 'null'; }\n\n    isKeywordUndefined(): boolean {\n        return this.type == TokenType.Keyword && this.strValue == 'undefined';\n    }\n\n    isKeywordTrue(): boolean { return this.type == TokenType.Keyword && this.strValue == 'true'; }\n\n    isKeywordFalse(): boolean { return this.type == TokenType.Keyword && this.strValue == 'false'; }\n\n    isKeywordThis(): boolean { return this.type == TokenType.Keyword && this.strValue == 'this'; }\n\n    isError(): boolean { return this.type == TokenType.Error; }\n\n    toNumber(): number { return this.type == TokenType.Number ? this.numValue : -1; }\n\n    toString(): string {\n        switch (this.type) {\n            case TokenType.Character:\n            case TokenType.Identifier:\n            case TokenType.Keyword:\n            case TokenType.Operator:\n            case TokenType.String:\n            case TokenType.Error:\n                return this.strValue;\n            case TokenType.Number:\n                return this.numValue.toString();\n            default:\n                return null;\n        }\n    }\n}\n\nfunction newCharacterToken(index: number, code: number): Token {\n    return new Token(index, TokenType.Character, code, String.fromCharCode(code));\n}\n\nfunction newIdentifierToken(index: number, text: string): Token {\n    return new Token(index, TokenType.Identifier, 0, text);\n}\n\nfunction newKeywordToken(index: number, text: string): Token {\n    return new Token(index, TokenType.Keyword, 0, text);\n}\n\nfunction newOperatorToken(index: number, text: string): Token {\n    return new Token(index, TokenType.Operator, 0, text);\n}\n\nfunction newStringToken(index: number, text: string): Token {\n    return new Token(index, TokenType.String, 0, text);\n}\n\nfunction newNumberToken(index: number, n: number): Token {\n    return new Token(index, TokenType.Number, n, '');\n}\n\nfunction newErrorToken(index: number, message: string): Token {\n    return new Token(index, TokenType.Error, 0, message);\n}\n\nexport const EOF: Token = new Token(-1, TokenType.Character, 0, '');\n\nclass _Scanner {\n    length: number;\n    peek: number = 0;\n    index: number = -1;\n\n    constructor(public input: string) {\n        this.length = input.length;\n        this.advance();\n    }\n\n    advance() {\n        this.peek = ++this.index >= this.length ? chars.$EOF : this.input.charCodeAt(this.index);\n    }\n\n    scanToken(): Token {\n        const input = this.input, length = this.length;\n        let peek = this.peek, index = this.index;\n\n        // Skip whitespace.\n        while (peek <= chars.$SPACE) {\n            if (++index >= length) {\n                peek = chars.$EOF;\n                break;\n            } else {\n                peek = input.charCodeAt(index);\n            }\n        }\n\n        this.peek = peek;\n        this.index = index;\n\n        if (index >= length) {\n            return null;\n        }\n\n        // Handle identifiers and numbers.\n        if (isIdentifierStart(peek)) return this.scanIdentifier();\n        if (chars.isDigit(peek)) return this.scanNumber(index);\n\n        const start: number = index;\n        switch (peek) {\n            case chars.$PERIOD:\n                this.advance();\n                return chars.isDigit(this.peek) ? this.scanNumber(start) :\n                    newCharacterToken(start, chars.$PERIOD);\n            case chars.$LPAREN:\n            case chars.$RPAREN:\n            case chars.$LBRACE:\n            case chars.$RBRACE:\n            case chars.$LBRACKET:\n            case chars.$RBRACKET:\n            case chars.$COMMA:\n            case chars.$COLON:\n            case chars.$SEMICOLON:\n                return this.scanCharacter(start, peek);\n            case chars.$SQ:\n            case chars.$DQ:\n                return this.scanString();\n            case chars.$HASH:\n            case chars.$PLUS:\n            case chars.$MINUS:\n            case chars.$STAR:\n            case chars.$SLASH:\n            case chars.$PERCENT:\n            case chars.$CARET:\n                return this.scanOperator(start, String.fromCharCode(peek));\n            case chars.$QUESTION:\n                return this.scanComplexOperator(start, '?', chars.$PERIOD, '.');\n            case chars.$LT:\n            case chars.$GT:\n                return this.scanComplexOperator(start, String.fromCharCode(peek), chars.$EQ, '=');\n            case chars.$BANG:\n            case chars.$EQ:\n                return this.scanComplexOperator(\n                    start, String.fromCharCode(peek), chars.$EQ, '=', chars.$EQ, '=');\n            case chars.$AMPERSAND:\n                return this.scanComplexOperator(start, '&', chars.$AMPERSAND, '&');\n            case chars.$BAR:\n                return this.scanComplexOperator(start, '|', chars.$BAR, '|');\n            case chars.$NBSP:\n                while (chars.isWhitespace(this.peek)) this.advance();\n                return this.scanToken();\n        }\n\n        this.advance();\n        return this.error(`Unexpected character [${String.fromCharCode(peek)}]`, 0);\n    }\n\n    scanCharacter(start: number, code: number): Token {\n        this.advance();\n        return newCharacterToken(start, code);\n    }\n\n\n    scanOperator(start: number, str: string): Token {\n        this.advance();\n        return newOperatorToken(start, str);\n    }\n\n    /**\n     * Tokenize a 2/3 char long operator\n     *\n     * @param start start index in the expression\n     * @param one first symbol (always part of the operator)\n     * @param twoCode code point for the second symbol\n     * @param two second symbol (part of the operator when the second code point matches)\n     * @param threeCode code point for the third symbol\n     * @param three third symbol (part of the operator when provided and matches source expression)\n     * @returns {Token}\n     */\n    scanComplexOperator(\n        start: number, one: string, twoCode: number, two: string, threeCode?: number,\n        three?: string): Token {\n        this.advance();\n        let str: string = one;\n        if (this.peek == twoCode) {\n            this.advance();\n            str += two;\n        }\n        if (threeCode != null && this.peek == threeCode) {\n            this.advance();\n            str += three;\n        }\n        return newOperatorToken(start, str);\n    }\n\n    scanIdentifier(): Token {\n        const start: number = this.index;\n        this.advance();\n        while (isIdentifierPart(this.peek)) this.advance();\n        const str: string = this.input.substring(start, this.index);\n        return KEYWORDS.indexOf(str) > -1 ? newKeywordToken(start, str) :\n            newIdentifierToken(start, str);\n    }\n\n    scanNumber(start: number): Token {\n        let simple: boolean = (this.index === start);\n        this.advance();  // Skip initial digit.\n        while (true) {\n            if (chars.isDigit(this.peek)) {\n                // Do nothing.\n            } else if (this.peek == chars.$PERIOD) {\n                simple = false;\n            } else if (isExponentStart(this.peek)) {\n                this.advance();\n                if (isExponentSign(this.peek)) this.advance();\n                if (!chars.isDigit(this.peek)) return this.error('Invalid exponent', -1);\n                simple = false;\n            } else {\n                break;\n            }\n            this.advance();\n        }\n        const str: string = this.input.substring(start, this.index);\n        const value: number = simple ? NumberWrapper.parseIntAutoRadix(str) : parseFloat(str);\n        return newNumberToken(start, value);\n    }\n\n    scanString(): Token {\n        const start: number = this.index;\n        const quote: number = this.peek;\n        this.advance();  // Skip initial quote.\n\n        let buffer: string = '';\n        let marker: number = this.index;\n        const input: string = this.input;\n\n        while (this.peek != quote) {\n            if (this.peek == chars.$BACKSLASH) {\n                buffer += input.substring(marker, this.index);\n                this.advance();\n                let unescapedCode: number;\n                // Workaround for TS2.1-introduced type strictness\n                this.peek = this.peek;\n                if (this.peek == chars.$u) {\n                    // 4 character hex code for unicode character.\n                    const hex: string = input.substring(this.index + 1, this.index + 5);\n                    if (/^[0-9a-f]+$/i.test(hex)) {\n                        unescapedCode = parseInt(hex, 16);\n                    } else {\n                        return this.error(`Invalid unicode escape [\\\\u${hex}]`, 0);\n                    }\n                    for (let i: number = 0; i < 5; i++) {\n                        this.advance();\n                    }\n                } else {\n                    unescapedCode = unescape(this.peek);\n                    this.advance();\n                }\n                buffer += String.fromCharCode(unescapedCode);\n                marker = this.index;\n            } else if (this.peek == chars.$EOF) {\n                return this.error('Unterminated quote', 0);\n            } else {\n                this.advance();\n            }\n        }\n\n        const last: string = input.substring(marker, this.index);\n        this.advance();  // Skip terminating quote.\n\n        return newStringToken(start, buffer + last);\n    }\n\n    error(message: string, offset: number): Token {\n        const position: number = this.index + offset;\n        return newErrorToken(\n            position, `Lexer Error: ${message} at column ${position} in expression [${this.input}]`);\n    }\n}\n\nfunction isIdentifierStart(code: number): boolean {\n    return (chars.$a <= code && code <= chars.$z) || (chars.$A <= code && code <= chars.$Z) ||\n        (code == chars.$_) || (code == chars.$$);\n}\n\nexport function isIdentifier(input: string): boolean {\n    if (input.length == 0) return false;\n    const scanner = new _Scanner(input);\n    if (!isIdentifierStart(scanner.peek)) return false;\n    scanner.advance();\n    while (scanner.peek !== chars.$EOF) {\n        if (!isIdentifierPart(scanner.peek)) return false;\n        scanner.advance();\n    }\n    return true;\n}\n\nfunction isIdentifierPart(code: number): boolean {\n    return chars.isAsciiLetter(code) || chars.isDigit(code) || (code == chars.$_) ||\n        (code == chars.$$);\n}\n\nfunction isExponentStart(code: number): boolean {\n    return code == chars.$e || code == chars.$E;\n}\n\nfunction isExponentSign(code: number): boolean {\n    return code == chars.$MINUS || code == chars.$PLUS;\n}\n\nexport function isQuote(code: number): boolean {\n    return code === chars.$SQ || code === chars.$DQ || code === chars.$BT;\n}\n\nfunction unescape(code: number): number {\n    switch (code) {\n        case chars.$n:\n            return chars.$LF;\n        case chars.$f:\n            return chars.$FF;\n        case chars.$r:\n            return chars.$CR;\n        case chars.$t:\n            return chars.$TAB;\n        case chars.$v:\n            return chars.$VTAB;\n        default:\n            return code;\n    }\n}"]}