@auscope/angular2parse 2.0.0 → 2.0.1

package/fesm2015/auscope-angular2parse.mjs

@@ -0,0 +1,2035 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Optional, Inject, NgModule } from '@angular/core';
+
+/**
+ * @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
+ */
+function getTypeNameForDebugging(type) {
+    return type['name'] || typeof type;
+}
+function isPresent$1(obj) {
+    return obj != null;
+}
+function isBlank(obj) {
+    return obj == null;
+}
+const STRING_MAP_PROTO = Object.getPrototypeOf({});
+function isStrictStringMap(obj) {
+    return typeof obj === 'object' && obj !== null && Object.getPrototypeOf(obj) === STRING_MAP_PROTO;
+}
+function stringify(token) {
+    if (typeof token === 'string') {
+        return token;
+    }
+    if (token == null) {
+        return '' + token;
+    }
+    if (token.overriddenName) {
+        return `${token.overriddenName}`;
+    }
+    if (token.name) {
+        return `${token.name}`;
+    }
+    const res = token.toString();
+    const newLineIndex = res.indexOf('\n');
+    return newLineIndex === -1 ? res : res.substring(0, newLineIndex);
+}
+class NumberWrapper {
+    static parseIntAutoRadix(text) {
+        const result = parseInt(text);
+        if (isNaN(result)) {
+            throw new Error('Invalid integer literal when parsing ' + text);
+        }
+        return result;
+    }
+    static isNumeric(value) { return !isNaN(value - parseFloat(value)); }
+}
+// JS has NaN !== NaN
+function looseIdentical(a, b) {
+    return a === b || typeof a === 'number' && typeof b === 'number' && isNaN(a) && isNaN(b);
+}
+function isJsObject$1(o) {
+    return o !== null && (typeof o === 'function' || typeof o === 'object');
+}
+function print(obj) {
+    // tslint:disable-next-line:no-console
+    console.log(obj);
+}
+function warn(obj) {
+    console.warn(obj);
+}
+function setValueOnPath(global, path, value) {
+    const parts = path.split('.');
+    let obj = global;
+    while (parts.length > 1) {
+        const name = parts.shift();
+        if (obj.hasOwnProperty(name) && obj[name] != null) {
+            obj = obj[name];
+        }
+        else {
+            obj = obj[name] = {};
+        }
+    }
+    if (obj === undefined || obj === null) {
+        obj = {};
+    }
+    obj[parts.shift()] = value;
+}
+function isPrimitive(obj) {
+    return !isJsObject$1(obj);
+}
+function escapeRegExp(s) {
+    return s.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
+}
+
+/**
+ * @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
+ */
+const isDevMode = () => false;
+function assertArrayOfStrings(identifier, value) {
+    if (!isDevMode() || isBlank(value)) {
+        return;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`Expected '${identifier}' to be an array of strings.`);
+    }
+    for (let i = 0; i < value.length; i += 1) {
+        if (typeof value[i] !== 'string') {
+            throw new Error(`Expected '${identifier}' to be an array of strings.`);
+        }
+    }
+}
+const INTERPOLATION_BLACKLIST_REGEXPS = [
+    /^\s*$/,
+    /[<>]/,
+    /^[{}]$/,
+    /&(#|[a-z])/i,
+    /^\/\//, // comment
+];
+function assertInterpolationSymbols(identifier, value) {
+    if (isPresent$1(value) && !(Array.isArray(value) && value.length == 2)) {
+        throw new Error(`Expected '${identifier}' to be an array, [start, end].`);
+    }
+    else if (isDevMode() && !isBlank(value)) {
+        const start = value[0];
+        const end = value[1];
+        // black list checking
+        INTERPOLATION_BLACKLIST_REGEXPS.forEach(regexp => {
+            if (regexp.test(start) || regexp.test(end)) {
+                throw new Error(`['${start}', '${end}'] contains unusable interpolation symbol.`);
+            }
+        });
+    }
+}
+
+/**
+ * @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
+ */
+class ParserError {
+    constructor(message, input, errLocation, ctxLocation) {
+        this.input = input;
+        this.errLocation = errLocation;
+        this.ctxLocation = ctxLocation;
+        this.message = `Parser Error: ${message} ${errLocation} [${input}] in ${ctxLocation}`;
+    }
+}
+class ParseSpan {
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+    }
+}
+class AST {
+    constructor(span) {
+        this.span = span;
+    }
+    visit(visitor, context = null) { return null; }
+    toString() { return 'AST'; }
+}
+/**
+ * Represents a quoted expression of the form:
+ *
+ * quote = prefix `:` uninterpretedExpression
+ * prefix = identifier
+ * uninterpretedExpression = arbitrary string
+ *
+ * A quoted expression is meant to be pre-processed by an AST transformer that
+ * converts it into another AST that no longer contains quoted expressions.
+ * It is meant to allow third-party developers to extend Angular template
+ * expression language. The `uninterpretedExpression` part of the quote is
+ * therefore not interpreted by the Angular's own expression parser.
+ */
+class Quote extends AST {
+    constructor(span, prefix, uninterpretedExpression, location) {
+        super(span);
+        this.prefix = prefix;
+        this.uninterpretedExpression = uninterpretedExpression;
+        this.location = location;
+    }
+    visit(visitor, context = null) { return visitor.visitQuote(this, context); }
+    toString() { return 'Quote'; }
+}
+class EmptyExpr extends AST {
+    visit(visitor, context = null) {
+        // do nothing
+    }
+}
+class ImplicitReceiver extends AST {
+    visit(visitor, context = null) {
+        return visitor.visitImplicitReceiver(this, context);
+    }
+}
+/**
+ * Multiple expressions separated by a semicolon.
+ */
+class Chain extends AST {
+    constructor(span, expressions) {
+        super(span);
+        this.expressions = expressions;
+    }
+    visit(visitor, context = null) { return visitor.visitChain(this, context); }
+}
+class Conditional extends AST {
+    constructor(span, condition, trueExp, falseExp) {
+        super(span);
+        this.condition = condition;
+        this.trueExp = trueExp;
+        this.falseExp = falseExp;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitConditional(this, context);
+    }
+}
+class PropertyRead extends AST {
+    constructor(span, receiver, name) {
+        super(span);
+        this.receiver = receiver;
+        this.name = name;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitPropertyRead(this, context);
+    }
+}
+class PropertyWrite extends AST {
+    constructor(span, receiver, name, value) {
+        super(span);
+        this.receiver = receiver;
+        this.name = name;
+        this.value = value;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitPropertyWrite(this, context);
+    }
+}
+class SafePropertyRead extends AST {
+    constructor(span, receiver, name) {
+        super(span);
+        this.receiver = receiver;
+        this.name = name;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitSafePropertyRead(this, context);
+    }
+}
+class KeyedRead extends AST {
+    constructor(span, obj, key) {
+        super(span);
+        this.obj = obj;
+        this.key = key;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitKeyedRead(this, context);
+    }
+}
+class KeyedWrite extends AST {
+    constructor(span, obj, key, value) {
+        super(span);
+        this.obj = obj;
+        this.key = key;
+        this.value = value;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitKeyedWrite(this, context);
+    }
+}
+class BindingPipe extends AST {
+    constructor(span, exp, name, args) {
+        super(span);
+        this.exp = exp;
+        this.name = name;
+        this.args = args;
+    }
+    visit(visitor, context = null) { return visitor.visitPipe(this, context); }
+}
+class LiteralPrimitive extends AST {
+    constructor(span, value) {
+        super(span);
+        this.value = value;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitLiteralPrimitive(this, context);
+    }
+}
+class LiteralArray extends AST {
+    constructor(span, expressions) {
+        super(span);
+        this.expressions = expressions;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitLiteralArray(this, context);
+    }
+}
+class LiteralMap extends AST {
+    constructor(span, keys, values) {
+        super(span);
+        this.keys = keys;
+        this.values = values;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitLiteralMap(this, context);
+    }
+}
+class Interpolation extends AST {
+    constructor(span, strings, expressions) {
+        super(span);
+        this.strings = strings;
+        this.expressions = expressions;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitInterpolation(this, context);
+    }
+}
+class Binary extends AST {
+    constructor(span, operation, left, right) {
+        super(span);
+        this.operation = operation;
+        this.left = left;
+        this.right = right;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitBinary(this, context);
+    }
+}
+class PrefixNot extends AST {
+    constructor(span, expression) {
+        super(span);
+        this.expression = expression;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitPrefixNot(this, context);
+    }
+}
+class MethodCall extends AST {
+    constructor(span, receiver, name, args) {
+        super(span);
+        this.receiver = receiver;
+        this.name = name;
+        this.args = args;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitMethodCall(this, context);
+    }
+}
+class SafeMethodCall extends AST {
+    constructor(span, receiver, name, args) {
+        super(span);
+        this.receiver = receiver;
+        this.name = name;
+        this.args = args;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitSafeMethodCall(this, context);
+    }
+}
+class FunctionCall extends AST {
+    constructor(span, target, args) {
+        super(span);
+        this.target = target;
+        this.args = args;
+    }
+    visit(visitor, context = null) {
+        return visitor.visitFunctionCall(this, context);
+    }
+}
+class ASTWithSource extends AST {
+    constructor(ast, source, location, errors) {
+        super(new ParseSpan(0, isBlank(source) ? 0 : source.length));
+        this.ast = ast;
+        this.source = source;
+        this.location = location;
+        this.errors = errors;
+    }
+    visit(visitor, context = null) { return this.ast.visit(visitor, context); }
+    toString() { return `${this.source} in ${this.location}`; }
+}
+class TemplateBinding {
+    constructor(span, key, keyIsVar, name, expression) {
+        this.span = span;
+        this.key = key;
+        this.keyIsVar = keyIsVar;
+        this.name = name;
+        this.expression = expression;
+    }
+}
+class RecursiveAstVisitor {
+    visitBinary(ast, context) {
+        ast.left.visit(this);
+        ast.right.visit(this);
+        return null;
+    }
+    visitChain(ast, context) { return this.visitAll(ast.expressions, context); }
+    visitConditional(ast, context) {
+        ast.condition.visit(this);
+        ast.trueExp.visit(this);
+        ast.falseExp.visit(this);
+        return null;
+    }
+    visitPipe(ast, context) {
+        ast.exp.visit(this);
+        this.visitAll(ast.args, context);
+        return null;
+    }
+    visitFunctionCall(ast, context) {
+        ast.target.visit(this);
+        this.visitAll(ast.args, context);
+        return null;
+    }
+    visitImplicitReceiver(ast, context) { return null; }
+    visitInterpolation(ast, context) {
+        return this.visitAll(ast.expressions, context);
+    }
+    visitKeyedRead(ast, context) {
+        ast.obj.visit(this);
+        ast.key.visit(this);
+        return null;
+    }
+    visitKeyedWrite(ast, context) {
+        ast.obj.visit(this);
+        ast.key.visit(this);
+        ast.value.visit(this);
+        return null;
+    }
+    visitLiteralArray(ast, context) {
+        return this.visitAll(ast.expressions, context);
+    }
+    visitLiteralMap(ast, context) { return this.visitAll(ast.values, context); }
+    visitLiteralPrimitive(ast, context) { return null; }
+    visitMethodCall(ast, context) {
+        ast.receiver.visit(this);
+        return this.visitAll(ast.args, context);
+    }
+    visitPrefixNot(ast, context) {
+        ast.expression.visit(this);
+        return null;
+    }
+    visitPropertyRead(ast, context) {
+        ast.receiver.visit(this);
+        return null;
+    }
+    visitPropertyWrite(ast, context) {
+        ast.receiver.visit(this);
+        ast.value.visit(this);
+        return null;
+    }
+    visitSafePropertyRead(ast, context) {
+        ast.receiver.visit(this);
+        return null;
+    }
+    visitSafeMethodCall(ast, context) {
+        ast.receiver.visit(this);
+        return this.visitAll(ast.args, context);
+    }
+    visitAll(asts, context) {
+        asts.forEach(ast => ast.visit(this, context));
+        return null;
+    }
+    visitQuote(ast, context) { return null; }
+}
+class AstTransformer {
+    visitImplicitReceiver(ast, context) { return ast; }
+    visitInterpolation(ast, context) {
+        return new Interpolation(ast.span, ast.strings, this.visitAll(ast.expressions));
+    }
+    visitLiteralPrimitive(ast, context) {
+        return new LiteralPrimitive(ast.span, ast.value);
+    }
+    visitPropertyRead(ast, context) {
+        return new PropertyRead(ast.span, ast.receiver.visit(this), ast.name);
+    }
+    visitPropertyWrite(ast, context) {
+        return new PropertyWrite(ast.span, ast.receiver.visit(this), ast.name, ast.value);
+    }
+    visitSafePropertyRead(ast, context) {
+        return new SafePropertyRead(ast.span, ast.receiver.visit(this), ast.name);
+    }
+    visitMethodCall(ast, context) {
+        return new MethodCall(ast.span, ast.receiver.visit(this), ast.name, this.visitAll(ast.args));
+    }
+    visitSafeMethodCall(ast, context) {
+        return new SafeMethodCall(ast.span, ast.receiver.visit(this), ast.name, this.visitAll(ast.args));
+    }
+    visitFunctionCall(ast, context) {
+        return new FunctionCall(ast.span, ast.target.visit(this), this.visitAll(ast.args));
+    }
+    visitLiteralArray(ast, context) {
+        return new LiteralArray(ast.span, this.visitAll(ast.expressions));
+    }
+    visitLiteralMap(ast, context) {
+        return new LiteralMap(ast.span, ast.keys, this.visitAll(ast.values));
+    }
+    visitBinary(ast, context) {
+        return new Binary(ast.span, ast.operation, ast.left.visit(this), ast.right.visit(this));
+    }
+    visitPrefixNot(ast, context) {
+        return new PrefixNot(ast.span, ast.expression.visit(this));
+    }
+    visitConditional(ast, context) {
+        return new Conditional(ast.span, ast.condition.visit(this), ast.trueExp.visit(this), ast.falseExp.visit(this));
+    }
+    visitPipe(ast, context) {
+        return new BindingPipe(ast.span, ast.exp.visit(this), ast.name, this.visitAll(ast.args));
+    }
+    visitKeyedRead(ast, context) {
+        return new KeyedRead(ast.span, ast.obj.visit(this), ast.key.visit(this));
+    }
+    visitKeyedWrite(ast, context) {
+        return new KeyedWrite(ast.span, ast.obj.visit(this), ast.key.visit(this), ast.value.visit(this));
+    }
+    visitAll(asts) {
+        const res = new Array(asts.length);
+        for (let i = 0; i < asts.length; ++i) {
+            res[i] = asts[i].visit(this);
+        }
+        return res;
+    }
+    visitChain(ast, context) {
+        return new Chain(ast.span, this.visitAll(ast.expressions));
+    }
+    visitQuote(ast, context) {
+        return new Quote(ast.span, ast.prefix, ast.uninterpretedExpression, ast.location);
+    }
+}
+
+/**
+ * @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
+ */
+const $EOF = 0;
+const $TAB = 9;
+const $LF = 10;
+const $VTAB = 11;
+const $FF = 12;
+const $CR = 13;
+const $SPACE = 32;
+const $BANG = 33;
+const $DQ = 34;
+const $HASH = 35;
+const $$ = 36;
+const $PERCENT = 37;
+const $AMPERSAND = 38;
+const $SQ = 39;
+const $LPAREN = 40;
+const $RPAREN = 41;
+const $STAR = 42;
+const $PLUS = 43;
+const $COMMA = 44;
+const $MINUS = 45;
+const $PERIOD = 46;
+const $SLASH = 47;
+const $COLON = 58;
+const $SEMICOLON = 59;
+const $LT = 60;
+const $EQ = 61;
+const $GT = 62;
+const $QUESTION = 63;
+const $0 = 48;
+const $9 = 57;
+const $A = 65;
+const $E = 69;
+const $F = 70;
+const $X = 88;
+const $Z = 90;
+const $LBRACKET = 91;
+const $BACKSLASH = 92;
+const $RBRACKET = 93;
+const $CARET = 94;
+const $_ = 95;
+const $a = 97;
+const $e = 101;
+const $f = 102;
+const $n = 110;
+const $r = 114;
+const $t = 116;
+const $u = 117;
+const $v = 118;
+const $x = 120;
+const $z = 122;
+const $LBRACE = 123;
+const $BAR = 124;
+const $RBRACE = 125;
+const $NBSP = 160;
+const $PIPE = 124;
+const $TILDA = 126;
+const $AT = 64;
+const $BT = 96;
+function isWhitespace(code) {
+    return (code >= $TAB && code <= $SPACE) || (code == $NBSP);
+}
+function isDigit(code) {
+    return $0 <= code && code <= $9;
+}
+function isAsciiLetter(code) {
+    return code >= $a && code <= $z || code >= $A && code <= $Z;
+}
+function isAsciiHexDigit(code) {
+    return code >= $a && code <= $f || code >= $A && code <= $F || isDigit(code);
+}
+
+/**
+ * @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
+ */
+class InterpolationConfig {
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+    }
+    static fromArray(markers) {
+        if (!markers) {
+            return DEFAULT_INTERPOLATION_CONFIG;
+        }
+        assertInterpolationSymbols('interpolation', markers);
+        return new InterpolationConfig(markers[0], markers[1]);
+    }
+    ;
+}
+const DEFAULT_INTERPOLATION_CONFIG = new InterpolationConfig('{{', '}}');
+
+/**
+ * @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
+ */
+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'];
+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;
+    }
+}
+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);
+}
+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 ? $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 <= $SPACE) {
+            if (++index >= length) {
+                peek = $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 (isDigit(peek))
+            return this.scanNumber(index);
+        const start = index;
+        switch (peek) {
+            case $PERIOD:
+                this.advance();
+                return isDigit(this.peek) ? this.scanNumber(start) :
+                    newCharacterToken(start, $PERIOD);
+            case $LPAREN:
+            case $RPAREN:
+            case $LBRACE:
+            case $RBRACE:
+            case $LBRACKET:
+            case $RBRACKET:
+            case $COMMA:
+            case $COLON:
+            case $SEMICOLON:
+                return this.scanCharacter(start, peek);
+            case $SQ:
+            case $DQ:
+                return this.scanString();
+            case $HASH:
+            case $PLUS:
+            case $MINUS:
+            case $STAR:
+            case $SLASH:
+            case $PERCENT:
+            case $CARET:
+                return this.scanOperator(start, String.fromCharCode(peek));
+            case $QUESTION:
+                return this.scanComplexOperator(start, '?', $PERIOD, '.');
+            case $LT:
+            case $GT:
+                return this.scanComplexOperator(start, String.fromCharCode(peek), $EQ, '=');
+            case $BANG:
+            case $EQ:
+                return this.scanComplexOperator(start, String.fromCharCode(peek), $EQ, '=', $EQ, '=');
+            case $AMPERSAND:
+                return this.scanComplexOperator(start, '&', $AMPERSAND, '&');
+            case $BAR:
+                return this.scanComplexOperator(start, '|', $BAR, '|');
+            case $NBSP:
+                while (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 (isDigit(this.peek)) {
+                // Do nothing.
+            }
+            else if (this.peek == $PERIOD) {
+                simple = false;
+            }
+            else if (isExponentStart(this.peek)) {
+                this.advance();
+                if (isExponentSign(this.peek))
+                    this.advance();
+                if (!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 == $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 == $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 == $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 ($a <= code && code <= $z) || ($A <= code && code <= $Z) ||
+        (code == $_) || (code == $$);
+}
+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 !== $EOF) {
+        if (!isIdentifierPart(scanner.peek))
+            return false;
+        scanner.advance();
+    }
+    return true;
+}
+function isIdentifierPart(code) {
+    return isAsciiLetter(code) || isDigit(code) || (code == $_) ||
+        (code == $$);
+}
+function isExponentStart(code) {
+    return code == $e || code == $E;
+}
+function isExponentSign(code) {
+    return code == $MINUS || code == $PLUS;
+}
+function isQuote(code) {
+    return code === $SQ || code === $DQ || code === $BT;
+}
+function unescape(code) {
+    switch (code) {
+        case $n:
+            return $LF;
+        case $f:
+            return $FF;
+        case $r:
+            return $CR;
+        case $t:
+            return $TAB;
+        case $v:
+            return $VTAB;
+        default:
+            return code;
+    }
+}
+
+/**
+ * @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
+ */
+class SplitInterpolation {
+    constructor(strings, expressions, offsets) {
+        this.strings = strings;
+        this.expressions = expressions;
+        this.offsets = offsets;
+    }
+}
+class TemplateBindingParseResult {
+    constructor(templateBindings, warnings, errors) {
+        this.templateBindings = templateBindings;
+        this.warnings = warnings;
+        this.errors = errors;
+    }
+}
+function _createInterpolateRegExp(config) {
+    const pattern = escapeRegExp(config.start) + '([\\s\\S]*?)' + escapeRegExp(config.end);
+    return new RegExp(pattern, 'g');
+}
+class Parser {
+    constructor(_lexer) {
+        this._lexer = _lexer;
+        this.errors = [];
+    }
+    parseAction(input, location, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+        this._checkNoInterpolation(input, location, interpolationConfig);
+        const sourceToLex = this._stripComments(input);
+        const tokens = this._lexer.tokenize(this._stripComments(input));
+        const ast = new _ParseAST(input, location, tokens, sourceToLex.length, true, this.errors, input.length - sourceToLex.length)
+            .parseChain();
+        return new ASTWithSource(ast, input, location, this.errors);
+    }
+    parseBinding(input, location, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+        const ast = this._parseBindingAst(input, location, interpolationConfig);
+        return new ASTWithSource(ast, input, location, this.errors);
+    }
+    parseSimpleBinding(input, location, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+        const ast = this._parseBindingAst(input, location, interpolationConfig);
+        const errors = SimpleExpressionChecker.check(ast);
+        if (errors.length > 0) {
+            this._reportError(`Host binding expression cannot contain ${errors.join(' ')}`, input, location);
+        }
+        return new ASTWithSource(ast, input, location, this.errors);
+    }
+    _reportError(message, input, errLocation, ctxLocation) {
+        this.errors.push(new ParserError(message, input, errLocation, ctxLocation));
+    }
+    _parseBindingAst(input, location, interpolationConfig) {
+        // Quotes expressions use 3rd-party expression language. We don't want to use
+        // our lexer or parser for that, so we check for that ahead of time.
+        const quote = this._parseQuote(input, location);
+        if (isPresent$1(quote)) {
+            return quote;
+        }
+        this._checkNoInterpolation(input, location, interpolationConfig);
+        const sourceToLex = this._stripComments(input);
+        const tokens = this._lexer.tokenize(sourceToLex);
+        return new _ParseAST(input, location, tokens, sourceToLex.length, false, this.errors, input.length - sourceToLex.length)
+            .parseChain();
+    }
+    _parseQuote(input, location) {
+        if (isBlank(input))
+            return null;
+        const prefixSeparatorIndex = input.indexOf(':');
+        if (prefixSeparatorIndex == -1)
+            return null;
+        const prefix = input.substring(0, prefixSeparatorIndex).trim();
+        if (!isIdentifier(prefix))
+            return null;
+        const uninterpretedExpression = input.substring(prefixSeparatorIndex + 1);
+        return new Quote(new ParseSpan(0, input.length), prefix, uninterpretedExpression, location);
+    }
+    parseTemplateBindings(prefixToken, input, location) {
+        const tokens = this._lexer.tokenize(input);
+        if (prefixToken) {
+            // Prefix the tokens with the tokens from prefixToken but have them take no space (0 index).
+            const prefixTokens = this._lexer.tokenize(prefixToken).map(t => {
+                t.index = 0;
+                return t;
+            });
+            tokens.unshift(...prefixTokens);
+        }
+        return new _ParseAST(input, location, tokens, input.length, false, this.errors, 0)
+            .parseTemplateBindings();
+    }
+    parseInterpolation(input, location, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+        const split = this.splitInterpolation(input, location, interpolationConfig);
+        if (split == null)
+            return null;
+        const expressions = [];
+        for (let i = 0; i < split.expressions.length; ++i) {
+            const expressionText = split.expressions[i];
+            const sourceToLex = this._stripComments(expressionText);
+            const tokens = this._lexer.tokenize(this._stripComments(split.expressions[i]));
+            const ast = new _ParseAST(input, location, tokens, sourceToLex.length, false, this.errors, split.offsets[i] + (expressionText.length - sourceToLex.length))
+                .parseChain();
+            expressions.push(ast);
+        }
+        return new ASTWithSource(new Interpolation(new ParseSpan(0, isBlank(input) ? 0 : input.length), split.strings, expressions), input, location, this.errors);
+    }
+    splitInterpolation(input, location, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+        const regexp = _createInterpolateRegExp(interpolationConfig);
+        const parts = input.split(regexp);
+        if (parts.length <= 1) {
+            return null;
+        }
+        const strings = [];
+        const expressions = [];
+        const offsets = [];
+        let offset = 0;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            if (i % 2 === 0) {
+                // fixed string
+                strings.push(part);
+                offset += part.length;
+            }
+            else if (part.trim().length > 0) {
+                offset += interpolationConfig.start.length;
+                expressions.push(part);
+                offsets.push(offset);
+                offset += part.length + interpolationConfig.end.length;
+            }
+            else {
+                this._reportError('Blank expressions are not allowed in interpolated strings', input, `at column ${this._findInterpolationErrorColumn(parts, i, interpolationConfig)} in`, location);
+                expressions.push('$implict');
+                offsets.push(offset);
+            }
+        }
+        return new SplitInterpolation(strings, expressions, offsets);
+    }
+    wrapLiteralPrimitive(input, location) {
+        return new ASTWithSource(new LiteralPrimitive(new ParseSpan(0, isBlank(input) ? 0 : input.length), input), input, location, this.errors);
+    }
+    _stripComments(input) {
+        const i = this._commentStart(input);
+        return isPresent$1(i) ? input.substring(0, i).trim() : input;
+    }
+    _commentStart(input) {
+        let outerQuote = null;
+        for (let i = 0; i < input.length - 1; i++) {
+            const char = input.charCodeAt(i);
+            const nextChar = input.charCodeAt(i + 1);
+            if (char === $SLASH && nextChar == $SLASH && isBlank(outerQuote))
+                return i;
+            if (outerQuote === char) {
+                outerQuote = null;
+            }
+            else if (isBlank(outerQuote) && isQuote(char)) {
+                outerQuote = char;
+            }
+        }
+        return null;
+    }
+    _checkNoInterpolation(input, location, interpolationConfig) {
+        const regexp = _createInterpolateRegExp(interpolationConfig);
+        const parts = input.split(regexp);
+        if (parts.length > 1) {
+            this._reportError(`Got interpolation (${interpolationConfig.start}${interpolationConfig.end}) where expression was expected`, input, `at column ${this._findInterpolationErrorColumn(parts, 1, interpolationConfig)} in`, location);
+        }
+    }
+    _findInterpolationErrorColumn(parts, partInErrIdx, interpolationConfig) {
+        let errLocation = '';
+        for (let j = 0; j < partInErrIdx; j++) {
+            errLocation += j % 2 === 0 ?
+                parts[j] :
+                `${interpolationConfig.start}${parts[j]}${interpolationConfig.end}`;
+        }
+        return errLocation.length;
+    }
+}
+class _ParseAST {
+    constructor(input, location, tokens, inputLength, parseAction, errors, offset) {
+        this.input = input;
+        this.location = location;
+        this.tokens = tokens;
+        this.inputLength = inputLength;
+        this.parseAction = parseAction;
+        this.errors = errors;
+        this.offset = offset;
+        this.rparensExpected = 0;
+        this.rbracketsExpected = 0;
+        this.rbracesExpected = 0;
+        this.index = 0;
+    }
+    peek(offset) {
+        const i = this.index + offset;
+        return i < this.tokens.length ? this.tokens[i] : EOF;
+    }
+    get next() { return this.peek(0); }
+    get inputIndex() {
+        return (this.index < this.tokens.length) ? this.next.index + this.offset :
+            this.inputLength + this.offset;
+    }
+    span(start) { return new ParseSpan(start, this.inputIndex); }
+    advance() { this.index++; }
+    optionalCharacter(code) {
+        if (this.next.isCharacter(code)) {
+            this.advance();
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    peekKeywordLet() { return this.next.isKeywordLet(); }
+    expectCharacter(code) {
+        if (this.optionalCharacter(code))
+            return;
+        this.error(`Missing expected ${String.fromCharCode(code)}`);
+    }
+    optionalOperator(op) {
+        if (this.next.isOperator(op)) {
+            this.advance();
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    expectOperator(operator) {
+        if (this.optionalOperator(operator))
+            return;
+        this.error(`Missing expected operator ${operator}`);
+    }
+    expectIdentifierOrKeyword() {
+        const n = this.next;
+        if (!n.isIdentifier() && !n.isKeyword()) {
+            this.error(`Unexpected token ${n}, expected identifier or keyword`);
+            return '';
+        }
+        this.advance();
+        return n.toString();
+    }
+    expectIdentifierOrKeywordOrString() {
+        const n = this.next;
+        if (!n.isIdentifier() && !n.isKeyword() && !n.isString()) {
+            this.error(`Unexpected token ${n}, expected identifier, keyword, or string`);
+            return '';
+        }
+        this.advance();
+        return n.toString();
+    }
+    parseChain() {
+        const exprs = [];
+        const start = this.inputIndex;
+        while (this.index < this.tokens.length) {
+            const expr = this.parsePipe();
+            exprs.push(expr);
+            if (this.optionalCharacter($SEMICOLON)) {
+                if (!this.parseAction) {
+                    this.error('Binding expression cannot contain chained expression');
+                }
+                while (this.optionalCharacter($SEMICOLON)) {
+                } // read all semicolons
+            }
+            else if (this.index < this.tokens.length) {
+                this.error(`Unexpected token '${this.next}'`);
+            }
+        }
+        if (exprs.length == 0)
+            return new EmptyExpr(this.span(start));
+        if (exprs.length == 1)
+            return exprs[0];
+        return new Chain(this.span(start), exprs);
+    }
+    parsePipe() {
+        let result = this.parseExpression();
+        if (this.optionalOperator('|')) {
+            if (this.parseAction) {
+                this.error('Cannot have a pipe in an action expression');
+            }
+            do {
+                const name = this.expectIdentifierOrKeyword();
+                const args = [];
+                while (this.optionalCharacter($COLON)) {
+                    args.push(this.parseExpression());
+                }
+                result = new BindingPipe(this.span(result.span.start), result, name, args);
+            } while (this.optionalOperator('|'));
+        }
+        return result;
+    }
+    parseExpression() { return this.parseConditional(); }
+    parseConditional() {
+        const start = this.inputIndex;
+        const result = this.parseLogicalOr();
+        if (this.optionalOperator('?')) {
+            const yes = this.parsePipe();
+            let no;
+            if (!this.optionalCharacter($COLON)) {
+                const end = this.inputIndex;
+                const expression = this.input.substring(start, end);
+                this.error(`Conditional expression ${expression} requires all 3 expressions`);
+                no = new EmptyExpr(this.span(start));
+            }
+            else {
+                no = this.parsePipe();
+            }
+            return new Conditional(this.span(start), result, yes, no);
+        }
+        else {
+            return result;
+        }
+    }
+    parseLogicalOr() {
+        // '||'
+        let result = this.parseLogicalAnd();
+        while (this.optionalOperator('||')) {
+            const right = this.parseLogicalAnd();
+            result = new Binary(this.span(result.span.start), '||', result, right);
+        }
+        return result;
+    }
+    parseLogicalAnd() {
+        // '&&'
+        let result = this.parseEquality();
+        while (this.optionalOperator('&&')) {
+            const right = this.parseEquality();
+            result = new Binary(this.span(result.span.start), '&&', result, right);
+        }
+        return result;
+    }
+    parseEquality() {
+        // '==','!=','===','!=='
+        let result = this.parseRelational();
+        while (this.next.type == TokenType.Operator) {
+            const operator = this.next.strValue;
+            switch (operator) {
+                case '==':
+                case '===':
+                case '!=':
+                case '!==':
+                    this.advance();
+                    const right = this.parseRelational();
+                    result = new Binary(this.span(result.span.start), operator, result, right);
+                    continue;
+            }
+            break;
+        }
+        return result;
+    }
+    parseRelational() {
+        // '<', '>', '<=', '>='
+        let result = this.parseAdditive();
+        while (this.next.type == TokenType.Operator) {
+            const operator = this.next.strValue;
+            switch (operator) {
+                case '<':
+                case '>':
+                case '<=':
+                case '>=':
+                    this.advance();
+                    const right = this.parseAdditive();
+                    result = new Binary(this.span(result.span.start), operator, result, right);
+                    continue;
+            }
+            break;
+        }
+        return result;
+    }
+    parseAdditive() {
+        // '+', '-'
+        let result = this.parseMultiplicative();
+        while (this.next.type == TokenType.Operator) {
+            const operator = this.next.strValue;
+            switch (operator) {
+                case '+':
+                case '-':
+                    this.advance();
+                    let right = this.parseMultiplicative();
+                    result = new Binary(this.span(result.span.start), operator, result, right);
+                    continue;
+            }
+            break;
+        }
+        return result;
+    }
+    parseMultiplicative() {
+        // '*', '%', '/'
+        let result = this.parsePrefix();
+        while (this.next.type == TokenType.Operator) {
+            const operator = this.next.strValue;
+            switch (operator) {
+                case '*':
+                case '%':
+                case '/':
+                    this.advance();
+                    let right = this.parsePrefix();
+                    result = new Binary(this.span(result.span.start), operator, result, right);
+                    continue;
+            }
+            break;
+        }
+        return result;
+    }
+    parsePrefix() {
+        if (this.next.type == TokenType.Operator) {
+            const start = this.inputIndex;
+            const operator = this.next.strValue;
+            let result;
+            switch (operator) {
+                case '+':
+                    this.advance();
+                    return this.parsePrefix();
+                case '-':
+                    this.advance();
+                    result = this.parsePrefix();
+                    return new Binary(this.span(start), operator, new LiteralPrimitive(new ParseSpan(start, start), 0), result);
+                case '!':
+                    this.advance();
+                    result = this.parsePrefix();
+                    return new PrefixNot(this.span(start), result);
+            }
+        }
+        return this.parseCallChain();
+    }
+    parseCallChain() {
+        let result = this.parsePrimary();
+        while (true) {
+            if (this.optionalCharacter($PERIOD)) {
+                result = this.parseAccessMemberOrMethodCall(result, false);
+            }
+            else if (this.optionalOperator('?.')) {
+                result = this.parseAccessMemberOrMethodCall(result, true);
+            }
+            else if (this.optionalCharacter($LBRACKET)) {
+                this.rbracketsExpected++;
+                const key = this.parsePipe();
+                this.rbracketsExpected--;
+                this.expectCharacter($RBRACKET);
+                if (this.optionalOperator('=')) {
+                    const value = this.parseConditional();
+                    result = new KeyedWrite(this.span(result.span.start), result, key, value);
+                }
+                else {
+                    result = new KeyedRead(this.span(result.span.start), result, key);
+                }
+            }
+            else if (this.optionalCharacter($LPAREN)) {
+                this.rparensExpected++;
+                const args = this.parseCallArguments();
+                this.rparensExpected--;
+                this.expectCharacter($RPAREN);
+                result = new FunctionCall(this.span(result.span.start), result, args);
+            }
+            else {
+                return result;
+            }
+        }
+    }
+    parsePrimary() {
+        const start = this.inputIndex;
+        if (this.optionalCharacter($LPAREN)) {
+            this.rparensExpected++;
+            const result = this.parsePipe();
+            this.rparensExpected--;
+            this.expectCharacter($RPAREN);
+            return result;
+        }
+        else if (this.next.isKeywordNull()) {
+            this.advance();
+            return new LiteralPrimitive(this.span(start), null);
+        }
+        else if (this.next.isKeywordUndefined()) {
+            this.advance();
+            return new LiteralPrimitive(this.span(start), void 0);
+        }
+        else if (this.next.isKeywordTrue()) {
+            this.advance();
+            return new LiteralPrimitive(this.span(start), true);
+        }
+        else if (this.next.isKeywordFalse()) {
+            this.advance();
+            return new LiteralPrimitive(this.span(start), false);
+        }
+        else if (this.next.isKeywordThis()) {
+            this.advance();
+            return new ImplicitReceiver(this.span(start));
+        }
+        else if (this.optionalCharacter($LBRACKET)) {
+            this.rbracketsExpected++;
+            const elements = this.parseExpressionList($RBRACKET);
+            this.rbracketsExpected--;
+            this.expectCharacter($RBRACKET);
+            return new LiteralArray(this.span(start), elements);
+        }
+        else if (this.next.isCharacter($LBRACE)) {
+            return this.parseLiteralMap();
+        }
+        else if (this.next.isIdentifier()) {
+            return this.parseAccessMemberOrMethodCall(new ImplicitReceiver(this.span(start)), false);
+        }
+        else if (this.next.isNumber()) {
+            const value = this.next.toNumber();
+            this.advance();
+            return new LiteralPrimitive(this.span(start), value);
+        }
+        else if (this.next.isString()) {
+            const literalValue = this.next.toString();
+            this.advance();
+            return new LiteralPrimitive(this.span(start), literalValue);
+        }
+        else if (this.index >= this.tokens.length) {
+            this.error(`Unexpected end of expression: ${this.input}`);
+            return new EmptyExpr(this.span(start));
+        }
+        else {
+            this.error(`Unexpected token ${this.next}`);
+            return new EmptyExpr(this.span(start));
+        }
+    }
+    parseExpressionList(terminator) {
+        const result = [];
+        if (!this.next.isCharacter(terminator)) {
+            do {
+                result.push(this.parsePipe());
+            } while (this.optionalCharacter($COMMA));
+        }
+        return result;
+    }
+    parseLiteralMap() {
+        const keys = [];
+        const values = [];
+        const start = this.inputIndex;
+        this.expectCharacter($LBRACE);
+        if (!this.optionalCharacter($RBRACE)) {
+            this.rbracesExpected++;
+            do {
+                const key = this.expectIdentifierOrKeywordOrString();
+                keys.push(key);
+                this.expectCharacter($COLON);
+                values.push(this.parsePipe());
+            } while (this.optionalCharacter($COMMA));
+            this.rbracesExpected--;
+            this.expectCharacter($RBRACE);
+        }
+        return new LiteralMap(this.span(start), keys, values);
+    }
+    parseAccessMemberOrMethodCall(receiver, isSafe = false) {
+        const start = receiver.span.start;
+        const id = this.expectIdentifierOrKeyword();
+        if (this.optionalCharacter($LPAREN)) {
+            this.rparensExpected++;
+            const args = this.parseCallArguments();
+            this.expectCharacter($RPAREN);
+            this.rparensExpected--;
+            const span = this.span(start);
+            return isSafe ? new SafeMethodCall(span, receiver, id, args) :
+                new MethodCall(span, receiver, id, args);
+        }
+        else {
+            if (isSafe) {
+                if (this.optionalOperator('=')) {
+                    this.error('The \'?.\' operator cannot be used in the assignment');
+                    return new EmptyExpr(this.span(start));
+                }
+                else {
+                    return new SafePropertyRead(this.span(start), receiver, id);
+                }
+            }
+            else {
+                if (this.optionalOperator('=')) {
+                    if (!this.parseAction) {
+                        this.error('Bindings cannot contain assignments');
+                        return new EmptyExpr(this.span(start));
+                    }
+                    const value = this.parseConditional();
+                    return new PropertyWrite(this.span(start), receiver, id, value);
+                }
+                else {
+                    return new PropertyRead(this.span(start), receiver, id);
+                }
+            }
+        }
+    }
+    parseCallArguments() {
+        if (this.next.isCharacter($RPAREN))
+            return [];
+        const positionals = [];
+        do {
+            positionals.push(this.parsePipe());
+        } while (this.optionalCharacter($COMMA));
+        return positionals;
+    }
+    /**
+     * An identifier, a keyword, a string with an optional `-` inbetween.
+     */
+    expectTemplateBindingKey() {
+        let result = '';
+        let operatorFound = false;
+        do {
+            result += this.expectIdentifierOrKeywordOrString();
+            operatorFound = this.optionalOperator('-');
+            if (operatorFound) {
+                result += '-';
+            }
+        } while (operatorFound);
+        return result.toString();
+    }
+    parseTemplateBindings() {
+        const bindings = [];
+        let prefix = null;
+        const warnings = [];
+        while (this.index < this.tokens.length) {
+            const start = this.inputIndex;
+            const keyIsVar = this.peekKeywordLet();
+            if (keyIsVar) {
+                this.advance();
+            }
+            let key = this.expectTemplateBindingKey();
+            if (!keyIsVar) {
+                if (prefix == null) {
+                    prefix = key;
+                }
+                else {
+                    key = prefix + key[0].toUpperCase() + key.substring(1);
+                }
+            }
+            this.optionalCharacter($COLON);
+            let name = null;
+            let expression = null;
+            if (keyIsVar) {
+                if (this.optionalOperator('=')) {
+                    name = this.expectTemplateBindingKey();
+                }
+                else {
+                    name = '\$implicit';
+                }
+            }
+            else if (this.next !== EOF && !this.peekKeywordLet()) {
+                const start = this.inputIndex;
+                const ast = this.parsePipe();
+                const source = this.input.substring(start - this.offset, this.inputIndex - this.offset);
+                expression = new ASTWithSource(ast, source, this.location, this.errors);
+            }
+            bindings.push(new TemplateBinding(this.span(start), key, keyIsVar, name, expression));
+            if (!this.optionalCharacter($SEMICOLON)) {
+                this.optionalCharacter($COMMA);
+            }
+        }
+        return new TemplateBindingParseResult(bindings, warnings, this.errors);
+    }
+    error(message, index = null) {
+        this.errors.push(new ParserError(message, this.input, this.locationText(index), this.location));
+        this.skip();
+    }
+    locationText(index = null) {
+        if (isBlank(index))
+            index = this.index;
+        return (index < this.tokens.length) ? `at column ${this.tokens[index].index + 1} in` :
+            `at the end of the expression`;
+    }
+    // Error recovery should skip tokens until it encounters a recovery point. skip() treats
+    // the end of input and a ';' as unconditionally a recovery point. It also treats ')',
+    // '}' and ']' as conditional recovery points if one of calling productions is expecting
+    // one of these symbols. This allows skip() to recover from errors such as '(a.) + 1' allowing
+    // more of the AST to be retained (it doesn't skip any tokens as the ')' is retained because
+    // of the '(' begins an '(' <expr> ')' production). The recovery points of grouping symbols
+    // must be conditional as they must be skipped if none of the calling productions are not
+    // expecting the closing token else we will never make progress in the case of an
+    // extraneous group closing symbol (such as a stray ')'). This is not the case for ';' because
+    // parseChain() is always the root production and it expects a ';'.
+    // If a production expects one of these token it increments the corresponding nesting count,
+    // and then decrements it just prior to checking if the token is in the input.
+    skip() {
+        let n = this.next;
+        while (this.index < this.tokens.length && !n.isCharacter($SEMICOLON) &&
+            (this.rparensExpected <= 0 || !n.isCharacter($RPAREN)) &&
+            (this.rbracesExpected <= 0 || !n.isCharacter($RBRACE)) &&
+            (this.rbracketsExpected <= 0 || !n.isCharacter($RBRACKET))) {
+            if (this.next.isError()) {
+                this.errors.push(new ParserError(this.next.toString(), this.input, this.locationText(), this.location));
+            }
+            this.advance();
+            n = this.next;
+        }
+    }
+}
+class SimpleExpressionChecker {
+    constructor() {
+        this.errors = [];
+    }
+    static check(ast) {
+        const s = new SimpleExpressionChecker();
+        ast.visit(s);
+        return s.errors;
+    }
+    visitImplicitReceiver(ast, context) { }
+    visitInterpolation(ast, context) { }
+    visitLiteralPrimitive(ast, context) { }
+    visitPropertyRead(ast, context) { }
+    visitPropertyWrite(ast, context) { }
+    visitSafePropertyRead(ast, context) { }
+    visitMethodCall(ast, context) { }
+    visitSafeMethodCall(ast, context) { }
+    visitFunctionCall(ast, context) { }
+    visitLiteralArray(ast, context) { this.visitAll(ast.expressions); }
+    visitLiteralMap(ast, context) { this.visitAll(ast.values); }
+    visitBinary(ast, context) { }
+    visitPrefixNot(ast, context) { }
+    visitConditional(ast, context) { }
+    visitPipe(ast, context) { this.errors.push('pipes'); }
+    visitKeyedRead(ast, context) { }
+    visitKeyedWrite(ast, context) { }
+    visitAll(asts) { return asts.map(node => node.visit(this)); }
+    visitChain(ast, context) { }
+    visitQuote(ast, context) { }
+}
+
+const BinaryOperations = new Map([
+    ['==', (left, right) => left == right],
+    ['===', (left, right) => left === right],
+    ['!=', (left, right) => left != right],
+    ['!==', (left, right) => left !== right],
+    ['&&', (left, right) => left && right],
+    ['||', (left, right) => left || right],
+    ['+', (left, right) => left + right],
+    ['-', (left, right) => left - right],
+    ['/', (left, right) => left / right],
+    ['*', (left, right) => left * right],
+    ['%', (left, right) => left % right],
+    ['<', (left, right) => left < right],
+    ['<=', (left, right) => left <= right],
+    ['>', (left, right) => left > right],
+    ['>=', (left, right) => left >= right],
+]);
+
+function compileToJSON(json) {
+    return JSON.stringify(json).replace(/"/g, '');
+}
+function isPresent(obj) {
+    return obj !== null && obj !== undefined;
+}
+function isJsObject(obj) {
+    return obj !== null && (typeof obj === 'function' || typeof obj === 'object');
+}
+function isFunction(val) {
+    return typeof val === 'function';
+}
+
+class ParseVisitorCompiler extends RecursiveAstVisitor {
+    visitBinary(ast) {
+        const left = ast.left.visit(this);
+        const right = ast.right.visit(this);
+        return `${left} ${ast.operation} ${right}`;
+    }
+    // TODO
+    visitChain(ast) {
+        return compileToJSON(this.visitAll(ast.expressions));
+    }
+    visitConditional(ast) {
+        const condition = ast.condition.visit(this);
+        const trueExp = ast.trueExp.visit(this);
+        const falseExp = ast.falseExp.visit(this);
+        return `${condition} ? ${trueExp} : ${falseExp}`;
+    }
+    visitPipe(ast) {
+        const pipe = ast.name;
+        const args = this.visitAll(ast.args);
+        const value = ast.exp.visit(this);
+        args.unshift(value);
+        return `pipesCache.get('${pipe}').transform.apply(null, ${compileToJSON(args)})`;
+    }
+    // TODO
+    visitFunctionCall(ast) {
+        const target = ast.target.visit(this);
+        const args = compileToJSON(this.visitAll(ast.args));
+        return `${target}.apply(${target}, ${args})`;
+    }
+    visitImplicitReceiver(ast) {
+        return `context`;
+    }
+    visitInterpolation(ast) {
+        return this.visitAll(ast.expressions)[0];
+    }
+    visitKeyedRead(ast) {
+        const obj = ast.obj.visit(this);
+        const key = ast.key.visit(this);
+        return `${obj}[${key}]`;
+    }
+    visitKeyedWrite(ast) {
+        return null;
+    }
+    visitLiteralArray(ast) {
+        return compileToJSON(this.visitAll(ast.expressions));
+    }
+    visitLiteralMap(ast) {
+        const result = {};
+        const keys = ast.keys;
+        const values = this.visitAll(ast.values);
+        for (let i = 0, length = keys.length; i < length; i++) {
+            result[keys[i]] = values[i];
+        }
+        return compileToJSON(result);
+    }
+    visitLiteralPrimitive(ast) {
+        return typeof ast.value === 'string' ? `'${ast.value}'` : ast.value;
+    }
+    visitMethodCall(ast) {
+        const methodName = ast.name;
+        const receiver = ast.receiver.visit(this);
+        const args = compileToJSON(this.visitAll(ast.args));
+        return `${receiver}['${methodName}'].apply(${receiver}, ${args})`;
+    }
+    visitPrefixNot(ast) {
+        return ast.expression.visit(this);
+    }
+    visitPropertyRead(ast) {
+        const property = ast.name;
+        const receiver = ast.receiver.visit(this);
+        return `${receiver}['${property}']`;
+    }
+    visitPropertyWrite(ast) {
+        return null;
+    }
+    visitSafePropertyRead(ast) {
+        const property = ast.name;
+        const receiver = ast.receiver.visit(this);
+        return `${receiver}['${property}']`;
+    }
+    visitSafeMethodCall(ast) {
+        const methodName = ast.name;
+        const receiver = ast.receiver.visit(this);
+        const args = compileToJSON(this.visitAll(ast.args));
+        return `${receiver}['${methodName}'].apply(${receiver}, ${args})`;
+    }
+    visitAll(asts) {
+        return asts.map(ast => ast.visit(this));
+    }
+    visitQuote(ast) {
+        return null;
+    }
+}
+
+class ParseVisitorResolver extends RecursiveAstVisitor {
+    constructor(pipes) {
+        super();
+        this.pipes = pipes;
+    }
+    ;
+    visitBinary(ast, context) {
+        const execFn = BinaryOperations.get(ast.operation);
+        if (!execFn) {
+            throw new Error(`Parse ERROR: on visitBinary, unknown operator ${ast.operation}`);
+        }
+        return execFn(ast.left.visit(this, context), ast.right.visit(this, context));
+    }
+    // TODO
+    visitChain(ast, context) {
+        return this.visitAll(ast.expressions, context);
+    }
+    visitConditional(ast, context) {
+        if (ast.condition.visit(this, context)) {
+            return ast.trueExp.visit(this, context);
+        }
+        else if (isPresent(ast.falseExp)) {
+            return ast.falseExp.visit(this, context);
+        }
+        return null;
+    }
+    visitPipe(ast, context) {
+        const pipe = this.pipes.get(ast.name);
+        if (!pipe) {
+            throw new Error(`pipe ${ast.name} not found.`);
+        }
+        if (!pipe.transform) {
+            throw new Error(`Parse ERROR: on visitPipe, transform method doesn't exist on pipe ${ast.name}.`);
+        }
+        const value = ast.exp.visit(this, context);
+        const pipeArgs = this.visitAll(ast.args, context);
+        pipeArgs.unshift(value);
+        return pipe.transform.apply(null, pipeArgs);
+    }
+    // TODO
+    visitFunctionCall(ast, context) {
+        const target = ast.target.visit(this, context);
+        if (!isFunction(target)) {
+            throw new Error(`Parse ERROR: on visitFunctionCall, target is not a function.`);
+        }
+        const args = this.visitAll(ast.args, context);
+        return target.apply(target, args);
+    }
+    visitImplicitReceiver(ast, context) {
+        return context;
+    }
+    visitInterpolation(ast, context) {
+        return this.visitAll(ast.expressions, context)[0];
+    }
+    visitKeyedRead(ast, context) {
+        const obj = ast.obj.visit(this, context);
+        const key = ast.key.visit(this, context);
+        return obj[key];
+    }
+    visitKeyedWrite(ast, context) {
+        const obj = ast.obj.visit(this, context);
+        const key = ast.key.visit(this, context);
+        const value = ast.value.visit(this, context);
+        obj[key] = value;
+        return null;
+    }
+    visitLiteralArray(ast, context) {
+        return this.visitAll(ast.expressions, context);
+    }
+    visitLiteralMap(ast, context) {
+        const result = {};
+        const keys = ast.keys;
+        const values = this.visitAll(ast.values, context);
+        for (let i = 0, length = keys.length; i < length; i++) {
+            result[keys[i]] = values[i];
+        }
+        return result;
+    }
+    visitLiteralPrimitive(ast, context) {
+        return ast.value;
+    }
+    visitMethodCall(ast, context) {
+        const receiver = ast.receiver.visit(this, context);
+        if (!isJsObject(receiver)) {
+            throw new Error(`Parse ERROR: on visitMethodCall, invalid method receiver.`);
+        }
+        const method = receiver[ast.name];
+        if (!isFunction(method)) {
+            throw new Error(`Parse ERROR: on visitMethodCall, method ${ast.name} doesn't exist on receiver.`);
+        }
+        const args = this.visitAll(ast.args, context);
+        return method.apply(receiver, args);
+    }
+    visitPrefixNot(ast, context) {
+        return ast.expression.visit(this, context);
+    }
+    visitPropertyRead(ast, context) {
+        const receiver = ast.receiver.visit(this, context);
+        if (!isJsObject(receiver)) {
+            throw new Error(`Parse ERROR: on visitPropertyRead, invalid property receiver.`);
+        }
+        return receiver[ast.name];
+    }
+    visitPropertyWrite(ast, context) {
+        const receiver = ast.receiver.visit(this, context);
+        if (!isJsObject(receiver)) {
+            throw new Error(`Parse ERROR: on visitPropertyRead, invalid property receiver.`);
+        }
+        receiver[ast.name] = ast.value.visit(this, context);
+        return null;
+    }
+    visitSafePropertyRead(ast, context) {
+        const receiver = ast.receiver.visit(this, context);
+        if (!isJsObject(receiver)) {
+            throw new Error(`Parse ERROR: on visitSafePropertyRead, invalid property receiver.`);
+        }
+        return receiver[ast.name];
+    }
+    visitSafeMethodCall(ast, context) {
+        const receiver = ast.receiver.visit(this, context);
+        if (!isJsObject(receiver)) {
+            throw new Error(`Parse ERROR: on visitSafeMethodCall, invalid method receiver.`);
+        }
+        const method = receiver[ast.name];
+        if (!isFunction(method)) {
+            throw new Error(`Parse ERROR: on visitSafeMethodCall, method ${ast.name} doesn't exist on receiver.`);
+        }
+        const args = this.visitAll(ast.args, context);
+        return method.apply(receiver, args);
+    }
+    visitAll(asts, context) {
+        return asts.map(ast => ast.visit(this, context));
+    }
+    visitQuote(ast, context) {
+        throw new Error(`Parse ERROR: on visitQuote, quote expression not allowed.`);
+    }
+}
+
+const PIPES_CONFIG = new InjectionToken('PipesConfig');
+class Parse {
+    /**
+     * Used to dependency inject the Angular 2 parser.
+     */
+    constructor(pipesConfigs) {
+        this._parser = new Parser(new Lexer());
+        this._pipesCache = new Map();
+        this._evalCache = new Map();
+        this._calcCache = new Map();
+        if (pipesConfigs && pipesConfigs.length) {
+            pipesConfigs
+                .filter(pipes => pipes && pipes.length)
+                .forEach(pipes => pipes.forEach((pipeData) => this._pipesCache.set(pipeData.pipeName, pipeData.pipeInstance)));
+        }
+    }
+    eval(expression) {
+        if (this._evalCache.has(expression)) {
+            return this._evalCache.get(expression);
+        }
+        const visitor = new ParseVisitorCompiler();
+        let ast = this._parser.parseInterpolation(expression, 'Parse');
+        if (!ast) {
+            ast = this._parser.parseBinding(expression, 'Parse');
+        }
+        const fnBody = ast.visit(visitor);
+        const pipesCache = this._pipesCache;
+        const getFn = new Function('context', 'pipesCache', `return ${fnBody};`);
+        const evalParse = function evalParse(context) {
+            return getFn(context, pipesCache);
+        };
+        this._evalCache.set(expression, evalParse);
+        return evalParse;
+    }
+    calc(expression) {
+        if (this._calcCache.has(expression)) {
+            return this._calcCache.get(expression);
+        }
+        const visitor = new ParseVisitorResolver(this._pipesCache);
+        let ast = this._parser.parseInterpolation(expression, 'Parse');
+        if (!ast) {
+            ast = this._parser.parseBinding(expression, 'Parse');
+        }
+        const calcParse = function calcParse(context) {
+            return ast.visit(visitor, context);
+        };
+        this._calcCache.set(expression, calcParse);
+        return calcParse;
+    }
+}
+Parse.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: Parse, deps: [{ token: PIPES_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+Parse.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: Parse, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: Parse, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Optional
+                    }, {
+                        type: Inject,
+                        args: [PIPES_CONFIG]
+                    }] }];
+    } });
+
+class Angular2ParseModule {
+    static forRoot(pipesConfigMap) {
+        return {
+            ngModule: Angular2ParseModule,
+            providers: [{ provide: PIPES_CONFIG, multi: true, useValue: pipesConfigMap || [] }]
+        };
+    }
+}
+Angular2ParseModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: Angular2ParseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+Angular2ParseModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: Angular2ParseModule });
+Angular2ParseModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: Angular2ParseModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: Angular2ParseModule, decorators: [{
+            type: NgModule
+        }] });
+
+/*
+ * Public API Surface of angular2parse
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { Angular2ParseModule, PIPES_CONFIG, Parse };
+//# sourceMappingURL=auscope-angular2parse.mjs.map