@auscope/angular2parse 2.0.3 → 4.0.0

package/esm2020/lib/angular/compiler/parser.mjs

@@ -0,0 +1,721 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as chars from './chars';
+import { escapeRegExp, isBlank, isPresent } from '../facade/lang';
+import { DEFAULT_INTERPOLATION_CONFIG } from './interpolation-config';
+import { ASTWithSource, Binary, BindingPipe, Chain, Conditional, EmptyExpr, FunctionCall, ImplicitReceiver, Interpolation, KeyedRead, KeyedWrite, LiteralArray, LiteralMap, LiteralPrimitive, MethodCall, ParseSpan, ParserError, PrefixNot, PropertyRead, PropertyWrite, Quote, SafeMethodCall, SafePropertyRead, TemplateBinding } from './ast';
+import { EOF, TokenType, isIdentifier, isQuote } from './lexer';
+export class SplitInterpolation {
+    constructor(strings, expressions, offsets) {
+        this.strings = strings;
+        this.expressions = expressions;
+        this.offsets = offsets;
+    }
+}
+export 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');
+}
+export 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(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(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 === chars.$SLASH && nextChar == chars.$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;
+    }
+}
+export 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(chars.$SEMICOLON)) {
+                if (!this.parseAction) {
+                    this.error('Binding expression cannot contain chained expression');
+                }
+                while (this.optionalCharacter(chars.$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(chars.$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(chars.$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(chars.$PERIOD)) {
+                result = this.parseAccessMemberOrMethodCall(result, false);
+            }
+            else if (this.optionalOperator('?.')) {
+                result = this.parseAccessMemberOrMethodCall(result, true);
+            }
+            else if (this.optionalCharacter(chars.$LBRACKET)) {
+                this.rbracketsExpected++;
+                const key = this.parsePipe();
+                this.rbracketsExpected--;
+                this.expectCharacter(chars.$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(chars.$LPAREN)) {
+                this.rparensExpected++;
+                const args = this.parseCallArguments();
+                this.rparensExpected--;
+                this.expectCharacter(chars.$RPAREN);
+                result = new FunctionCall(this.span(result.span.start), result, args);
+            }
+            else {
+                return result;
+            }
+        }
+    }
+    parsePrimary() {
+        const start = this.inputIndex;
+        if (this.optionalCharacter(chars.$LPAREN)) {
+            this.rparensExpected++;
+            const result = this.parsePipe();
+            this.rparensExpected--;
+            this.expectCharacter(chars.$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(chars.$LBRACKET)) {
+            this.rbracketsExpected++;
+            const elements = this.parseExpressionList(chars.$RBRACKET);
+            this.rbracketsExpected--;
+            this.expectCharacter(chars.$RBRACKET);
+            return new LiteralArray(this.span(start), elements);
+        }
+        else if (this.next.isCharacter(chars.$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(chars.$COMMA));
+        }
+        return result;
+    }
+    parseLiteralMap() {
+        const keys = [];
+        const values = [];
+        const start = this.inputIndex;
+        this.expectCharacter(chars.$LBRACE);
+        if (!this.optionalCharacter(chars.$RBRACE)) {
+            this.rbracesExpected++;
+            do {
+                const key = this.expectIdentifierOrKeywordOrString();
+                keys.push(key);
+                this.expectCharacter(chars.$COLON);
+                values.push(this.parsePipe());
+            } while (this.optionalCharacter(chars.$COMMA));
+            this.rbracesExpected--;
+            this.expectCharacter(chars.$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(chars.$LPAREN)) {
+            this.rparensExpected++;
+            const args = this.parseCallArguments();
+            this.expectCharacter(chars.$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(chars.$RPAREN))
+            return [];
+        const positionals = [];
+        do {
+            positionals.push(this.parsePipe());
+        } while (this.optionalCharacter(chars.$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(chars.$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(chars.$SEMICOLON)) {
+                this.optionalCharacter(chars.$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(chars.$SEMICOLON) &&
+            (this.rparensExpected <= 0 || !n.isCharacter(chars.$RPAREN)) &&
+            (this.rbracesExpected <= 0 || !n.isCharacter(chars.$RBRACE)) &&
+            (this.rbracketsExpected <= 0 || !n.isCharacter(chars.$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) { }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parser.js","sourceRoot":"","sources":["../../../../../../projects/angular2parse/src/lib/angular/compiler/parser.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,EAAC,YAAY,EAAE,OAAO,EAAE,SAAS,EAAC,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAC,4BAA4B,EAAsB,MAAM,wBAAwB,CAAC;AAEzF,OAAO,EAAM,aAAa,EAAc,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,gBAAgB,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,eAAe,EAAC,MAAM,OAAO,CAAC;AACjW,OAAO,EAAC,GAAG,EAAgB,SAAS,EAAE,YAAY,EAAE,OAAO,EAAC,MAAM,SAAS,CAAC;AAG5E,MAAM,OAAO,kBAAkB;IAC3B,YAAmB,OAAiB,EAAS,WAAqB,EAAS,OAAiB;QAAzE,YAAO,GAAP,OAAO,CAAU;QAAS,gBAAW,GAAX,WAAW,CAAU;QAAS,YAAO,GAAP,OAAO,CAAU;IAAG,CAAC;CACnG;AAED,MAAM,OAAO,0BAA0B;IACnC,YACW,gBAAmC,EAAS,QAAkB,EAC9D,MAAqB;QADrB,qBAAgB,GAAhB,gBAAgB,CAAmB;QAAS,aAAQ,GAAR,QAAQ,CAAU;QAC9D,WAAM,GAAN,MAAM,CAAe;IAAG,CAAC;CACvC;AAED,SAAS,wBAAwB,CAAC,MAA2B;IACzD,MAAM,OAAO,GAAG,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,cAAc,GAAG,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACvF,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;AACpC,CAAC;AAED,MAAM,OAAO,MAAM;IAGf,YAAoB,MAAa;QAAb,WAAM,GAAN,MAAM,CAAO;QAFzB,WAAM,GAAkB,EAAE,CAAC;IAEC,CAAC;IAErC,WAAW,CACP,KAAa,EAAE,QAAa,EAC5B,sBAA2C,4BAA4B;QACvE,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QACjE,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC;QAChE,MAAM,GAAG,GAAG,IAAI,SAAS,CACrB,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,EAC9D,KAAK,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;aACjC,UAAU,EAAE,CAAC;QAClB,OAAO,IAAI,aAAa,CAAC,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAChE,CAAC;IAED,YAAY,CACR,KAAa,EAAE,QAAa,EAC5B,sBAA2C,4BAA4B;QACvE,MAAM,GAAG,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QACxE,OAAO,IAAI,aAAa,CAAC,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAChE,CAAC;IAED,kBAAkB,CACd,KAAa,EAAE,QAAgB,EAC/B,sBAA2C,4BAA4B;QACvE,MAAM,GAAG,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QACxE,MAAM,MAAM,GAAG,uBAAuB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAClD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YACnB,IAAI,CAAC,YAAY,CACb,0CAA0C,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;SACtF;QACD,OAAO,IAAI,aAAa,CAAC,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAChE,CAAC;IAEO,YAAY,CAAC,OAAe,EAAE,KAAa,EAAE,WAAmB,EAAE,WAAiB;QACvF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC;IAChF,CAAC;IAEO,gBAAgB,CACpB,KAAa,EAAE,QAAgB,EAAE,mBAAwC;QACzE,6EAA6E;QAC7E,oEAAoE;QACpE,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAEhD,IAAI,SAAS,CAAC,KAAK,CAAC,EAAE;YAClB,OAAO,KAAK,CAAC;SAChB;QAED,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QACjE,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;QACjD,OAAO,IAAI,SAAS,CAChB,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,EAC/D,KAAK,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;aACjC,UAAU,EAAE,CAAC;IACtB,CAAC;IAEO,WAAW,CAAC,KAAa,EAAE,QAAa;QAC5C,IAAI,OAAO,CAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAChC,MAAM,oBAAoB,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAChD,IAAI,oBAAoB,IAAI,CAAC,CAAC;YAAE,OAAO,IAAI,CAAC;QAC5C,MAAM,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC,IAAI,EAAE,CAAC;QAC/D,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;YAAE,OAAO,IAAI,CAAC;QACvC,MAAM,uBAAuB,GAAG,KAAK,CAAC,SAAS,CAAC,oBAAoB,GAAG,CAAC,CAAC,CAAC;QAC1E,OAAO,IAAI,KAAK,CAAC,IAAI,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,uBAAuB,EAAE,QAAQ,CAAC,CAAC;IAChG,CAAC;IAED,qBAAqB,CAAC,WAAmB,EAAE,KAAa,EAAE,QAAa;QAEnE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC3C,IAAI,WAAW,EAAE;YACb,4FAA4F;YAC5F,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;gBAC3D,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC;gBACZ,OAAO,CAAC,CAAC;YACb,CAAC,CAAC,CAAC;YACH,MAAM,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,CAAC;SACnC;QACD,OAAO,IAAI,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;aAC7E,qBAAqB,EAAE,CAAC;IACjC,CAAC;IAED,kBAAkB,CACd,KAAa,EAAE,QAAa,EAC5B,sBAA2C,4BAA4B;QACvE,MAAM,KAAK,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QAC5E,IAAI,KAAK,IAAI,IAAI;YAAE,OAAO,IAAI,CAAC;QAE/B,MAAM,WAAW,GAAU,EAAE,CAAC;QAE9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;YAC/C,MAAM,cAAc,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YAC5C,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;YACxD,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/E,MAAM,GAAG,GAAG,IAAI,SAAS,CACrB,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,EAC/D,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,cAAc,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;iBAC/D,UAAU,EAAE,CAAC;YAClB,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;SACzB;QAED,OAAO,IAAI,aAAa,CACpB,IAAI,aAAa,CACb,IAAI,SAAS,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,OAAO,EAAE,WAAW,CAAC,EACpF,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IAED,kBAAkB,CACd,KAAa,EAAE,QAAgB,EAC/B,sBAA2C,4BAA4B;QACvE,MAAM,MAAM,GAAG,wBAAwB,CAAC,mBAAmB,CAAC,CAAC;QAC7D,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAClC,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,EAAE;YACnB,OAAO,IAAI,CAAC;SACf;QACD,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,MAAM,WAAW,GAAa,EAAE,CAAC;QACjC,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACnC,MAAM,IAAI,GAAW,KAAK,CAAC,CAAC,CAAC,CAAC;YAC9B,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;gBACb,eAAe;gBACf,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACnB,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC;aACzB;iBAAM,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC/B,MAAM,IAAI,mBAAmB,CAAC,KAAK,CAAC,MAAM,CAAC;gBAC3C,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACvB,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACrB,MAAM,IAAI,IAAI,CAAC,MAAM,GAAG,mBAAmB,CAAC,GAAG,CAAC,MAAM,CAAC;aAC1D;iBAAM;gBACH,IAAI,CAAC,YAAY,CACb,2DAA2D,EAAE,KAAK,EAClE,aAAa,IAAI,CAAC,6BAA6B,CAAC,KAAK,EAAE,CAAC,EAAE,mBAAmB,CAAC,KAAK,EACnF,QAAQ,CAAC,CAAC;gBACd,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gBAC7B,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aACxB;SACJ;QACD,OAAO,IAAI,kBAAkB,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;IACjE,CAAC;IAED,oBAAoB,CAAC,KAAa,EAAE,QAAa;QAC7C,OAAO,IAAI,aAAa,CACpB,IAAI,gBAAgB,CAAC,IAAI,SAAS,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,EAAE,KAAK,EACvF,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC/B,CAAC;IAEO,cAAc,CAAC,KAAa;QAChC,MAAM,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACpC,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;IAC/D,CAAC;IAEO,aAAa,CAAC,KAAa;QAC/B,IAAI,UAAU,GAAW,IAAI,CAAC;QAC9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;YACvC,MAAM,IAAI,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YACjC,MAAM,QAAQ,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAEzC,IAAI,IAAI,KAAK,KAAK,CAAC,MAAM,IAAI,QAAQ,IAAI,KAAK,CAAC,MAAM,IAAI,OAAO,CAAC,UAAU,CAAC;gBAAE,OAAO,CAAC,CAAC;YAEvF,IAAI,UAAU,KAAK,IAAI,EAAE;gBACrB,UAAU,GAAG,IAAI,CAAC;aACrB;iBAAM,IAAI,OAAO,CAAC,UAAU,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,EAAE;gBAC7C,UAAU,GAAG,IAAI,CAAC;aACrB;SACJ;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEO,qBAAqB,CACzB,KAAa,EAAE,QAAa,EAAE,mBAAwC;QACtE,MAAM,MAAM,GAAG,wBAAwB,CAAC,mBAAmB,CAAC,CAAC;QAC7D,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAClC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;YAClB,IAAI,CAAC,YAAY,CACb,sBAAsB,mBAAmB,CAAC,KAAK,GAAG,mBAAmB,CAAC,GAAG,iCAAiC,EAC1G,KAAK,EACL,aAAa,IAAI,CAAC,6BAA6B,CAAC,KAAK,EAAE,CAAC,EAAE,mBAAmB,CAAC,KAAK,EACnF,QAAQ,CAAC,CAAC;SACjB;IACL,CAAC;IAEO,6BAA6B,CACjC,KAAe,EAAE,YAAoB,EAAE,mBAAwC;QAC/E,IAAI,WAAW,GAAG,EAAE,CAAC;QACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,EAAE,CAAC,EAAE,EAAE;YACnC,WAAW,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;gBACxB,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;gBACV,GAAG,mBAAmB,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC,GAAG,EAAE,CAAC;SAC3E;QAED,OAAO,WAAW,CAAC,MAAM,CAAC;IAC9B,CAAC;CACJ;AAED,MAAM,OAAO,SAAS;IAOlB,YACW,KAAa,EAAS,QAAa,EAAS,MAAe,EAC3D,WAAmB,EAAS,WAAoB,EAAU,MAAqB,EAC9E,MAAc;QAFf,UAAK,GAAL,KAAK,CAAQ;QAAS,aAAQ,GAAR,QAAQ,CAAK;QAAS,WAAM,GAAN,MAAM,CAAS;QAC3D,gBAAW,GAAX,WAAW,CAAQ;QAAS,gBAAW,GAAX,WAAW,CAAS;QAAU,WAAM,GAAN,MAAM,CAAe;QAC9E,WAAM,GAAN,MAAM,CAAQ;QATlB,oBAAe,GAAG,CAAC,CAAC;QACpB,sBAAiB,GAAG,CAAC,CAAC;QACtB,oBAAe,GAAG,CAAC,CAAC;QAE5B,UAAK,GAAW,CAAC,CAAC;IAKW,CAAC;IAE9B,IAAI,CAAC,MAAc;QACf,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC;QAC9B,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IACzD,CAAC;IAED,IAAI,IAAI,KAAY,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAE1C,IAAI,UAAU;QACV,OAAO,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;YACtE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC;IACvC,CAAC;IAED,IAAI,CAAC,KAAa,IAAI,OAAO,IAAI,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAErE,OAAO,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAE3B,iBAAiB,CAAC,IAAY;QAC1B,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;YAC7B,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,OAAO,IAAI,CAAC;SACf;aAAM;YACH,OAAO,KAAK,CAAC;SAChB;IACL,CAAC;IAED,cAAc,KAAc,OAAO,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;IAE9D,eAAe,CAAC,IAAY;QACxB,IAAI,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC;YAAE,OAAO;QACzC,IAAI,CAAC,KAAK,CAAC,oBAAoB,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAChE,CAAC;IAED,gBAAgB,CAAC,EAAU;QACvB,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE;YAC1B,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,OAAO,IAAI,CAAC;SACf;aAAM;YACH,OAAO,KAAK,CAAC;SAChB;IACL,CAAC;IAED,cAAc,CAAC,QAAgB;QAC3B,IAAI,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC;YAAE,OAAO;QAC5C,IAAI,CAAC,KAAK,CAAC,6BAA6B,QAAQ,EAAE,CAAC,CAAC;IACxD,CAAC;IAED,yBAAyB;QACrB,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;QACpB,IAAI,CAAC,CAAC,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC,SAAS,EAAE,EAAE;YACrC,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,kCAAkC,CAAC,CAAC;YACpE,OAAO,EAAE,CAAC;SACb;QACD,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,OAAO,CAAC,CAAC,QAAQ,EAAE,CAAC;IACxB,CAAC;IAED,iCAAiC;QAC7B,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;QACpB,IAAI,CAAC,CAAC,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAE;YACtD,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,2CAA2C,CAAC,CAAC;YAC7E,OAAO,EAAE,CAAC;SACb;QACD,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,OAAO,CAAC,CAAC,QAAQ,EAAE,CAAC;IACxB,CAAC;IAED,UAAU;QACN,MAAM,KAAK,GAAU,EAAE,CAAC;QACxB,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC;QAC9B,OAAO,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;YACpC,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YAC9B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAEjB,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE;gBAC1C,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;oBACnB,IAAI,CAAC,KAAK,CAAC,sDAAsD,CAAC,CAAC;iBACtE;gBACD,OAAO,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE;iBAChD,CAAE,sBAAsB;aAC5B;iBAAM,IAAI,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;gBACxC,IAAI,CAAC,KAAK,CAAC,qBAAqB,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;aACjD;SACJ;QACD,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC;YAAE,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAC9D,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC;YAAE,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;QACvC,OAAO,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;IAC9C,CAAC;IAED,SAAS;QACL,IAAI,MAAM,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QACpC,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE;YAC5B,IAAI,IAAI,CAAC,WAAW,EAAE;gBAClB,IAAI,CAAC,KAAK,CAAC,4CAA4C,CAAC,CAAC;aAC5D;YAED,GAAG;gBACC,MAAM,IAAI,GAAG,IAAI,CAAC,yBAAyB,EAAE,CAAC;gBAC9C,MAAM,IAAI,GAAU,EAAE,CAAC;gBACvB,OAAO,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;oBACzC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;iBACrC;gBACD,MAAM,GAAG,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;aAC9E,QAAQ,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE;SACxC;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,eAAe,KAAU,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC;IAE1D,gBAAgB;QACZ,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC;QAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QAErC,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE;YAC5B,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YAC7B,IAAI,EAAO,CAAC;YACZ,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;gBACvC,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC;gBAC5B,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;gBACpD,IAAI,CAAC,KAAK,CAAC,0BAA0B,UAAU,6BAA6B,CAAC,CAAC;gBAC9E,EAAE,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;aACxC;iBAAM;gBACH,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;aACzB;YACD,OAAO,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;SAC7D;aAAM;YACH,OAAO,MAAM,CAAC;SACjB;IACL,CAAC;IAED,cAAc;QACV,OAAO;QACP,IAAI,MAAM,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QACpC,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE;YAChC,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;YACrC,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;SAC1E;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,eAAe;QACX,OAAO;QACP,IAAI,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QAClC,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE;YAChC,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YACnC,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;SAC1E;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,aAAa;QACT,wBAAwB;QACxB,IAAI,MAAM,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QACpC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,SAAS,CAAC,QAAQ,EAAE;YACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;YACpC,QAAQ,QAAQ,EAAE;gBACd,KAAK,IAAI,CAAC;gBACV,KAAK,KAAK,CAAC;gBACX,KAAK,IAAI,CAAC;gBACV,KAAK,KAAK;oBACN,IAAI,CAAC,OAAO,EAAE,CAAC;oBACf,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;oBACrC,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;oBAC3E,SAAS;aAChB;YACD,MAAM;SACT;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,eAAe;QACX,uBAAuB;QACvB,IAAI,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QAClC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,SAAS,CAAC,QAAQ,EAAE;YACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;YACpC,QAAQ,QAAQ,EAAE;gBACd,KAAK,GAAG,CAAC;gBACT,KAAK,GAAG,CAAC;gBACT,KAAK,IAAI,CAAC;gBACV,KAAK,IAAI;oBACL,IAAI,CAAC,OAAO,EAAE,CAAC;oBACf,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;oBACnC,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;oBAC3E,SAAS;aAChB;YACD,MAAM;SACT;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,aAAa;QACT,WAAW;QACX,IAAI,MAAM,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACxC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,SAAS,CAAC,QAAQ,EAAE;YACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;YACpC,QAAQ,QAAQ,EAAE;gBACd,KAAK,GAAG,CAAC;gBACT,KAAK,GAAG;oBACJ,IAAI,CAAC,OAAO,EAAE,CAAC;oBACf,IAAI,KAAK,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;oBACvC,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;oBAC3E,SAAS;aAChB;YACD,MAAM;SACT;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,mBAAmB;QACf,gBAAgB;QAChB,IAAI,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QAChC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,SAAS,CAAC,QAAQ,EAAE;YACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;YACpC,QAAQ,QAAQ,EAAE;gBACd,KAAK,GAAG,CAAC;gBACT,KAAK,GAAG,CAAC;gBACT,KAAK,GAAG;oBACJ,IAAI,CAAC,OAAO,EAAE,CAAC;oBACf,IAAI,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;oBAC/B,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;oBAC3E,SAAS;aAChB;YACD,MAAM;SACT;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,WAAW;QACP,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,SAAS,CAAC,QAAQ,EAAE;YACtC,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC;YAC9B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;YACpC,IAAI,MAAW,CAAC;YAChB,QAAQ,QAAQ,EAAE;gBACd,KAAK,GAAG;oBACJ,IAAI,CAAC,OAAO,EAAE,CAAC;oBACf,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;gBAC9B,KAAK,GAAG;oBACJ,IAAI,CAAC,OAAO,EAAE,CAAC;oBACf,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;oBAC5B,OAAO,IAAI,MAAM,CACb,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,IAAI,gBAAgB,CAAC,IAAI,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,EAChF,MAAM,CAAC,CAAC;gBAChB,KAAK,GAAG;oBACJ,IAAI,CAAC,OAAO,EAAE,CAAC;oBACf,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;oBAC5B,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,CAAC;aACtD;SACJ;QACD,OAAO,IAAI,CAAC,cAAc,EAAE,CAAC;IACjC,CAAC;IAED,cAAc;QACV,IAAI,MAAM,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QACjC,OAAO,IAAI,EAAE;YACT,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE;gBACvC,MAAM,GAAG,IAAI,CAAC,6BAA6B,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;aAE9D;iBAAM,IAAI,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE;gBACpC,MAAM,GAAG,IAAI,CAAC,6BAA6B,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;aAE7D;iBAAM,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE;gBAChD,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACzB,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;gBAC7B,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACzB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;gBACtC,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE;oBAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;oBACtC,MAAM,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;iBAC7E;qBAAM;oBACH,MAAM,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;iBACrE;aAEJ;iBAAM,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE;gBAC9C,IAAI,CAAC,eAAe,EAAE,CAAC;gBACvB,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBACvC,IAAI,CAAC,eAAe,EAAE,CAAC;gBACvB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;gBACpC,MAAM,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;aAEzE;iBAAM;gBACH,OAAO,MAAM,CAAC;aACjB;SACJ;IACL,CAAC;IAED,YAAY;QACR,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC;QAC9B,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE;YACvC,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YAChC,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YACpC,OAAO,MAAM,CAAC;SAEjB;aAAM,IAAI,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE;YAClC,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,OAAO,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;SAEvD;aAAM,IAAI,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,EAAE;YACvC,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,OAAO,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;SAEzD;aAAM,IAAI,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE;YAClC,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,OAAO,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;SAEvD;aAAM,IAAI,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE;YACnC,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,OAAO,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;SAExD;aAAM,IAAI,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE;YAClC,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,OAAO,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;SAEjD;aAAM,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE;YAChD,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;YAC3D,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;YACtC,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,CAAC;SAEvD;aAAM,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE;YAC7C,OAAO,IAAI,CAAC,eAAe,EAAE,CAAC;SAEjC;aAAM,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,EAAE;YACjC,OAAO,IAAI,CAAC,6BAA6B,CAAC,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;SAE5F;aAAM,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE;YAC7B,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnC,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,OAAO,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;SAExD;aAAM,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE;YAC7B,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC1C,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,OAAO,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC;SAE/D;aAAM,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;YACzC,IAAI,CAAC,KAAK,CAAC,iCAAiC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;YAC1D,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;SAC1C;aAAM;YACH,IAAI,CAAC,KAAK,CAAC,oBAAoB,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;YAC5C,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;SAC1C;IACL,CAAC;IAED,mBAAmB,CAAC,UAAkB;QAClC,MAAM,MAAM,GAAU,EAAE,CAAC;QACzB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE;YACpC,GAAG;gBACC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;aACjC,QAAQ,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;SAClD;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,eAAe;QACX,MAAM,IAAI,GAAa,EAAE,CAAC;QAC1B,MAAM,MAAM,GAAU,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC;QAC9B,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACpC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE;YACxC,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,GAAG;gBACC,MAAM,GAAG,GAAG,IAAI,CAAC,iCAAiC,EAAE,CAAC;gBACrD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBACf,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;gBACnC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;aACjC,QAAQ,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;YAC/C,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;SACvC;QACD,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IAC1D,CAAC;IAED,6BAA6B,CAAC,QAAa,EAAE,SAAkB,KAAK;QAChE,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC;QAClC,MAAM,EAAE,GAAG,IAAI,CAAC,yBAAyB,EAAE,CAAC;QAE5C,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE;YACvC,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACvC,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YACpC,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC9B,OAAO,MAAM,CAAC,CAAC,CAAC,IAAI,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC;gBAC1D,IAAI,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;SAEhD;aAAM;YACH,IAAI,MAAM,EAAE;gBACR,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE;oBAC5B,IAAI,CAAC,KAAK,CAAC,sDAAsD,CAAC,CAAC;oBACnE,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;iBAC1C;qBAAM;oBACH,OAAO,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;iBAC/D;aACJ;iBAAM;gBACH,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE;oBAC5B,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;wBACnB,IAAI,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;wBAClD,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;qBAC1C;oBAED,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;oBACtC,OAAO,IAAI,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;iBACnE;qBAAM;oBACH,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;iBAC3D;aACJ;SACJ;IACL,CAAC;IAED,kBAAkB;QACd,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC;YAAE,OAAO,EAAE,CAAC;QACpD,MAAM,WAAW,GAAU,EAAE,CAAC;QAC9B,GAAG;YACC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;SACtC,QAAQ,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;QAC/C,OAAO,WAA4B,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,wBAAwB;QACpB,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,IAAI,aAAa,GAAG,KAAK,CAAC;QAC1B,GAAG;YACC,MAAM,IAAI,IAAI,CAAC,iCAAiC,EAAE,CAAC;YACnD,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;YAC3C,IAAI,aAAa,EAAE;gBACf,MAAM,IAAI,GAAG,CAAC;aACjB;SACJ,QAAQ,aAAa,EAAE;QAExB,OAAO,MAAM,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;IAED,qBAAqB;QACjB,MAAM,QAAQ,GAAsB,EAAE,CAAC;QACvC,IAAI,MAAM,GAAW,IAAI,CAAC;QAC1B,MAAM,QAAQ,GAAa,EAAE,CAAC;QAC9B,OAAO,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;YACpC,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC;YAC9B,MAAM,QAAQ,GAAY,IAAI,CAAC,cAAc,EAAE,CAAC;YAChD,IAAI,QAAQ,EAAE;gBACV,IAAI,CAAC,OAAO,EAAE,CAAC;aAClB;YACD,IAAI,GAAG,GAAG,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAC1C,IAAI,CAAC,QAAQ,EAAE;gBACX,IAAI,MAAM,IAAI,IAAI,EAAE;oBAChB,MAAM,GAAG,GAAG,CAAC;iBAChB;qBAAM;oBACH,GAAG,GAAG,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;iBAC1D;aACJ;YACD,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YACrC,IAAI,IAAI,GAAW,IAAI,CAAC;YACxB,IAAI,UAAU,GAAkB,IAAI,CAAC;YACrC,IAAI,QAAQ,EAAE;gBACV,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE;oBAC5B,IAAI,GAAG,IAAI,CAAC,wBAAwB,EAAE,CAAC;iBAC1C;qBAAM;oBACH,IAAI,GAAG,YAAY,CAAC;iBACvB;aACJ;iBAAM,IAAI,IAAI,CAAC,IAAI,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE;gBACpD,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC;gBAC9B,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;gBAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;gBACxF,UAAU,GAAG,IAAI,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;aAC3E;YACD,QAAQ,CAAC,IAAI,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC;YACtF,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE;gBAC3C,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;aACxC;SACJ;QACD,OAAO,IAAI,0BAA0B,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3E,CAAC;IAED,KAAK,CAAC,OAAe,EAAE,QAAgB,IAAI;QACvC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;QAChG,IAAI,CAAC,IAAI,EAAE,CAAC;IAChB,CAAC;IAEO,YAAY,CAAC,QAAgB,IAAI;QACrC,IAAI,OAAO,CAAC,KAAK,CAAC;YAAE,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACvC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,aAAa,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG,CAAC,KAAK,CAAC,CAAC;YAClF,8BAA8B,CAAC;IACvC,CAAC;IAED,wFAAwF;IACxF,sFAAsF;IACtF,wFAAwF;IACxF,8FAA8F;IAC9F,4FAA4F;IAC5F,2FAA2F;IAC3F,yFAAyF;IACzF,iFAAiF;IACjF,8FAA8F;IAC9F,mEAAmE;IAEnE,4FAA4F;IAC5F,8EAA8E;IACtE,IAAI;QACR,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;QAClB,OAAO,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,UAAU,CAAC;YAC1E,CAAC,IAAI,CAAC,eAAe,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YAC5D,CAAC,IAAI,CAAC,eAAe,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YAC5D,CAAC,IAAI,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE;YAC9D,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE;gBACrB,IAAI,CAAC,MAAM,CAAC,IAAI,CACZ,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;aAC9F;YACD,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;SACjB;IACL,CAAC;CACJ;AAED,MAAM,uBAAuB;IAA7B;QAOI,WAAM,GAAa,EAAE,CAAC;IAyC1B,CAAC;IA/CG,MAAM,CAAC,KAAK,CAAC,GAAQ;QACjB,MAAM,CAAC,GAAG,IAAI,uBAAuB,EAAE,CAAC;QACxC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACb,OAAO,CAAC,CAAC,MAAM,CAAC;IACpB,CAAC;IAID,qBAAqB,CAAC,GAAqB,EAAE,OAAY,IAAG,CAAC;IAE7D,kBAAkB,CAAC,GAAkB,EAAE,OAAY,IAAG,CAAC;IAEvD,qBAAqB,CAAC,GAAqB,EAAE,OAAY,IAAG,CAAC;IAE7D,iBAAiB,CAAC,GAAiB,EAAE,OAAY,IAAG,CAAC;IAErD,kBAAkB,CAAC,GAAkB,EAAE,OAAY,IAAG,CAAC;IAEvD,qBAAqB,CAAC,GAAqB,EAAE,OAAY,IAAG,CAAC;IAE7D,eAAe,CAAC,GAAe,EAAE,OAAY,IAAG,CAAC;IAEjD,mBAAmB,CAAC,GAAmB,EAAE,OAAY,IAAG,CAAC;IAEzD,iBAAiB,CAAC,GAAiB,EAAE,OAAY,IAAG,CAAC;IAErD,iBAAiB,CAAC,GAAiB,EAAE,OAAY,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAEtF,eAAe,CAAC,GAAe,EAAE,OAAY,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAE7E,WAAW,CAAC,GAAW,EAAE,OAAY,IAAG,CAAC;IAEzC,cAAc,CAAC,GAAc,EAAE,OAAY,IAAG,CAAC;IAE/C,gBAAgB,CAAC,GAAgB,EAAE,OAAY,IAAG,CAAC;IAEnD,SAAS,CAAC,GAAgB,EAAE,OAAY,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAExE,cAAc,CAAC,GAAc,EAAE,OAAY,IAAG,CAAC;IAE/C,eAAe,CAAC,GAAe,EAAE,OAAY,IAAG,CAAC;IAEjD,QAAQ,CAAC,IAAW,IAAW,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAE3E,UAAU,CAAC,GAAU,EAAE,OAAY,IAAG,CAAC;IAEvC,UAAU,CAAC,GAAU,EAAE,OAAY,IAAG,CAAC;CAC1C","sourcesContent":["/**\r\n * @license\r\n * Copyright Google Inc. All Rights Reserved.\r\n *\r\n * Use of this source code is governed by an MIT-style license that can be\r\n * found in the LICENSE file at https://angular.io/license\r\n */\r\n\r\nimport * as chars from './chars';\r\nimport {escapeRegExp, isBlank, isPresent} from '../facade/lang';\r\nimport {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from './interpolation-config';\r\n\r\nimport {AST, ASTWithSource, AstVisitor, Binary, BindingPipe, Chain, Conditional, EmptyExpr, FunctionCall, ImplicitReceiver, Interpolation, KeyedRead, KeyedWrite, LiteralArray, LiteralMap, LiteralPrimitive, MethodCall, ParseSpan, ParserError, PrefixNot, PropertyRead, PropertyWrite, Quote, SafeMethodCall, SafePropertyRead, TemplateBinding} from './ast';\r\nimport {EOF, Lexer, Token, TokenType, isIdentifier, isQuote} from './lexer';\r\n\r\n\r\nexport class SplitInterpolation {\r\n    constructor(public strings: string[], public expressions: string[], public offsets: number[]) {}\r\n}\r\n\r\nexport class TemplateBindingParseResult {\r\n    constructor(\r\n        public templateBindings: TemplateBinding[], public warnings: string[],\r\n        public errors: ParserError[]) {}\r\n}\r\n\r\nfunction _createInterpolateRegExp(config: InterpolationConfig): RegExp {\r\n    const pattern = escapeRegExp(config.start) + '([\\\\s\\\\S]*?)' + escapeRegExp(config.end);\r\n    return new RegExp(pattern, 'g');\r\n}\r\n\r\nexport class Parser {\r\n    private errors: ParserError[] = [];\r\n\r\n    constructor(private _lexer: Lexer) {}\r\n\r\n    parseAction(\r\n        input: string, location: any,\r\n        interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ASTWithSource {\r\n        this._checkNoInterpolation(input, location, interpolationConfig);\r\n        const sourceToLex = this._stripComments(input);\r\n        const tokens = this._lexer.tokenize(this._stripComments(input));\r\n        const ast = new _ParseAST(\r\n            input, location, tokens, sourceToLex.length, true, this.errors,\r\n            input.length - sourceToLex.length)\r\n            .parseChain();\r\n        return new ASTWithSource(ast, input, location, this.errors);\r\n    }\r\n\r\n    parseBinding(\r\n        input: string, location: any,\r\n        interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ASTWithSource {\r\n        const ast = this._parseBindingAst(input, location, interpolationConfig);\r\n        return new ASTWithSource(ast, input, location, this.errors);\r\n    }\r\n\r\n    parseSimpleBinding(\r\n        input: string, location: string,\r\n        interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ASTWithSource {\r\n        const ast = this._parseBindingAst(input, location, interpolationConfig);\r\n        const errors = SimpleExpressionChecker.check(ast);\r\n        if (errors.length > 0) {\r\n            this._reportError(\r\n                `Host binding expression cannot contain ${errors.join(' ')}`, input, location);\r\n        }\r\n        return new ASTWithSource(ast, input, location, this.errors);\r\n    }\r\n\r\n    private _reportError(message: string, input: string, errLocation: string, ctxLocation?: any) {\r\n        this.errors.push(new ParserError(message, input, errLocation, ctxLocation));\r\n    }\r\n\r\n    private _parseBindingAst(\r\n        input: string, location: string, interpolationConfig: InterpolationConfig): AST {\r\n        // Quotes expressions use 3rd-party expression language. We don't want to use\r\n        // our lexer or parser for that, so we check for that ahead of time.\r\n        const quote = this._parseQuote(input, location);\r\n\r\n        if (isPresent(quote)) {\r\n            return quote;\r\n        }\r\n\r\n        this._checkNoInterpolation(input, location, interpolationConfig);\r\n        const sourceToLex = this._stripComments(input);\r\n        const tokens = this._lexer.tokenize(sourceToLex);\r\n        return new _ParseAST(\r\n            input, location, tokens, sourceToLex.length, false, this.errors,\r\n            input.length - sourceToLex.length)\r\n            .parseChain();\r\n    }\r\n\r\n    private _parseQuote(input: string, location: any): AST {\r\n        if (isBlank(input)) return null;\r\n        const prefixSeparatorIndex = input.indexOf(':');\r\n        if (prefixSeparatorIndex == -1) return null;\r\n        const prefix = input.substring(0, prefixSeparatorIndex).trim();\r\n        if (!isIdentifier(prefix)) return null;\r\n        const uninterpretedExpression = input.substring(prefixSeparatorIndex + 1);\r\n        return new Quote(new ParseSpan(0, input.length), prefix, uninterpretedExpression, location);\r\n    }\r\n\r\n    parseTemplateBindings(prefixToken: string, input: string, location: any):\r\n    TemplateBindingParseResult {\r\n        const tokens = this._lexer.tokenize(input);\r\n        if (prefixToken) {\r\n            // Prefix the tokens with the tokens from prefixToken but have them take no space (0 index).\r\n            const prefixTokens = this._lexer.tokenize(prefixToken).map(t => {\r\n                t.index = 0;\r\n                return t;\r\n            });\r\n            tokens.unshift(...prefixTokens);\r\n        }\r\n        return new _ParseAST(input, location, tokens, input.length, false, this.errors, 0)\r\n            .parseTemplateBindings();\r\n    }\r\n\r\n    parseInterpolation(\r\n        input: string, location: any,\r\n        interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ASTWithSource {\r\n        const split = this.splitInterpolation(input, location, interpolationConfig);\r\n        if (split == null) return null;\r\n\r\n        const expressions: AST[] = [];\r\n\r\n        for (let i = 0; i < split.expressions.length; ++i) {\r\n            const expressionText = split.expressions[i];\r\n            const sourceToLex = this._stripComments(expressionText);\r\n            const tokens = this._lexer.tokenize(this._stripComments(split.expressions[i]));\r\n            const ast = new _ParseAST(\r\n                input, location, tokens, sourceToLex.length, false, this.errors,\r\n                split.offsets[i] + (expressionText.length - sourceToLex.length))\r\n                .parseChain();\r\n            expressions.push(ast);\r\n        }\r\n\r\n        return new ASTWithSource(\r\n            new Interpolation(\r\n                new ParseSpan(0, isBlank(input) ? 0 : input.length), split.strings, expressions),\r\n            input, location, this.errors);\r\n    }\r\n\r\n    splitInterpolation(\r\n        input: string, location: string,\r\n        interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): SplitInterpolation {\r\n        const regexp = _createInterpolateRegExp(interpolationConfig);\r\n        const parts = input.split(regexp);\r\n        if (parts.length <= 1) {\r\n            return null;\r\n        }\r\n        const strings: string[] = [];\r\n        const expressions: string[] = [];\r\n        const offsets: number[] = [];\r\n        let offset = 0;\r\n        for (let i = 0; i < parts.length; i++) {\r\n            const part: string = parts[i];\r\n            if (i % 2 === 0) {\r\n                // fixed string\r\n                strings.push(part);\r\n                offset += part.length;\r\n            } else if (part.trim().length > 0) {\r\n                offset += interpolationConfig.start.length;\r\n                expressions.push(part);\r\n                offsets.push(offset);\r\n                offset += part.length + interpolationConfig.end.length;\r\n            } else {\r\n                this._reportError(\r\n                    'Blank expressions are not allowed in interpolated strings', input,\r\n                    `at column ${this._findInterpolationErrorColumn(parts, i, interpolationConfig)} in`,\r\n                    location);\r\n                expressions.push('$implict');\r\n                offsets.push(offset);\r\n            }\r\n        }\r\n        return new SplitInterpolation(strings, expressions, offsets);\r\n    }\r\n\r\n    wrapLiteralPrimitive(input: string, location: any): ASTWithSource {\r\n        return new ASTWithSource(\r\n            new LiteralPrimitive(new ParseSpan(0, isBlank(input) ? 0 : input.length), input), input,\r\n            location, this.errors);\r\n    }\r\n\r\n    private _stripComments(input: string): string {\r\n        const i = this._commentStart(input);\r\n        return isPresent(i) ? input.substring(0, i).trim() : input;\r\n    }\r\n\r\n    private _commentStart(input: string): number {\r\n        let outerQuote: number = null;\r\n        for (let i = 0; i < input.length - 1; i++) {\r\n            const char = input.charCodeAt(i);\r\n            const nextChar = input.charCodeAt(i + 1);\r\n\r\n            if (char === chars.$SLASH && nextChar == chars.$SLASH && isBlank(outerQuote)) return i;\r\n\r\n            if (outerQuote === char) {\r\n                outerQuote = null;\r\n            } else if (isBlank(outerQuote) && isQuote(char)) {\r\n                outerQuote = char;\r\n            }\r\n        }\r\n        return null;\r\n    }\r\n\r\n    private _checkNoInterpolation(\r\n        input: string, location: any, interpolationConfig: InterpolationConfig): void {\r\n        const regexp = _createInterpolateRegExp(interpolationConfig);\r\n        const parts = input.split(regexp);\r\n        if (parts.length > 1) {\r\n            this._reportError(\r\n                `Got interpolation (${interpolationConfig.start}${interpolationConfig.end}) where expression was expected`,\r\n                input,\r\n                `at column ${this._findInterpolationErrorColumn(parts, 1, interpolationConfig)} in`,\r\n                location);\r\n        }\r\n    }\r\n\r\n    private _findInterpolationErrorColumn(\r\n        parts: string[], partInErrIdx: number, interpolationConfig: InterpolationConfig): number {\r\n        let errLocation = '';\r\n        for (let j = 0; j < partInErrIdx; j++) {\r\n            errLocation += j % 2 === 0 ?\r\n                parts[j] :\r\n                `${interpolationConfig.start}${parts[j]}${interpolationConfig.end}`;\r\n        }\r\n\r\n        return errLocation.length;\r\n    }\r\n}\r\n\r\nexport class _ParseAST {\r\n    private rparensExpected = 0;\r\n    private rbracketsExpected = 0;\r\n    private rbracesExpected = 0;\r\n\r\n    index: number = 0;\r\n\r\n    constructor(\r\n        public input: string, public location: any, public tokens: Token[],\r\n        public inputLength: number, public parseAction: boolean, private errors: ParserError[],\r\n        private offset: number) {}\r\n\r\n    peek(offset: number): Token {\r\n        const i = this.index + offset;\r\n        return i < this.tokens.length ? this.tokens[i] : EOF;\r\n    }\r\n\r\n    get next(): Token { return this.peek(0); }\r\n\r\n    get inputIndex(): number {\r\n        return (this.index < this.tokens.length) ? this.next.index + this.offset :\r\n            this.inputLength + this.offset;\r\n    }\r\n\r\n    span(start: number) { return new ParseSpan(start, this.inputIndex); }\r\n\r\n    advance() { this.index++; }\r\n\r\n    optionalCharacter(code: number): boolean {\r\n        if (this.next.isCharacter(code)) {\r\n            this.advance();\r\n            return true;\r\n        } else {\r\n            return false;\r\n        }\r\n    }\r\n\r\n    peekKeywordLet(): boolean { return this.next.isKeywordLet(); }\r\n\r\n    expectCharacter(code: number) {\r\n        if (this.optionalCharacter(code)) return;\r\n        this.error(`Missing expected ${String.fromCharCode(code)}`);\r\n    }\r\n\r\n    optionalOperator(op: string): boolean {\r\n        if (this.next.isOperator(op)) {\r\n            this.advance();\r\n            return true;\r\n        } else {\r\n            return false;\r\n        }\r\n    }\r\n\r\n    expectOperator(operator: string) {\r\n        if (this.optionalOperator(operator)) return;\r\n        this.error(`Missing expected operator ${operator}`);\r\n    }\r\n\r\n    expectIdentifierOrKeyword(): string {\r\n        const n = this.next;\r\n        if (!n.isIdentifier() && !n.isKeyword()) {\r\n            this.error(`Unexpected token ${n}, expected identifier or keyword`);\r\n            return '';\r\n        }\r\n        this.advance();\r\n        return n.toString();\r\n    }\r\n\r\n    expectIdentifierOrKeywordOrString(): string {\r\n        const n = this.next;\r\n        if (!n.isIdentifier() && !n.isKeyword() && !n.isString()) {\r\n            this.error(`Unexpected token ${n}, expected identifier, keyword, or string`);\r\n            return '';\r\n        }\r\n        this.advance();\r\n        return n.toString();\r\n    }\r\n\r\n    parseChain(): AST {\r\n        const exprs: AST[] = [];\r\n        const start = this.inputIndex;\r\n        while (this.index < this.tokens.length) {\r\n            const expr = this.parsePipe();\r\n            exprs.push(expr);\r\n\r\n            if (this.optionalCharacter(chars.$SEMICOLON)) {\r\n                if (!this.parseAction) {\r\n                    this.error('Binding expression cannot contain chained expression');\r\n                }\r\n                while (this.optionalCharacter(chars.$SEMICOLON)) {\r\n                }  // read all semicolons\r\n            } else if (this.index < this.tokens.length) {\r\n                this.error(`Unexpected token '${this.next}'`);\r\n            }\r\n        }\r\n        if (exprs.length == 0) return new EmptyExpr(this.span(start));\r\n        if (exprs.length == 1) return exprs[0];\r\n        return new Chain(this.span(start), exprs);\r\n    }\r\n\r\n    parsePipe(): AST {\r\n        let result = this.parseExpression();\r\n        if (this.optionalOperator('|')) {\r\n            if (this.parseAction) {\r\n                this.error('Cannot have a pipe in an action expression');\r\n            }\r\n\r\n            do {\r\n                const name = this.expectIdentifierOrKeyword();\r\n                const args: AST[] = [];\r\n                while (this.optionalCharacter(chars.$COLON)) {\r\n                    args.push(this.parseExpression());\r\n                }\r\n                result = new BindingPipe(this.span(result.span.start), result, name, args);\r\n            } while (this.optionalOperator('|'));\r\n        }\r\n\r\n        return result;\r\n    }\r\n\r\n    parseExpression(): AST { return this.parseConditional(); }\r\n\r\n    parseConditional(): AST {\r\n        const start = this.inputIndex;\r\n        const result = this.parseLogicalOr();\r\n\r\n        if (this.optionalOperator('?')) {\r\n            const yes = this.parsePipe();\r\n            let no: AST;\r\n            if (!this.optionalCharacter(chars.$COLON)) {\r\n                const end = this.inputIndex;\r\n                const expression = this.input.substring(start, end);\r\n                this.error(`Conditional expression ${expression} requires all 3 expressions`);\r\n                no = new EmptyExpr(this.span(start));\r\n            } else {\r\n                no = this.parsePipe();\r\n            }\r\n            return new Conditional(this.span(start), result, yes, no);\r\n        } else {\r\n            return result;\r\n        }\r\n    }\r\n\r\n    parseLogicalOr(): AST {\r\n        // '||'\r\n        let result = this.parseLogicalAnd();\r\n        while (this.optionalOperator('||')) {\r\n            const right = this.parseLogicalAnd();\r\n            result = new Binary(this.span(result.span.start), '||', result, right);\r\n        }\r\n        return result;\r\n    }\r\n\r\n    parseLogicalAnd(): AST {\r\n        // '&&'\r\n        let result = this.parseEquality();\r\n        while (this.optionalOperator('&&')) {\r\n            const right = this.parseEquality();\r\n            result = new Binary(this.span(result.span.start), '&&', result, right);\r\n        }\r\n        return result;\r\n    }\r\n\r\n    parseEquality(): AST {\r\n        // '==','!=','===','!=='\r\n        let result = this.parseRelational();\r\n        while (this.next.type == TokenType.Operator) {\r\n            const operator = this.next.strValue;\r\n            switch (operator) {\r\n                case '==':\r\n                case '===':\r\n                case '!=':\r\n                case '!==':\r\n                    this.advance();\r\n                    const right = this.parseRelational();\r\n                    result = new Binary(this.span(result.span.start), operator, result, right);\r\n                    continue;\r\n            }\r\n            break;\r\n        }\r\n        return result;\r\n    }\r\n\r\n    parseRelational(): AST {\r\n        // '<', '>', '<=', '>='\r\n        let result = this.parseAdditive();\r\n        while (this.next.type == TokenType.Operator) {\r\n            const operator = this.next.strValue;\r\n            switch (operator) {\r\n                case '<':\r\n                case '>':\r\n                case '<=':\r\n                case '>=':\r\n                    this.advance();\r\n                    const right = this.parseAdditive();\r\n                    result = new Binary(this.span(result.span.start), operator, result, right);\r\n                    continue;\r\n            }\r\n            break;\r\n        }\r\n        return result;\r\n    }\r\n\r\n    parseAdditive(): AST {\r\n        // '+', '-'\r\n        let result = this.parseMultiplicative();\r\n        while (this.next.type == TokenType.Operator) {\r\n            const operator = this.next.strValue;\r\n            switch (operator) {\r\n                case '+':\r\n                case '-':\r\n                    this.advance();\r\n                    let right = this.parseMultiplicative();\r\n                    result = new Binary(this.span(result.span.start), operator, result, right);\r\n                    continue;\r\n            }\r\n            break;\r\n        }\r\n        return result;\r\n    }\r\n\r\n    parseMultiplicative(): AST {\r\n        // '*', '%', '/'\r\n        let result = this.parsePrefix();\r\n        while (this.next.type == TokenType.Operator) {\r\n            const operator = this.next.strValue;\r\n            switch (operator) {\r\n                case '*':\r\n                case '%':\r\n                case '/':\r\n                    this.advance();\r\n                    let right = this.parsePrefix();\r\n                    result = new Binary(this.span(result.span.start), operator, result, right);\r\n                    continue;\r\n            }\r\n            break;\r\n        }\r\n        return result;\r\n    }\r\n\r\n    parsePrefix(): AST {\r\n        if (this.next.type == TokenType.Operator) {\r\n            const start = this.inputIndex;\r\n            const operator = this.next.strValue;\r\n            let result: AST;\r\n            switch (operator) {\r\n                case '+':\r\n                    this.advance();\r\n                    return this.parsePrefix();\r\n                case '-':\r\n                    this.advance();\r\n                    result = this.parsePrefix();\r\n                    return new Binary(\r\n                        this.span(start), operator, new LiteralPrimitive(new ParseSpan(start, start), 0),\r\n                        result);\r\n                case '!':\r\n                    this.advance();\r\n                    result = this.parsePrefix();\r\n                    return new PrefixNot(this.span(start), result);\r\n            }\r\n        }\r\n        return this.parseCallChain();\r\n    }\r\n\r\n    parseCallChain(): AST {\r\n        let result = this.parsePrimary();\r\n        while (true) {\r\n            if (this.optionalCharacter(chars.$PERIOD)) {\r\n                result = this.parseAccessMemberOrMethodCall(result, false);\r\n\r\n            } else if (this.optionalOperator('?.')) {\r\n                result = this.parseAccessMemberOrMethodCall(result, true);\r\n\r\n            } else if (this.optionalCharacter(chars.$LBRACKET)) {\r\n                this.rbracketsExpected++;\r\n                const key = this.parsePipe();\r\n                this.rbracketsExpected--;\r\n                this.expectCharacter(chars.$RBRACKET);\r\n                if (this.optionalOperator('=')) {\r\n                    const value = this.parseConditional();\r\n                    result = new KeyedWrite(this.span(result.span.start), result, key, value);\r\n                } else {\r\n                    result = new KeyedRead(this.span(result.span.start), result, key);\r\n                }\r\n\r\n            } else if (this.optionalCharacter(chars.$LPAREN)) {\r\n                this.rparensExpected++;\r\n                const args = this.parseCallArguments();\r\n                this.rparensExpected--;\r\n                this.expectCharacter(chars.$RPAREN);\r\n                result = new FunctionCall(this.span(result.span.start), result, args);\r\n\r\n            } else {\r\n                return result;\r\n            }\r\n        }\r\n    }\r\n\r\n    parsePrimary(): AST {\r\n        const start = this.inputIndex;\r\n        if (this.optionalCharacter(chars.$LPAREN)) {\r\n            this.rparensExpected++;\r\n            const result = this.parsePipe();\r\n            this.rparensExpected--;\r\n            this.expectCharacter(chars.$RPAREN);\r\n            return result;\r\n\r\n        } else if (this.next.isKeywordNull()) {\r\n            this.advance();\r\n            return new LiteralPrimitive(this.span(start), null);\r\n\r\n        } else if (this.next.isKeywordUndefined()) {\r\n            this.advance();\r\n            return new LiteralPrimitive(this.span(start), void 0);\r\n\r\n        } else if (this.next.isKeywordTrue()) {\r\n            this.advance();\r\n            return new LiteralPrimitive(this.span(start), true);\r\n\r\n        } else if (this.next.isKeywordFalse()) {\r\n            this.advance();\r\n            return new LiteralPrimitive(this.span(start), false);\r\n\r\n        } else if (this.next.isKeywordThis()) {\r\n            this.advance();\r\n            return new ImplicitReceiver(this.span(start));\r\n\r\n        } else if (this.optionalCharacter(chars.$LBRACKET)) {\r\n            this.rbracketsExpected++;\r\n            const elements = this.parseExpressionList(chars.$RBRACKET);\r\n            this.rbracketsExpected--;\r\n            this.expectCharacter(chars.$RBRACKET);\r\n            return new LiteralArray(this.span(start), elements);\r\n\r\n        } else if (this.next.isCharacter(chars.$LBRACE)) {\r\n            return this.parseLiteralMap();\r\n\r\n        } else if (this.next.isIdentifier()) {\r\n            return this.parseAccessMemberOrMethodCall(new ImplicitReceiver(this.span(start)), false);\r\n\r\n        } else if (this.next.isNumber()) {\r\n            const value = this.next.toNumber();\r\n            this.advance();\r\n            return new LiteralPrimitive(this.span(start), value);\r\n\r\n        } else if (this.next.isString()) {\r\n            const literalValue = this.next.toString();\r\n            this.advance();\r\n            return new LiteralPrimitive(this.span(start), literalValue);\r\n\r\n        } else if (this.index >= this.tokens.length) {\r\n            this.error(`Unexpected end of expression: ${this.input}`);\r\n            return new EmptyExpr(this.span(start));\r\n        } else {\r\n            this.error(`Unexpected token ${this.next}`);\r\n            return new EmptyExpr(this.span(start));\r\n        }\r\n    }\r\n\r\n    parseExpressionList(terminator: number): AST[] {\r\n        const result: AST[] = [];\r\n        if (!this.next.isCharacter(terminator)) {\r\n            do {\r\n                result.push(this.parsePipe());\r\n            } while (this.optionalCharacter(chars.$COMMA));\r\n        }\r\n        return result;\r\n    }\r\n\r\n    parseLiteralMap(): LiteralMap {\r\n        const keys: string[] = [];\r\n        const values: AST[] = [];\r\n        const start = this.inputIndex;\r\n        this.expectCharacter(chars.$LBRACE);\r\n        if (!this.optionalCharacter(chars.$RBRACE)) {\r\n            this.rbracesExpected++;\r\n            do {\r\n                const key = this.expectIdentifierOrKeywordOrString();\r\n                keys.push(key);\r\n                this.expectCharacter(chars.$COLON);\r\n                values.push(this.parsePipe());\r\n            } while (this.optionalCharacter(chars.$COMMA));\r\n            this.rbracesExpected--;\r\n            this.expectCharacter(chars.$RBRACE);\r\n        }\r\n        return new LiteralMap(this.span(start), keys, values);\r\n    }\r\n\r\n    parseAccessMemberOrMethodCall(receiver: AST, isSafe: boolean = false): AST {\r\n        const start = receiver.span.start;\r\n        const id = this.expectIdentifierOrKeyword();\r\n\r\n        if (this.optionalCharacter(chars.$LPAREN)) {\r\n            this.rparensExpected++;\r\n            const args = this.parseCallArguments();\r\n            this.expectCharacter(chars.$RPAREN);\r\n            this.rparensExpected--;\r\n            const span = this.span(start);\r\n            return isSafe ? new SafeMethodCall(span, receiver, id, args) :\r\n                new MethodCall(span, receiver, id, args);\r\n\r\n        } else {\r\n            if (isSafe) {\r\n                if (this.optionalOperator('=')) {\r\n                    this.error('The \\'?.\\' operator cannot be used in the assignment');\r\n                    return new EmptyExpr(this.span(start));\r\n                } else {\r\n                    return new SafePropertyRead(this.span(start), receiver, id);\r\n                }\r\n            } else {\r\n                if (this.optionalOperator('=')) {\r\n                    if (!this.parseAction) {\r\n                        this.error('Bindings cannot contain assignments');\r\n                        return new EmptyExpr(this.span(start));\r\n                    }\r\n\r\n                    const value = this.parseConditional();\r\n                    return new PropertyWrite(this.span(start), receiver, id, value);\r\n                } else {\r\n                    return new PropertyRead(this.span(start), receiver, id);\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    parseCallArguments(): BindingPipe[] {\r\n        if (this.next.isCharacter(chars.$RPAREN)) return [];\r\n        const positionals: AST[] = [];\r\n        do {\r\n            positionals.push(this.parsePipe());\r\n        } while (this.optionalCharacter(chars.$COMMA));\r\n        return positionals as BindingPipe[];\r\n    }\r\n\r\n    /**\r\n     * An identifier, a keyword, a string with an optional `-` inbetween.\r\n     */\r\n    expectTemplateBindingKey(): string {\r\n        let result = '';\r\n        let operatorFound = false;\r\n        do {\r\n            result += this.expectIdentifierOrKeywordOrString();\r\n            operatorFound = this.optionalOperator('-');\r\n            if (operatorFound) {\r\n                result += '-';\r\n            }\r\n        } while (operatorFound);\r\n\r\n        return result.toString();\r\n    }\r\n\r\n    parseTemplateBindings(): TemplateBindingParseResult {\r\n        const bindings: TemplateBinding[] = [];\r\n        let prefix: string = null;\r\n        const warnings: string[] = [];\r\n        while (this.index < this.tokens.length) {\r\n            const start = this.inputIndex;\r\n            const keyIsVar: boolean = this.peekKeywordLet();\r\n            if (keyIsVar) {\r\n                this.advance();\r\n            }\r\n            let key = this.expectTemplateBindingKey();\r\n            if (!keyIsVar) {\r\n                if (prefix == null) {\r\n                    prefix = key;\r\n                } else {\r\n                    key = prefix + key[0].toUpperCase() + key.substring(1);\r\n                }\r\n            }\r\n            this.optionalCharacter(chars.$COLON);\r\n            let name: string = null;\r\n            let expression: ASTWithSource = null;\r\n            if (keyIsVar) {\r\n                if (this.optionalOperator('=')) {\r\n                    name = this.expectTemplateBindingKey();\r\n                } else {\r\n                    name = '\\$implicit';\r\n                }\r\n            } else if (this.next !== EOF && !this.peekKeywordLet()) {\r\n                const start = this.inputIndex;\r\n                const ast = this.parsePipe();\r\n                const source = this.input.substring(start - this.offset, this.inputIndex - this.offset);\r\n                expression = new ASTWithSource(ast, source, this.location, this.errors);\r\n            }\r\n            bindings.push(new TemplateBinding(this.span(start), key, keyIsVar, name, expression));\r\n            if (!this.optionalCharacter(chars.$SEMICOLON)) {\r\n                this.optionalCharacter(chars.$COMMA);\r\n            }\r\n        }\r\n        return new TemplateBindingParseResult(bindings, warnings, this.errors);\r\n    }\r\n\r\n    error(message: string, index: number = null) {\r\n        this.errors.push(new ParserError(message, this.input, this.locationText(index), this.location));\r\n        this.skip();\r\n    }\r\n\r\n    private locationText(index: number = null) {\r\n        if (isBlank(index)) index = this.index;\r\n        return (index < this.tokens.length) ? `at column ${this.tokens[index].index + 1} in` :\r\n            `at the end of the expression`;\r\n    }\r\n\r\n    // Error recovery should skip tokens until it encounters a recovery point. skip() treats\r\n    // the end of input and a ';' as unconditionally a recovery point. It also treats ')',\r\n    // '}' and ']' as conditional recovery points if one of calling productions is expecting\r\n    // one of these symbols. This allows skip() to recover from errors such as '(a.) + 1' allowing\r\n    // more of the AST to be retained (it doesn't skip any tokens as the ')' is retained because\r\n    // of the '(' begins an '(' <expr> ')' production). The recovery points of grouping symbols\r\n    // must be conditional as they must be skipped if none of the calling productions are not\r\n    // expecting the closing token else we will never make progress in the case of an\r\n    // extraneous group closing symbol (such as a stray ')'). This is not the case for ';' because\r\n    // parseChain() is always the root production and it expects a ';'.\r\n\r\n    // If a production expects one of these token it increments the corresponding nesting count,\r\n    // and then decrements it just prior to checking if the token is in the input.\r\n    private skip() {\r\n        let n = this.next;\r\n        while (this.index < this.tokens.length && !n.isCharacter(chars.$SEMICOLON) &&\r\n        (this.rparensExpected <= 0 || !n.isCharacter(chars.$RPAREN)) &&\r\n        (this.rbracesExpected <= 0 || !n.isCharacter(chars.$RBRACE)) &&\r\n        (this.rbracketsExpected <= 0 || !n.isCharacter(chars.$RBRACKET))) {\r\n            if (this.next.isError()) {\r\n                this.errors.push(\r\n                    new ParserError(this.next.toString(), this.input, this.locationText(), this.location));\r\n            }\r\n            this.advance();\r\n            n = this.next;\r\n        }\r\n    }\r\n}\r\n\r\nclass SimpleExpressionChecker implements AstVisitor {\r\n    static check(ast: AST): string[] {\r\n        const s = new SimpleExpressionChecker();\r\n        ast.visit(s);\r\n        return s.errors;\r\n    }\r\n\r\n    errors: string[] = [];\r\n\r\n    visitImplicitReceiver(ast: ImplicitReceiver, context: any) {}\r\n\r\n    visitInterpolation(ast: Interpolation, context: any) {}\r\n\r\n    visitLiteralPrimitive(ast: LiteralPrimitive, context: any) {}\r\n\r\n    visitPropertyRead(ast: PropertyRead, context: any) {}\r\n\r\n    visitPropertyWrite(ast: PropertyWrite, context: any) {}\r\n\r\n    visitSafePropertyRead(ast: SafePropertyRead, context: any) {}\r\n\r\n    visitMethodCall(ast: MethodCall, context: any) {}\r\n\r\n    visitSafeMethodCall(ast: SafeMethodCall, context: any) {}\r\n\r\n    visitFunctionCall(ast: FunctionCall, context: any) {}\r\n\r\n    visitLiteralArray(ast: LiteralArray, context: any) { this.visitAll(ast.expressions); }\r\n\r\n    visitLiteralMap(ast: LiteralMap, context: any) { this.visitAll(ast.values); }\r\n\r\n    visitBinary(ast: Binary, context: any) {}\r\n\r\n    visitPrefixNot(ast: PrefixNot, context: any) {}\r\n\r\n    visitConditional(ast: Conditional, context: any) {}\r\n\r\n    visitPipe(ast: BindingPipe, context: any) { this.errors.push('pipes'); }\r\n\r\n    visitKeyedRead(ast: KeyedRead, context: any) {}\r\n\r\n    visitKeyedWrite(ast: KeyedWrite, context: any) {}\r\n\r\n    visitAll(asts: any[]): any[] { return asts.map(node => node.visit(this)); }\r\n\r\n    visitChain(ast: Chain, context: any) {}\r\n\r\n    visitQuote(ast: Quote, context: any) {}\r\n}"]}