@auscope/angular2parse 2.0.2 → 2.0.3

package/fesm2015/auscope-angular2parse.mjs

@@ -1,2035 +0,0 @@
-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