@angular/language-service 13.0.0-next.3 → 13.0.0-next.7

package/bundles/language-service.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v13.0.0-next.3
+ * @license Angular v13.0.0-next.7
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -819,9 +819,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         key(index, type, sourceSpan) {
             return new ReadKeyExpr(this, index, type, sourceSpan);
         }
-        callMethod(name, params, sourceSpan) {
-            return new InvokeMethodExpr(this, name, params, null, sourceSpan);
-        }
         callFn(params, sourceSpan, pure) {
             return new InvokeFunctionExpr(this, params, null, sourceSpan, pure);
         }
@@ -1023,31 +1020,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         BuiltinMethod[BuiltinMethod["SubscribeObservable"] = 1] = "SubscribeObservable";
         BuiltinMethod[BuiltinMethod["Bind"] = 2] = "Bind";
     })(BuiltinMethod || (BuiltinMethod = {}));
-    class InvokeMethodExpr extends Expression {
-        constructor(receiver, method, args, type, sourceSpan) {
-            super(type, sourceSpan);
-            this.receiver = receiver;
-            this.args = args;
-            if (typeof method === 'string') {
-                this.name = method;
-                this.builtin = null;
-            }
-            else {
-                this.name = null;
-                this.builtin = method;
-            }
-        }
-        isEquivalent(e) {
-            return e instanceof InvokeMethodExpr && this.receiver.isEquivalent(e.receiver) &&
-                this.name === e.name && this.builtin === e.builtin && areAllEquivalent(this.args, e.args);
-        }
-        isConstant() {
-            return false;
-        }
-        visitExpression(visitor, context) {
-            return visitor.visitInvokeMethodExpr(this, context);
-        }
-    }
     class InvokeFunctionExpr extends Expression {
         constructor(fn, args, type, sourceSpan, pure = false) {
             super(type, sourceSpan);
@@ -1917,7 +1889,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             this.visitWriteVarExpr = invalid;
             this.visitWriteKeyExpr = invalid;
             this.visitWritePropExpr = invalid;
-            this.visitInvokeMethodExpr = invalid;
             this.visitInvokeFunctionExpr = invalid;
             this.visitTaggedTemplateExpr = invalid;
             this.visitInstantiateExpr = invalid;
@@ -3993,21 +3964,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             return null;
         }
-        visitInvokeMethodExpr(expr, ctx) {
-            expr.receiver.visitExpression(this, ctx);
-            let name = expr.name;
-            if (expr.builtin != null) {
-                name = this.getBuiltinMethodName(expr.builtin);
-                if (name == null) {
-                    // some builtins just mean to skip the call.
-                    return null;
-                }
-            }
-            ctx.print(expr, `.${name}(`);
-            this.visitAllExpressions(expr.args, ctx, `,`);
-            ctx.print(expr, `)`);
-            return null;
-        }
         visitInvokeFunctionExpr(expr, ctx) {
             expr.fn.visitExpression(this, ctx);
             ctx.print(expr, `(`);
@@ -4646,7 +4602,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         return createFactoryFunction(unwrappedType);
     }
     function createFactoryFunction(type) {
-        return fn([new FnParam('t', DYNAMIC_TYPE)], [new ReturnStatement(type.callMethod('ɵfac', [variable('t')]))]);
+        return fn([new FnParam('t', DYNAMIC_TYPE)], [new ReturnStatement(type.prop('ɵfac').callFn([variable('t')]))]);
     }
 
     /**
@@ -6021,38 +5977,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return visitor.visitNonNullAssert(this, context);
         }
     }
-    class MethodCall extends ASTWithName {
-        constructor(span, sourceSpan, nameSpan, receiver, name, args, argumentSpan) {
-            super(span, sourceSpan, nameSpan);
-            this.receiver = receiver;
-            this.name = name;
-            this.args = args;
-            this.argumentSpan = argumentSpan;
-        }
-        visit(visitor, context = null) {
-            return visitor.visitMethodCall(this, context);
-        }
-    }
-    class SafeMethodCall extends ASTWithName {
-        constructor(span, sourceSpan, nameSpan, receiver, name, args, argumentSpan) {
-            super(span, sourceSpan, nameSpan);
+    class Call extends AST {
+        constructor(span, sourceSpan, receiver, args, argumentSpan) {
+            super(span, sourceSpan);
             this.receiver = receiver;
-            this.name = name;
             this.args = args;
             this.argumentSpan = argumentSpan;
         }
         visit(visitor, context = null) {
-            return visitor.visitSafeMethodCall(this, context);
-        }
-    }
-    class FunctionCall extends AST {
-        constructor(span, sourceSpan, target, args) {
-            super(span, sourceSpan);
-            this.target = target;
-            this.args = args;
-        }
-        visit(visitor, context = null) {
-            return visitor.visitFunctionCall(this, context);
+            return visitor.visitCall(this, context);
         }
     }
     /**
@@ -6138,12 +6071,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             this.visit(ast.exp, context);
             this.visitAll(ast.args, context);
         }
-        visitFunctionCall(ast, context) {
-            if (ast.target) {
-                this.visit(ast.target, context);
-            }
-            this.visitAll(ast.args, context);
-        }
         visitImplicitReceiver(ast, context) { }
         visitThisReceiver(ast, context) { }
         visitInterpolation(ast, context) {
@@ -6165,10 +6092,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             this.visitAll(ast.values, context);
         }
         visitLiteralPrimitive(ast, context) { }
-        visitMethodCall(ast, context) {
-            this.visit(ast.receiver, context);
-            this.visitAll(ast.args, context);
-        }
         visitPrefixNot(ast, context) {
             this.visit(ast.expression, context);
         }
@@ -6185,14 +6108,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         visitSafePropertyRead(ast, context) {
             this.visit(ast.receiver, context);
         }
-        visitSafeMethodCall(ast, context) {
-            this.visit(ast.receiver, context);
-            this.visitAll(ast.args, context);
-        }
         visitSafeKeyedRead(ast, context) {
             this.visit(ast.receiver, context);
             this.visit(ast.key, context);
         }
+        visitCall(ast, context) {
+            this.visit(ast.receiver, context);
+            this.visitAll(ast.args, context);
+        }
         visitQuote(ast, context) { }
         // This is not part of the AstVisitor interface, just a helper method
         visitAll(asts, context) {
@@ -6223,15 +6146,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         visitSafePropertyRead(ast, context) {
             return new SafePropertyRead(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name);
         }
-        visitMethodCall(ast, context) {
-            return new MethodCall(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name, this.visitAll(ast.args), ast.argumentSpan);
-        }
-        visitSafeMethodCall(ast, context) {
-            return new SafeMethodCall(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name, this.visitAll(ast.args), ast.argumentSpan);
-        }
-        visitFunctionCall(ast, context) {
-            return new FunctionCall(ast.span, ast.sourceSpan, ast.target.visit(this), this.visitAll(ast.args));
-        }
         visitLiteralArray(ast, context) {
             return new LiteralArray(ast.span, ast.sourceSpan, this.visitAll(ast.expressions));
         }
@@ -6269,6 +6183,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         visitKeyedWrite(ast, context) {
             return new KeyedWrite(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this), ast.value.visit(this));
         }
+        visitCall(ast, context) {
+            return new Call(ast.span, ast.sourceSpan, ast.receiver.visit(this), this.visitAll(ast.args), ast.argumentSpan);
+        }
         visitAll(asts) {
             const res = [];
             for (let i = 0; i < asts.length; ++i) {
@@ -6326,30 +6243,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             return ast;
         }
-        visitMethodCall(ast, context) {
-            const receiver = ast.receiver.visit(this);
-            const args = this.visitAll(ast.args);
-            if (receiver !== ast.receiver || args !== ast.args) {
-                return new MethodCall(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name, args, ast.argumentSpan);
-            }
-            return ast;
-        }
-        visitSafeMethodCall(ast, context) {
-            const receiver = ast.receiver.visit(this);
-            const args = this.visitAll(ast.args);
-            if (receiver !== ast.receiver || args !== ast.args) {
-                return new SafeMethodCall(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name, args, ast.argumentSpan);
-            }
-            return ast;
-        }
-        visitFunctionCall(ast, context) {
-            const target = ast.target && ast.target.visit(this);
-            const args = this.visitAll(ast.args);
-            if (target !== ast.target || args !== ast.args) {
-                return new FunctionCall(ast.span, ast.sourceSpan, target, args);
-            }
-            return ast;
-        }
         visitLiteralArray(ast, context) {
             const expressions = this.visitAll(ast.expressions);
             if (expressions !== ast.expressions) {
@@ -6452,6 +6345,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             return ast;
         }
+        visitCall(ast, context) {
+            const receiver = ast.receiver.visit(this);
+            const args = this.visitAll(ast.args);
+            if (receiver !== ast.receiver || args !== ast.args) {
+                return new Call(ast.span, ast.sourceSpan, receiver, args, ast.argumentSpan);
+            }
+            return ast;
+        }
         visitQuote(ast, context) {
             return ast;
         }
@@ -6984,18 +6885,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         visitPipe(ast, mode) {
             throw new Error(`Illegal state: Pipes should have been converted into functions. Pipe: ${ast.name}`);
         }
-        visitFunctionCall(ast, mode) {
-            const convertedArgs = this.visitAll(ast.args, _Mode.Expression);
-            let fnResult;
-            if (ast instanceof BuiltinFunctionCall) {
-                fnResult = ast.converter(convertedArgs);
-            }
-            else {
-                fnResult = this._visit(ast.target, _Mode.Expression)
-                    .callFn(convertedArgs, this.convertSourceSpan(ast.span));
-            }
-            return convertToStatementIfNeeded(mode, fnResult);
-        }
         visitImplicitReceiver(ast, mode) {
             ensureExpressionMode(mode, ast);
             this.usesImplicitReceiver = true;
@@ -7060,40 +6949,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             return this._localResolver.getLocal(name);
         }
-        visitMethodCall(ast, mode) {
-            if (ast.receiver instanceof ImplicitReceiver &&
-                !(ast.receiver instanceof ThisReceiver) && ast.name === '$any') {
-                const args = this.visitAll(ast.args, _Mode.Expression);
-                if (args.length != 1) {
-                    throw new Error(`Invalid call to $any, expected 1 argument but received ${args.length || 'none'}`);
-                }
-                return args[0].cast(DYNAMIC_TYPE, this.convertSourceSpan(ast.span));
-            }
-            const leftMostSafe = this.leftMostSafeNode(ast);
-            if (leftMostSafe) {
-                return this.convertSafeAccess(ast, leftMostSafe, mode);
-            }
-            else {
-                const args = this.visitAll(ast.args, _Mode.Expression);
-                const prevUsesImplicitReceiver = this.usesImplicitReceiver;
-                let result = null;
-                const receiver = this._visit(ast.receiver, _Mode.Expression);
-                if (receiver === this._implicitReceiver) {
-                    const varExpr = this._getLocal(ast.name, ast.receiver);
-                    if (varExpr) {
-                        // Restore the previous "usesImplicitReceiver" state since the implicit
-                        // receiver has been replaced with a resolved local expression.
-                        this.usesImplicitReceiver = prevUsesImplicitReceiver;
-                        result = varExpr.callFn(args);
-                        this.addImplicitReceiverAccess(ast.name);
-                    }
-                }
-                if (result == null) {
-                    result = receiver.callMethod(ast.name, args, this.convertSourceSpan(ast.span));
-                }
-                return convertToStatementIfNeeded(mode, result);
-            }
-        }
         visitPrefixNot(ast, mode) {
             return convertToStatementIfNeeded(mode, not(this._visit(ast.expression, _Mode.Expression)));
         }
@@ -7119,7 +6974,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     }
                 }
                 if (result == null) {
-                    result = receiver.prop(ast.name);
+                    result = receiver.prop(ast.name, this.convertSourceSpan(ast.span));
                 }
                 return convertToStatementIfNeeded(mode, result);
             }
@@ -7152,16 +7007,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             // If no local expression could be produced, use the original receiver's
             // property as the target.
             if (varExpr === null) {
-                varExpr = receiver.prop(ast.name);
+                varExpr = receiver.prop(ast.name, this.convertSourceSpan(ast.span));
             }
             return convertToStatementIfNeeded(mode, varExpr.set(this._visit(ast.value, _Mode.Expression)));
         }
         visitSafePropertyRead(ast, mode) {
             return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
         }
-        visitSafeMethodCall(ast, mode) {
-            return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
-        }
         visitSafeKeyedRead(ast, mode) {
             return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
         }
@@ -7172,6 +7024,29 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             throw new Error(`Quotes are not supported for evaluation!
         Statement: ${ast.uninterpretedExpression} located at ${ast.location}`);
         }
+        visitCall(ast, mode) {
+            const convertedArgs = this.visitAll(ast.args, _Mode.Expression);
+            if (ast instanceof BuiltinFunctionCall) {
+                return convertToStatementIfNeeded(mode, ast.converter(convertedArgs));
+            }
+            const receiver = ast.receiver;
+            if (receiver instanceof PropertyRead &&
+                receiver.receiver instanceof ImplicitReceiver &&
+                !(receiver.receiver instanceof ThisReceiver) && receiver.name === '$any') {
+                if (convertedArgs.length !== 1) {
+                    throw new Error(`Invalid call to $any, expected 1 argument but received ${convertedArgs.length || 'none'}`);
+                }
+                return convertedArgs[0]
+                    .cast(DYNAMIC_TYPE, this.convertSourceSpan(ast.span));
+            }
+            const leftMostSafe = this.leftMostSafeNode(ast);
+            if (leftMostSafe) {
+                return this.convertSafeAccess(ast, leftMostSafe, mode);
+            }
+            const call = this._visit(receiver, _Mode.Expression)
+                .callFn(convertedArgs, this.convertSourceSpan(ast.span));
+            return convertToStatementIfNeeded(mode, call);
+        }
         _visit(ast, mode) {
             const result = this._resultMap.get(ast);
             if (result)
@@ -7228,10 +7103,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             const condition = guardedExpression.isBlank();
             // Convert the ast to an unguarded access to the receiver's member. The map will substitute
             // leftMostNode with its unguarded version in the call to `this.visit()`.
-            if (leftMostSafe instanceof SafeMethodCall) {
-                this._nodeMap.set(leftMostSafe, new MethodCall(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan, leftMostSafe.receiver, leftMostSafe.name, leftMostSafe.args, leftMostSafe.argumentSpan));
-            }
-            else if (leftMostSafe instanceof SafeKeyedRead) {
+            if (leftMostSafe instanceof SafeKeyedRead) {
                 this._nodeMap.set(leftMostSafe, new KeyedRead(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.receiver, leftMostSafe.key));
             }
             else {
@@ -7287,8 +7159,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 visitConditional(ast) {
                     return null;
                 },
-                visitFunctionCall(ast) {
-                    return null;
+                visitCall(ast) {
+                    return visit(this, ast.receiver);
                 },
                 visitImplicitReceiver(ast) {
                     return null;
@@ -7314,9 +7186,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 visitLiteralPrimitive(ast) {
                     return null;
                 },
-                visitMethodCall(ast) {
-                    return visit(this, ast.receiver);
-                },
                 visitPipe(ast) {
                     return null;
                 },
@@ -7335,9 +7204,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 visitQuote(ast) {
                     return null;
                 },
-                visitSafeMethodCall(ast) {
-                    return visit(this, ast.receiver) || ast;
-                },
                 visitSafePropertyRead(ast) {
                     return visit(this, ast.receiver) || ast;
                 },
@@ -7369,7 +7235,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 visitConditional(ast) {
                     return visit(this, ast.condition) || visit(this, ast.trueExp) || visit(this, ast.falseExp);
                 },
-                visitFunctionCall(ast) {
+                visitCall(ast) {
                     return true;
                 },
                 visitImplicitReceiver(ast) {
@@ -7396,9 +7262,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 visitLiteralPrimitive(ast) {
                     return false;
                 },
-                visitMethodCall(ast) {
-                    return true;
-                },
                 visitPipe(ast) {
                     return true;
                 },
@@ -7417,9 +7280,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 visitQuote(ast) {
                     return false;
                 },
-                visitSafeMethodCall(ast) {
-                    return true;
-                },
                 visitSafePropertyRead(ast) {
                     return false;
                 },
@@ -7504,9 +7364,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
         return null;
     }
-    class BuiltinFunctionCall extends FunctionCall {
+    class BuiltinFunctionCall extends Call {
         constructor(span, sourceSpan, args, converter) {
-            super(span, sourceSpan, null, args);
+            super(span, sourceSpan, new EmptyExpr(span, sourceSpan), args, null);
             this.converter = converter;
         }
     }
@@ -8086,7 +7946,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     const _polyfillHostRe = /-shadowcsshost/gim;
     const _colonHostRe = /:host/gim;
     const _colonHostContextRe = /:host-context/gim;
-    const _commentRe = /\/\*\s*[\s\S]*?\*\//g;
+    const _commentRe = /\/\*[\s\S]*?\*\//g;
     function stripComments(input) {
         return input.replace(_commentRe, '');
     }
@@ -8677,9 +8537,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
     }
     class Text$2 extends NodeWithI18n {
-        constructor(value, sourceSpan, i18n) {
+        constructor(value, sourceSpan, tokens, i18n) {
             super(sourceSpan, i18n);
             this.value = value;
+            this.tokens = tokens;
         }
         visit(visitor, context) {
             return visitor.visitText(this, context);
@@ -8710,12 +8571,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
     }
     class Attribute extends NodeWithI18n {
-        constructor(name, value, sourceSpan, keySpan, valueSpan, i18n) {
+        constructor(name, value, sourceSpan, keySpan, valueSpan, valueTokens, i18n) {
             super(sourceSpan, i18n);
             this.name = name;
             this.value = value;
             this.keySpan = keySpan;
             this.valueSpan = valueSpan;
+            this.valueTokens = valueTokens;
         }
         visit(visitor, context) {
             return visitor.visitAttribute(this, context);
@@ -10935,38 +10797,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * 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["TAG_OPEN_START"] = 0] = "TAG_OPEN_START";
-        TokenType[TokenType["TAG_OPEN_END"] = 1] = "TAG_OPEN_END";
-        TokenType[TokenType["TAG_OPEN_END_VOID"] = 2] = "TAG_OPEN_END_VOID";
-        TokenType[TokenType["TAG_CLOSE"] = 3] = "TAG_CLOSE";
-        TokenType[TokenType["INCOMPLETE_TAG_OPEN"] = 4] = "INCOMPLETE_TAG_OPEN";
-        TokenType[TokenType["TEXT"] = 5] = "TEXT";
-        TokenType[TokenType["ESCAPABLE_RAW_TEXT"] = 6] = "ESCAPABLE_RAW_TEXT";
-        TokenType[TokenType["RAW_TEXT"] = 7] = "RAW_TEXT";
-        TokenType[TokenType["COMMENT_START"] = 8] = "COMMENT_START";
-        TokenType[TokenType["COMMENT_END"] = 9] = "COMMENT_END";
-        TokenType[TokenType["CDATA_START"] = 10] = "CDATA_START";
-        TokenType[TokenType["CDATA_END"] = 11] = "CDATA_END";
-        TokenType[TokenType["ATTR_NAME"] = 12] = "ATTR_NAME";
-        TokenType[TokenType["ATTR_QUOTE"] = 13] = "ATTR_QUOTE";
-        TokenType[TokenType["ATTR_VALUE"] = 14] = "ATTR_VALUE";
-        TokenType[TokenType["DOC_TYPE"] = 15] = "DOC_TYPE";
-        TokenType[TokenType["EXPANSION_FORM_START"] = 16] = "EXPANSION_FORM_START";
-        TokenType[TokenType["EXPANSION_CASE_VALUE"] = 17] = "EXPANSION_CASE_VALUE";
-        TokenType[TokenType["EXPANSION_CASE_EXP_START"] = 18] = "EXPANSION_CASE_EXP_START";
-        TokenType[TokenType["EXPANSION_CASE_EXP_END"] = 19] = "EXPANSION_CASE_EXP_END";
-        TokenType[TokenType["EXPANSION_FORM_END"] = 20] = "EXPANSION_FORM_END";
-        TokenType[TokenType["EOF"] = 21] = "EOF";
-    })(TokenType || (TokenType = {}));
-    class Token {
-        constructor(type, parts, sourceSpan) {
-            this.type = type;
-            this.parts = parts;
-            this.sourceSpan = sourceSpan;
-        }
-    }
     class TokenError extends ParseError {
         constructor(errorMsg, tokenType, span) {
             super(span, errorMsg);
@@ -11073,14 +10903,16 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                         }
                     }
                     else if (!(this._tokenizeIcu && this._tokenizeExpansionForm())) {
-                        this._consumeText();
+                        // In (possibly interpolated) text the end of the text is given by `isTextEnd()`, while
+                        // the premature end of an interpolation is given by the start of a new HTML element.
+                        this._consumeWithInterpolation(5 /* TEXT */, 8 /* INTERPOLATION */, () => this._isTextEnd(), () => this._isTagStart());
                     }
                 }
                 catch (e) {
                     this.handleError(e);
                 }
             }
-            this._beginToken(TokenType.EOF);
+            this._beginToken(24 /* EOF */);
             this._endToken([]);
         }
         /**
@@ -11119,7 +10951,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             if (this._currentTokenType === null) {
                 throw new TokenError('Programming error - attempted to end a token which has no token type', null, this._cursor.getSpan(this._currentTokenStart));
             }
-            const token = new Token(this._currentTokenType, parts, this._cursor.getSpan(this._currentTokenStart, this._leadingTriviaCodePoints));
+            const token = {
+                type: this._currentTokenType,
+                parts,
+                sourceSpan: (end !== null && end !== void 0 ? end : this._cursor).getSpan(this._currentTokenStart, this._leadingTriviaCodePoints),
+            };
             this.tokens.push(token);
             this._currentTokenStart = null;
             this._currentTokenType = null;
@@ -11212,19 +11048,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 this._cursor.advance();
             }
         }
-        _readChar(decodeEntities) {
-            if (decodeEntities && this._cursor.peek() === $AMPERSAND) {
-                return this._decodeEntity();
-            }
-            else {
-                // Don't rely upon reading directly from `_input` as the actual char value
-                // may have been generated from an escape sequence.
-                const char = String.fromCodePoint(this._cursor.peek());
-                this._cursor.advance();
-                return char;
-            }
+        _readChar() {
+            // Don't rely upon reading directly from `_input` as the actual char value
+            // may have been generated from an escape sequence.
+            const char = String.fromCodePoint(this._cursor.peek());
+            this._cursor.advance();
+            return char;
         }
-        _decodeEntity() {
+        _consumeEntity(textTokenType) {
+            this._beginToken(9 /* ENCODED_ENTITY */);
             const start = this._cursor.clone();
             this._cursor.advance();
             if (this._attemptCharCode($HASH)) {
@@ -11242,7 +11074,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 this._cursor.advance();
                 try {
                     const charCode = parseInt(strNum, isHex ? 16 : 10);
-                    return String.fromCharCode(charCode);
+                    this._endToken([String.fromCharCode(charCode), this._cursor.getChars(start)]);
                 }
                 catch (_a) {
                     throw this._createError(_unknownEntityErrorMsg(this._cursor.getChars(start)), this._cursor.getSpan());
@@ -11252,20 +11084,25 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 const nameStart = this._cursor.clone();
                 this._attemptCharCodeUntilFn(isNamedEntityEnd);
                 if (this._cursor.peek() != $SEMICOLON) {
+                    // No semicolon was found so abort the encoded entity token that was in progress, and treat
+                    // this as a text token
+                    this._beginToken(textTokenType, start);
                     this._cursor = nameStart;
-                    return '&';
+                    this._endToken(['&']);
                 }
-                const name = this._cursor.getChars(nameStart);
-                this._cursor.advance();
-                const char = NAMED_ENTITIES[name];
-                if (!char) {
-                    throw this._createError(_unknownEntityErrorMsg(name), this._cursor.getSpan(start));
+                else {
+                    const name = this._cursor.getChars(nameStart);
+                    this._cursor.advance();
+                    const char = NAMED_ENTITIES[name];
+                    if (!char) {
+                        throw this._createError(_unknownEntityErrorMsg(name), this._cursor.getSpan(start));
+                    }
+                    this._endToken([char, `&${name};`]);
                 }
-                return char;
             }
         }
-        _consumeRawText(decodeEntities, endMarkerPredicate) {
-            this._beginToken(decodeEntities ? TokenType.ESCAPABLE_RAW_TEXT : TokenType.RAW_TEXT);
+        _consumeRawText(consumeEntities, endMarkerPredicate) {
+            this._beginToken(consumeEntities ? 6 /* ESCAPABLE_RAW_TEXT */ : 7 /* RAW_TEXT */);
             const parts = [];
             while (true) {
                 const tagCloseStart = this._cursor.clone();
@@ -11274,30 +11111,38 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 if (foundEndMarker) {
                     break;
                 }
-                parts.push(this._readChar(decodeEntities));
+                if (consumeEntities && this._cursor.peek() === $AMPERSAND) {
+                    this._endToken([this._processCarriageReturns(parts.join(''))]);
+                    parts.length = 0;
+                    this._consumeEntity(6 /* ESCAPABLE_RAW_TEXT */);
+                    this._beginToken(6 /* ESCAPABLE_RAW_TEXT */);
+                }
+                else {
+                    parts.push(this._readChar());
+                }
             }
-            return this._endToken([this._processCarriageReturns(parts.join(''))]);
+            this._endToken([this._processCarriageReturns(parts.join(''))]);
         }
         _consumeComment(start) {
-            this._beginToken(TokenType.COMMENT_START, start);
+            this._beginToken(10 /* COMMENT_START */, start);
             this._requireCharCode($MINUS);
             this._endToken([]);
             this._consumeRawText(false, () => this._attemptStr('-->'));
-            this._beginToken(TokenType.COMMENT_END);
+            this._beginToken(11 /* COMMENT_END */);
             this._requireStr('-->');
             this._endToken([]);
         }
         _consumeCdata(start) {
-            this._beginToken(TokenType.CDATA_START, start);
+            this._beginToken(12 /* CDATA_START */, start);
             this._requireStr('CDATA[');
             this._endToken([]);
             this._consumeRawText(false, () => this._attemptStr(']]>'));
-            this._beginToken(TokenType.CDATA_END);
+            this._beginToken(13 /* CDATA_END */);
             this._requireStr(']]>');
             this._endToken([]);
         }
         _consumeDocType(start) {
-            this._beginToken(TokenType.DOC_TYPE, start);
+            this._beginToken(18 /* DOC_TYPE */, start);
             const contentStart = this._cursor.clone();
             this._attemptUntilChar($GT);
             const content = this._cursor.getChars(contentStart);
@@ -11351,12 +11196,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 if (e instanceof _ControlFlowError) {
                     if (openTagToken) {
                         // We errored before we could close the opening tag, so it is incomplete.
-                        openTagToken.type = TokenType.INCOMPLETE_TAG_OPEN;
+                        openTagToken.type = 4 /* INCOMPLETE_TAG_OPEN */;
                     }
                     else {
                         // When the start tag is invalid, assume we want a "<" as text.
                         // Back to back text tokens are merged at the end.
-                        this._beginToken(TokenType.TEXT, start);
+                        this._beginToken(5 /* TEXT */, start);
                         this._endToken(['<']);
                     }
                     return;
@@ -11371,8 +11216,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 this._consumeRawTextWithTagClose(prefix, tagName, true);
             }
         }
-        _consumeRawTextWithTagClose(prefix, tagName, decodeEntities) {
-            this._consumeRawText(decodeEntities, () => {
+        _consumeRawTextWithTagClose(prefix, tagName, consumeEntities) {
+            this._consumeRawText(consumeEntities, () => {
                 if (!this._attemptCharCode($LT))
                     return false;
                 if (!this._attemptCharCode($SLASH))
@@ -11383,13 +11228,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 this._attemptCharCodeUntilFn(isNotWhitespace);
                 return this._attemptCharCode($GT);
             });
-            this._beginToken(TokenType.TAG_CLOSE);
+            this._beginToken(3 /* TAG_CLOSE */);
             this._requireCharCodeUntilFn(code => code === $GT, 3);
             this._cursor.advance(); // Consume the `>`
             this._endToken([prefix, tagName]);
         }
         _consumeTagOpenStart(start) {
-            this._beginToken(TokenType.TAG_OPEN_START, start);
+            this._beginToken(0 /* TAG_OPEN_START */, start);
             const parts = this._consumePrefixAndName();
             return this._endToken(parts);
         }
@@ -11398,44 +11243,38 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             if (attrNameStart === $SQ || attrNameStart === $DQ) {
                 throw this._createError(_unexpectedCharacterErrorMsg(attrNameStart), this._cursor.getSpan());
             }
-            this._beginToken(TokenType.ATTR_NAME);
+            this._beginToken(14 /* ATTR_NAME */);
             const prefixAndName = this._consumePrefixAndName();
             this._endToken(prefixAndName);
         }
         _consumeAttributeValue() {
-            let value;
             if (this._cursor.peek() === $SQ || this._cursor.peek() === $DQ) {
-                this._beginToken(TokenType.ATTR_QUOTE);
                 const quoteChar = this._cursor.peek();
-                this._cursor.advance();
-                this._endToken([String.fromCodePoint(quoteChar)]);
-                this._beginToken(TokenType.ATTR_VALUE);
-                const parts = [];
-                while (this._cursor.peek() !== quoteChar) {
-                    parts.push(this._readChar(true));
-                }
-                value = parts.join('');
-                this._endToken([this._processCarriageReturns(value)]);
-                this._beginToken(TokenType.ATTR_QUOTE);
-                this._cursor.advance();
-                this._endToken([String.fromCodePoint(quoteChar)]);
+                this._consumeQuote(quoteChar);
+                // In an attribute then end of the attribute value and the premature end to an interpolation
+                // are both triggered by the `quoteChar`.
+                const endPredicate = () => this._cursor.peek() === quoteChar;
+                this._consumeWithInterpolation(16 /* ATTR_VALUE_TEXT */, 17 /* ATTR_VALUE_INTERPOLATION */, endPredicate, endPredicate);
+                this._consumeQuote(quoteChar);
             }
             else {
-                this._beginToken(TokenType.ATTR_VALUE);
-                const valueStart = this._cursor.clone();
-                this._requireCharCodeUntilFn(isNameEnd, 1);
-                value = this._cursor.getChars(valueStart);
-                this._endToken([this._processCarriageReturns(value)]);
+                const endPredicate = () => isNameEnd(this._cursor.peek());
+                this._consumeWithInterpolation(16 /* ATTR_VALUE_TEXT */, 17 /* ATTR_VALUE_INTERPOLATION */, endPredicate, endPredicate);
             }
         }
+        _consumeQuote(quoteChar) {
+            this._beginToken(15 /* ATTR_QUOTE */);
+            this._requireCharCode(quoteChar);
+            this._endToken([String.fromCodePoint(quoteChar)]);
+        }
         _consumeTagOpenEnd() {
-            const tokenType = this._attemptCharCode($SLASH) ? TokenType.TAG_OPEN_END_VOID : TokenType.TAG_OPEN_END;
+            const tokenType = this._attemptCharCode($SLASH) ? 2 /* TAG_OPEN_END_VOID */ : 1 /* TAG_OPEN_END */;
             this._beginToken(tokenType);
             this._requireCharCode($GT);
             this._endToken([]);
         }
         _consumeTagClose(start) {
-            this._beginToken(TokenType.TAG_CLOSE, start);
+            this._beginToken(3 /* TAG_CLOSE */, start);
             this._attemptCharCodeUntilFn(isNotWhitespace);
             const prefixAndName = this._consumePrefixAndName();
             this._attemptCharCodeUntilFn(isNotWhitespace);
@@ -11443,11 +11282,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             this._endToken(prefixAndName);
         }
         _consumeExpansionFormStart() {
-            this._beginToken(TokenType.EXPANSION_FORM_START);
+            this._beginToken(19 /* EXPANSION_FORM_START */);
             this._requireCharCode($LBRACE);
             this._endToken([]);
-            this._expansionCaseStack.push(TokenType.EXPANSION_FORM_START);
-            this._beginToken(TokenType.RAW_TEXT);
+            this._expansionCaseStack.push(19 /* EXPANSION_FORM_START */);
+            this._beginToken(7 /* RAW_TEXT */);
             const condition = this._readUntil($COMMA);
             const normalizedCondition = this._processCarriageReturns(condition);
             if (this._i18nNormalizeLineEndingsInICUs) {
@@ -11463,59 +11302,139 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             this._requireCharCode($COMMA);
             this._attemptCharCodeUntilFn(isNotWhitespace);
-            this._beginToken(TokenType.RAW_TEXT);
+            this._beginToken(7 /* RAW_TEXT */);
             const type = this._readUntil($COMMA);
             this._endToken([type]);
             this._requireCharCode($COMMA);
             this._attemptCharCodeUntilFn(isNotWhitespace);
         }
         _consumeExpansionCaseStart() {
-            this._beginToken(TokenType.EXPANSION_CASE_VALUE);
+            this._beginToken(20 /* EXPANSION_CASE_VALUE */);
             const value = this._readUntil($LBRACE).trim();
             this._endToken([value]);
             this._attemptCharCodeUntilFn(isNotWhitespace);
-            this._beginToken(TokenType.EXPANSION_CASE_EXP_START);
+            this._beginToken(21 /* EXPANSION_CASE_EXP_START */);
             this._requireCharCode($LBRACE);
             this._endToken([]);
             this._attemptCharCodeUntilFn(isNotWhitespace);
-            this._expansionCaseStack.push(TokenType.EXPANSION_CASE_EXP_START);
+            this._expansionCaseStack.push(21 /* EXPANSION_CASE_EXP_START */);
         }
         _consumeExpansionCaseEnd() {
-            this._beginToken(TokenType.EXPANSION_CASE_EXP_END);
+            this._beginToken(22 /* EXPANSION_CASE_EXP_END */);
             this._requireCharCode($RBRACE);
             this._endToken([]);
             this._attemptCharCodeUntilFn(isNotWhitespace);
             this._expansionCaseStack.pop();
         }
         _consumeExpansionFormEnd() {
-            this._beginToken(TokenType.EXPANSION_FORM_END);
+            this._beginToken(23 /* EXPANSION_FORM_END */);
             this._requireCharCode($RBRACE);
             this._endToken([]);
             this._expansionCaseStack.pop();
         }
-        _consumeText() {
-            const start = this._cursor.clone();
-            this._beginToken(TokenType.TEXT, start);
+        /**
+         * Consume a string that may contain interpolation expressions.
+         *
+         * The first token consumed will be of `tokenType` and then there will be alternating
+         * `interpolationTokenType` and `tokenType` tokens until the `endPredicate()` returns true.
+         *
+         * If an interpolation token ends prematurely it will have no end marker in its `parts` array.
+         *
+         * @param textTokenType the kind of tokens to interleave around interpolation tokens.
+         * @param interpolationTokenType the kind of tokens that contain interpolation.
+         * @param endPredicate a function that should return true when we should stop consuming.
+         * @param endInterpolation a function that should return true if there is a premature end to an
+         *     interpolation expression - i.e. before we get to the normal interpolation closing marker.
+         */
+        _consumeWithInterpolation(textTokenType, interpolationTokenType, endPredicate, endInterpolation) {
+            this._beginToken(textTokenType);
             const parts = [];
-            do {
+            while (!endPredicate()) {
+                const current = this._cursor.clone();
                 if (this._interpolationConfig && this._attemptStr(this._interpolationConfig.start)) {
-                    parts.push(this._interpolationConfig.start);
-                    this._inInterpolation = true;
+                    this._endToken([this._processCarriageReturns(parts.join(''))], current);
+                    parts.length = 0;
+                    this._consumeInterpolation(interpolationTokenType, current, endInterpolation);
+                    this._beginToken(textTokenType);
                 }
-                else if (this._interpolationConfig && this._inInterpolation &&
-                    this._attemptStr(this._interpolationConfig.end)) {
-                    parts.push(this._interpolationConfig.end);
-                    this._inInterpolation = false;
+                else if (this._cursor.peek() === $AMPERSAND) {
+                    this._endToken([this._processCarriageReturns(parts.join(''))]);
+                    parts.length = 0;
+                    this._consumeEntity(textTokenType);
+                    this._beginToken(textTokenType);
                 }
                 else {
-                    parts.push(this._readChar(true));
+                    parts.push(this._readChar());
                 }
-            } while (!this._isTextEnd());
+            }
             // It is possible that an interpolation was started but not ended inside this text token.
             // Make sure that we reset the state of the lexer correctly.
             this._inInterpolation = false;
             this._endToken([this._processCarriageReturns(parts.join(''))]);
         }
+        /**
+         * Consume a block of text that has been interpreted as an Angular interpolation.
+         *
+         * @param interpolationTokenType the type of the interpolation token to generate.
+         * @param interpolationStart a cursor that points to the start of this interpolation.
+         * @param prematureEndPredicate a function that should return true if the next characters indicate
+         *     an end to the interpolation before its normal closing marker.
+         */
+        _consumeInterpolation(interpolationTokenType, interpolationStart, prematureEndPredicate) {
+            const parts = [];
+            this._beginToken(interpolationTokenType, interpolationStart);
+            parts.push(this._interpolationConfig.start);
+            // Find the end of the interpolation, ignoring content inside quotes.
+            const expressionStart = this._cursor.clone();
+            let inQuote = null;
+            let inComment = false;
+            while (this._cursor.peek() !== $EOF &&
+                (prematureEndPredicate === null || !prematureEndPredicate())) {
+                const current = this._cursor.clone();
+                if (this._isTagStart()) {
+                    // We are starting what looks like an HTML element in the middle of this interpolation.
+                    // Reset the cursor to before the `<` character and end the interpolation token.
+                    // (This is actually wrong but here for backward compatibility).
+                    this._cursor = current;
+                    parts.push(this._getProcessedChars(expressionStart, current));
+                    this._endToken(parts);
+                    return;
+                }
+                if (inQuote === null) {
+                    if (this._attemptStr(this._interpolationConfig.end)) {
+                        // We are not in a string, and we hit the end interpolation marker
+                        parts.push(this._getProcessedChars(expressionStart, current));
+                        parts.push(this._interpolationConfig.end);
+                        this._endToken(parts);
+                        return;
+                    }
+                    else if (this._attemptStr('//')) {
+                        // Once we are in a comment we ignore any quotes
+                        inComment = true;
+                    }
+                }
+                const char = this._cursor.peek();
+                this._cursor.advance();
+                if (char === $BACKSLASH) {
+                    // Skip the next character because it was escaped.
+                    this._cursor.advance();
+                }
+                else if (char === inQuote) {
+                    // Exiting the current quoted string
+                    inQuote = null;
+                }
+                else if (!inComment && inQuote === null && isQuote(char)) {
+                    // Entering a new quoted string
+                    inQuote = char;
+                }
+            }
+            // We hit EOF without finding a closing interpolation marker
+            parts.push(this._getProcessedChars(expressionStart, this._cursor));
+            this._endToken(parts);
+        }
+        _getProcessedChars(start, end) {
+            return this._processCarriageReturns(end.getChars(start));
+        }
         _isTextEnd() {
             if (this._isTagStart() || this._cursor.peek() === $EOF) {
                 return true;
@@ -11558,12 +11477,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         _isInExpansionCase() {
             return this._expansionCaseStack.length > 0 &&
                 this._expansionCaseStack[this._expansionCaseStack.length - 1] ===
-                    TokenType.EXPANSION_CASE_EXP_START;
+                    21 /* EXPANSION_CASE_EXP_START */;
         }
         _isInExpansionForm() {
             return this._expansionCaseStack.length > 0 &&
                 this._expansionCaseStack[this._expansionCaseStack.length - 1] ===
-                    TokenType.EXPANSION_FORM_START;
+                    19 /* EXPANSION_FORM_START */;
         }
         isExpansionFormStart() {
             if (this._cursor.peek() !== $LBRACE) {
@@ -11610,7 +11529,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         let lastDstToken = undefined;
         for (let i = 0; i < srcTokens.length; i++) {
             const token = srcTokens[i];
-            if (lastDstToken && lastDstToken.type === TokenType.TEXT && token.type === TokenType.TEXT) {
+            if ((lastDstToken && lastDstToken.type === 5 /* TEXT */ && token.type === 5 /* TEXT */) ||
+                (lastDstToken && lastDstToken.type === 16 /* ATTR_VALUE_TEXT */ &&
+                    token.type === 16 /* ATTR_VALUE_TEXT */)) {
                 lastDstToken.parts[0] += token.parts[0];
                 lastDstToken.sourceSpan.end = token.sourceSpan.end;
             }
@@ -11903,28 +11824,28 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             this._advance();
         }
         build() {
-            while (this._peek.type !== TokenType.EOF) {
-                if (this._peek.type === TokenType.TAG_OPEN_START ||
-                    this._peek.type === TokenType.INCOMPLETE_TAG_OPEN) {
+            while (this._peek.type !== 24 /* EOF */) {
+                if (this._peek.type === 0 /* TAG_OPEN_START */ ||
+                    this._peek.type === 4 /* INCOMPLETE_TAG_OPEN */) {
                     this._consumeStartTag(this._advance());
                 }
-                else if (this._peek.type === TokenType.TAG_CLOSE) {
+                else if (this._peek.type === 3 /* TAG_CLOSE */) {
                     this._consumeEndTag(this._advance());
                 }
-                else if (this._peek.type === TokenType.CDATA_START) {
+                else if (this._peek.type === 12 /* CDATA_START */) {
                     this._closeVoidElement();
                     this._consumeCdata(this._advance());
                 }
-                else if (this._peek.type === TokenType.COMMENT_START) {
+                else if (this._peek.type === 10 /* COMMENT_START */) {
                     this._closeVoidElement();
                     this._consumeComment(this._advance());
                 }
-                else if (this._peek.type === TokenType.TEXT || this._peek.type === TokenType.RAW_TEXT ||
-                    this._peek.type === TokenType.ESCAPABLE_RAW_TEXT) {
+                else if (this._peek.type === 5 /* TEXT */ || this._peek.type === 7 /* RAW_TEXT */ ||
+                    this._peek.type === 6 /* ESCAPABLE_RAW_TEXT */) {
                     this._closeVoidElement();
                     this._consumeText(this._advance());
                 }
-                else if (this._peek.type === TokenType.EXPANSION_FORM_START) {
+                else if (this._peek.type === 19 /* EXPANSION_FORM_START */) {
                     this._consumeExpansion(this._advance());
                 }
                 else {
@@ -11950,11 +11871,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
         _consumeCdata(_startToken) {
             this._consumeText(this._advance());
-            this._advanceIf(TokenType.CDATA_END);
+            this._advanceIf(13 /* CDATA_END */);
         }
         _consumeComment(token) {
-            const text = this._advanceIf(TokenType.RAW_TEXT);
-            this._advanceIf(TokenType.COMMENT_END);
+            const text = this._advanceIf(7 /* RAW_TEXT */);
+            this._advanceIf(11 /* COMMENT_END */);
             const value = text != null ? text.parts[0].trim() : null;
             this._addToParent(new Comment$1(value, token.sourceSpan));
         }
@@ -11963,14 +11884,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             const type = this._advance();
             const cases = [];
             // read =
-            while (this._peek.type === TokenType.EXPANSION_CASE_VALUE) {
+            while (this._peek.type === 20 /* EXPANSION_CASE_VALUE */) {
                 const expCase = this._parseExpansionCase();
                 if (!expCase)
                     return; // error
                 cases.push(expCase);
             }
             // read the final }
-            if (this._peek.type !== TokenType.EXPANSION_FORM_END) {
+            if (this._peek.type !== 23 /* EXPANSION_FORM_END */) {
                 this.errors.push(TreeError.create(null, this._peek.sourceSpan, `Invalid ICU message. Missing '}'.`));
                 return;
             }
@@ -11981,7 +11902,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         _parseExpansionCase() {
             const value = this._advance();
             // read {
-            if (this._peek.type !== TokenType.EXPANSION_CASE_EXP_START) {
+            if (this._peek.type !== 21 /* EXPANSION_CASE_EXP_START */) {
                 this.errors.push(TreeError.create(null, this._peek.sourceSpan, `Invalid ICU message. Missing '{'.`));
                 return null;
             }
@@ -11991,7 +11912,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             if (!exp)
                 return null;
             const end = this._advance();
-            exp.push(new Token(TokenType.EOF, [], end.sourceSpan));
+            exp.push({ type: 24 /* EOF */, parts: [], sourceSpan: end.sourceSpan });
             // parse everything in between { and }
             const expansionCaseParser = new _TreeBuilder(exp, this.getTagDefinition);
             expansionCaseParser.build();
@@ -12005,14 +11926,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
         _collectExpansionExpTokens(start) {
             const exp = [];
-            const expansionFormStack = [TokenType.EXPANSION_CASE_EXP_START];
+            const expansionFormStack = [21 /* EXPANSION_CASE_EXP_START */];
             while (true) {
-                if (this._peek.type === TokenType.EXPANSION_FORM_START ||
-                    this._peek.type === TokenType.EXPANSION_CASE_EXP_START) {
+                if (this._peek.type === 19 /* EXPANSION_FORM_START */ ||
+                    this._peek.type === 21 /* EXPANSION_CASE_EXP_START */) {
                     expansionFormStack.push(this._peek.type);
                 }
-                if (this._peek.type === TokenType.EXPANSION_CASE_EXP_END) {
-                    if (lastOnStack(expansionFormStack, TokenType.EXPANSION_CASE_EXP_START)) {
+                if (this._peek.type === 22 /* EXPANSION_CASE_EXP_END */) {
+                    if (lastOnStack(expansionFormStack, 21 /* EXPANSION_CASE_EXP_START */)) {
                         expansionFormStack.pop();
                         if (expansionFormStack.length === 0)
                             return exp;
@@ -12022,8 +11943,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                         return null;
                     }
                 }
-                if (this._peek.type === TokenType.EXPANSION_FORM_END) {
-                    if (lastOnStack(expansionFormStack, TokenType.EXPANSION_FORM_START)) {
+                if (this._peek.type === 23 /* EXPANSION_FORM_END */) {
+                    if (lastOnStack(expansionFormStack, 19 /* EXPANSION_FORM_START */)) {
                         expansionFormStack.pop();
                     }
                     else {
@@ -12031,7 +11952,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                         return null;
                     }
                 }
-                if (this._peek.type === TokenType.EOF) {
+                if (this._peek.type === 24 /* EOF */) {
                     this.errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
                     return null;
                 }
@@ -12039,16 +11960,38 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
         }
         _consumeText(token) {
+            const tokens = [token];
+            const startSpan = token.sourceSpan;
             let text = token.parts[0];
             if (text.length > 0 && text[0] === '\n') {
                 const parent = this._getParentElement();
                 if (parent != null && parent.children.length === 0 &&
                     this.getTagDefinition(parent.name).ignoreFirstLf) {
                     text = text.substring(1);
+                    tokens[0] = { type: token.type, sourceSpan: token.sourceSpan, parts: [text] };
+                }
+            }
+            while (this._peek.type === 8 /* INTERPOLATION */ || this._peek.type === 5 /* TEXT */ ||
+                this._peek.type === 9 /* ENCODED_ENTITY */) {
+                token = this._advance();
+                tokens.push(token);
+                if (token.type === 8 /* INTERPOLATION */) {
+                    // For backward compatibility we decode HTML entities that appear in interpolation
+                    // expressions. This is arguably a bug, but it could be a considerable breaking change to
+                    // fix it. It should be addressed in a larger project to refactor the entire parser/lexer
+                    // chain after View Engine has been removed.
+                    text += token.parts.join('').replace(/&([^;]+);/g, decodeEntity);
+                }
+                else if (token.type === 9 /* ENCODED_ENTITY */) {
+                    text += token.parts[0];
+                }
+                else {
+                    text += token.parts.join('');
                 }
             }
             if (text.length > 0) {
-                this._addToParent(new Text$2(text, token.sourceSpan));
+                const endSpan = token.sourceSpan;
+                this._addToParent(new Text$2(text, new ParseSourceSpan(startSpan.start, endSpan.end, startSpan.fullStart, startSpan.details), tokens));
             }
         }
         _closeVoidElement() {
@@ -12060,14 +12003,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         _consumeStartTag(startTagToken) {
             const [prefix, name] = startTagToken.parts;
             const attrs = [];
-            while (this._peek.type === TokenType.ATTR_NAME) {
+            while (this._peek.type === 14 /* ATTR_NAME */) {
                 attrs.push(this._consumeAttr(this._advance()));
             }
             const fullName = this._getElementFullName(prefix, name, this._getParentElement());
             let selfClosing = false;
             // Note: There could have been a tokenizer error
             // so that we don't get a token for the end tag...
-            if (this._peek.type === TokenType.TAG_OPEN_END_VOID) {
+            if (this._peek.type === 2 /* TAG_OPEN_END_VOID */) {
                 this._advance();
                 selfClosing = true;
                 const tagDef = this.getTagDefinition(fullName);
@@ -12075,7 +12018,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     this.errors.push(TreeError.create(fullName, startTagToken.sourceSpan, `Only void and foreign elements can be self closed "${startTagToken.parts[1]}"`));
                 }
             }
-            else if (this._peek.type === TokenType.TAG_OPEN_END) {
+            else if (this._peek.type === 1 /* TAG_OPEN_END */) {
                 this._advance();
                 selfClosing = false;
             }
@@ -12090,7 +12033,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 // element start tag also represents the end tag.
                 this._popElement(fullName, span);
             }
-            else if (startTagToken.type === TokenType.INCOMPLETE_TAG_OPEN) {
+            else if (startTagToken.type === 4 /* INCOMPLETE_TAG_OPEN */) {
                 // We already know the opening tag is not complete, so it is unlikely it has a corresponding
                 // close tag. Let's optimistically parse it as a full element and emit an error.
                 this._popElement(fullName, null);
@@ -12145,24 +12088,53 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
         _consumeAttr(attrName) {
             const fullName = mergeNsAndName(attrName.parts[0], attrName.parts[1]);
-            let end = attrName.sourceSpan.end;
-            let value = '';
-            let valueSpan = undefined;
-            if (this._peek.type === TokenType.ATTR_QUOTE) {
+            let attrEnd = attrName.sourceSpan.end;
+            // Consume any quote
+            if (this._peek.type === 15 /* ATTR_QUOTE */) {
                 this._advance();
             }
-            if (this._peek.type === TokenType.ATTR_VALUE) {
-                const valueToken = this._advance();
-                value = valueToken.parts[0];
-                end = valueToken.sourceSpan.end;
-                valueSpan = valueToken.sourceSpan;
+            // Consume the attribute value
+            let value = '';
+            const valueTokens = [];
+            let valueStartSpan = undefined;
+            let valueEnd = undefined;
+            // NOTE: We need to use a new variable `nextTokenType` here to hide the actual type of
+            // `_peek.type` from TS. Otherwise TS will narrow the type of `_peek.type` preventing it from
+            // being able to consider `ATTR_VALUE_INTERPOLATION` as an option. This is because TS is not
+            // able to see that `_advance()` will actually mutate `_peek`.
+            const nextTokenType = this._peek.type;
+            if (nextTokenType === 16 /* ATTR_VALUE_TEXT */) {
+                valueStartSpan = this._peek.sourceSpan;
+                valueEnd = this._peek.sourceSpan.end;
+                while (this._peek.type === 16 /* ATTR_VALUE_TEXT */ ||
+                    this._peek.type === 17 /* ATTR_VALUE_INTERPOLATION */ ||
+                    this._peek.type === 9 /* ENCODED_ENTITY */) {
+                    const valueToken = this._advance();
+                    valueTokens.push(valueToken);
+                    if (valueToken.type === 17 /* ATTR_VALUE_INTERPOLATION */) {
+                        // For backward compatibility we decode HTML entities that appear in interpolation
+                        // expressions. This is arguably a bug, but it could be a considerable breaking change to
+                        // fix it. It should be addressed in a larger project to refactor the entire parser/lexer
+                        // chain after View Engine has been removed.
+                        value += valueToken.parts.join('').replace(/&([^;]+);/g, decodeEntity);
+                    }
+                    else if (valueToken.type === 9 /* ENCODED_ENTITY */) {
+                        value += valueToken.parts[0];
+                    }
+                    else {
+                        value += valueToken.parts.join('');
+                    }
+                    valueEnd = attrEnd = valueToken.sourceSpan.end;
+                }
             }
-            if (this._peek.type === TokenType.ATTR_QUOTE) {
+            // Consume any quote
+            if (this._peek.type === 15 /* ATTR_QUOTE */) {
                 const quoteToken = this._advance();
-                end = quoteToken.sourceSpan.end;
+                attrEnd = quoteToken.sourceSpan.end;
             }
-            const keySpan = new ParseSourceSpan(attrName.sourceSpan.start, attrName.sourceSpan.end);
-            return new Attribute(fullName, value, new ParseSourceSpan(attrName.sourceSpan.start, end, attrName.sourceSpan.fullStart), keySpan, valueSpan);
+            const valueSpan = valueStartSpan && valueEnd &&
+                new ParseSourceSpan(valueStartSpan.start, valueEnd, valueStartSpan.fullStart);
+            return new Attribute(fullName, value, new ParseSourceSpan(attrName.sourceSpan.start, attrEnd, attrName.sourceSpan.fullStart), attrName.sourceSpan, valueSpan, valueTokens.length > 0 ? valueTokens : undefined, undefined);
         }
         _getParentElement() {
             return this._elementStack.length > 0 ? this._elementStack[this._elementStack.length - 1] : null;
@@ -12193,6 +12165,23 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     function lastOnStack(stack, element) {
         return stack.length > 0 && stack[stack.length - 1] === element;
     }
+    /**
+     * Decode the `entity` string, which we believe is the contents of an HTML entity.
+     *
+     * If the string is not actually a valid/known entity then just return the original `match` string.
+     */
+    function decodeEntity(match, entity) {
+        if (NAMED_ENTITIES[entity] !== undefined) {
+            return NAMED_ENTITIES[entity] || match;
+        }
+        if (/^#x[a-f0-9]+$/i.test(entity)) {
+            return String.fromCodePoint(parseInt(entity.slice(2), 16));
+        }
+        if (/^#\d+$/.test(entity)) {
+            return String.fromCodePoint(parseInt(entity.slice(1), 10));
+        }
+        return match;
+    }
 
     /**
      * @license
@@ -12268,7 +12257,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             const hasExpansionSibling = context &&
                 (context.prev instanceof Expansion || context.next instanceof Expansion);
             if (isNotBlank || hasExpansionSibling) {
-                return new Text$2(replaceNgsp(text.value).replace(WS_REPLACE_REGEXP, ' '), text.sourceSpan, text.i18n);
+                // Process the whitespace in the tokens of this Text node
+                const tokens = text.tokens.map(token => token.type === 5 /* TEXT */ ? createWhitespaceProcessedTextToken(token) : token);
+                // Process the whitespace of the value of this Text node
+                const value = processWhitespace(text.value);
+                return new Text$2(value, text.sourceSpan, tokens, text.i18n);
             }
             return null;
         }
@@ -12282,6 +12275,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return expansionCase;
         }
     }
+    function createWhitespaceProcessedTextToken({ type, parts, sourceSpan }) {
+        return { type, parts: [processWhitespace(parts[0])], sourceSpan };
+    }
+    function processWhitespace(text) {
+        return replaceNgsp(text).replace(WS_REPLACE_REGEXP, ' ');
+    }
     function removeWhitespaces(htmlAstWithErrors) {
         return new ParseTreeResult(visitAll$1(new WhitespaceVisitor(), htmlAstWithErrors.rootNodes), htmlAstWithErrors.errors);
     }
@@ -12384,9 +12383,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             const expansionResult = expandNodes(c.expression);
             errors.push(...expansionResult.errors);
-            return new Element$1(`ng-template`, [new Attribute('ngPluralCase', `${c.value}`, c.valueSourceSpan, undefined /* keySpan */, undefined /* valueSpan */, undefined /* i18n */)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);
+            return new Element$1(`ng-template`, [new Attribute('ngPluralCase', `${c.value}`, c.valueSourceSpan, undefined /* keySpan */, undefined /* valueSpan */, undefined /* valueTokens */, undefined /* i18n */)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);
         });
-        const switchAttr = new Attribute('[ngPlural]', ast.switchValue, ast.switchValueSourceSpan, undefined /* keySpan */, undefined /* valueSpan */, undefined /* i18n */);
+        const switchAttr = new Attribute('[ngPlural]', ast.switchValue, ast.switchValueSourceSpan, undefined /* keySpan */, undefined /* valueSpan */, undefined /* valueTokens */, undefined /* i18n */);
         return new Element$1('ng-container', [switchAttr], children, ast.sourceSpan, ast.sourceSpan, ast.sourceSpan);
     }
     // ICU messages (excluding plural form) are expanded to `NgSwitch`  and `NgSwitchCase`s
@@ -12396,11 +12395,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             errors.push(...expansionResult.errors);
             if (c.value === 'other') {
                 // other is the default case when no values match
-                return new Element$1(`ng-template`, [new Attribute('ngSwitchDefault', '', c.valueSourceSpan, undefined /* keySpan */, undefined /* valueSpan */, undefined /* i18n */)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);
+                return new Element$1(`ng-template`, [new Attribute('ngSwitchDefault', '', c.valueSourceSpan, undefined /* keySpan */, undefined /* valueSpan */, undefined /* valueTokens */, undefined /* i18n */)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);
             }
-            return new Element$1(`ng-template`, [new Attribute('ngSwitchCase', `${c.value}`, c.valueSourceSpan, undefined /* keySpan */, undefined /* valueSpan */, undefined /* i18n */)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);
+            return new Element$1(`ng-template`, [new Attribute('ngSwitchCase', `${c.value}`, c.valueSourceSpan, undefined /* keySpan */, undefined /* valueSpan */, undefined /* valueTokens */, undefined /* i18n */)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);
         });
-        const switchAttr = new Attribute('[ngSwitch]', ast.switchValue, ast.switchValueSourceSpan, undefined /* keySpan */, undefined /* valueSpan */, undefined /* i18n */);
+        const switchAttr = new Attribute('[ngSwitch]', ast.switchValue, ast.switchValueSourceSpan, undefined /* keySpan */, undefined /* valueSpan */, undefined /* valueTokens */, undefined /* i18n */);
         return new Element$1('ng-container', [switchAttr], children, ast.sourceSpan, ast.sourceSpan, ast.sourceSpan);
     }
 
@@ -15018,7 +15017,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * 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$1;
+    var TokenType;
     (function (TokenType) {
         TokenType[TokenType["Character"] = 0] = "Character";
         TokenType[TokenType["Identifier"] = 1] = "Identifier";
@@ -15028,7 +15027,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         TokenType[TokenType["Operator"] = 5] = "Operator";
         TokenType[TokenType["Number"] = 6] = "Number";
         TokenType[TokenType["Error"] = 7] = "Error";
-    })(TokenType$1 || (TokenType$1 = {}));
+    })(TokenType || (TokenType = {}));
     const KEYWORDS = ['var', 'let', 'as', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this'];
     class Lexer {
         tokenize(text) {
@@ -15042,7 +15041,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return tokens;
         }
     }
-    class Token$1 {
+    class Token {
         constructor(index, end, type, numValue, strValue) {
             this.index = index;
             this.end = end;
@@ -15051,64 +15050,64 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             this.strValue = strValue;
         }
         isCharacter(code) {
-            return this.type == TokenType$1.Character && this.numValue == code;
+            return this.type == TokenType.Character && this.numValue == code;
         }
         isNumber() {
-            return this.type == TokenType$1.Number;
+            return this.type == TokenType.Number;
         }
         isString() {
-            return this.type == TokenType$1.String;
+            return this.type == TokenType.String;
         }
         isOperator(operator) {
-            return this.type == TokenType$1.Operator && this.strValue == operator;
+            return this.type == TokenType.Operator && this.strValue == operator;
         }
         isIdentifier() {
-            return this.type == TokenType$1.Identifier;
+            return this.type == TokenType.Identifier;
         }
         isPrivateIdentifier() {
-            return this.type == TokenType$1.PrivateIdentifier;
+            return this.type == TokenType.PrivateIdentifier;
         }
         isKeyword() {
-            return this.type == TokenType$1.Keyword;
+            return this.type == TokenType.Keyword;
         }
         isKeywordLet() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'let';
+            return this.type == TokenType.Keyword && this.strValue == 'let';
         }
         isKeywordAs() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'as';
+            return this.type == TokenType.Keyword && this.strValue == 'as';
         }
         isKeywordNull() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'null';
+            return this.type == TokenType.Keyword && this.strValue == 'null';
         }
         isKeywordUndefined() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'undefined';
+            return this.type == TokenType.Keyword && this.strValue == 'undefined';
         }
         isKeywordTrue() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'true';
+            return this.type == TokenType.Keyword && this.strValue == 'true';
         }
         isKeywordFalse() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'false';
+            return this.type == TokenType.Keyword && this.strValue == 'false';
         }
         isKeywordThis() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'this';
+            return this.type == TokenType.Keyword && this.strValue == 'this';
         }
         isError() {
-            return this.type == TokenType$1.Error;
+            return this.type == TokenType.Error;
         }
         toNumber() {
-            return this.type == TokenType$1.Number ? this.numValue : -1;
+            return this.type == TokenType.Number ? this.numValue : -1;
         }
         toString() {
             switch (this.type) {
-                case TokenType$1.Character:
-                case TokenType$1.Identifier:
-                case TokenType$1.Keyword:
-                case TokenType$1.Operator:
-                case TokenType$1.PrivateIdentifier:
-                case TokenType$1.String:
-                case TokenType$1.Error:
+                case TokenType.Character:
+                case TokenType.Identifier:
+                case TokenType.Keyword:
+                case TokenType.Operator:
+                case TokenType.PrivateIdentifier:
+                case TokenType.String:
+                case TokenType.Error:
                     return this.strValue;
-                case TokenType$1.Number:
+                case TokenType.Number:
                     return this.numValue.toString();
                 default:
                     return null;
@@ -15116,30 +15115,30 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
     }
     function newCharacterToken(index, end, code) {
-        return new Token$1(index, end, TokenType$1.Character, code, String.fromCharCode(code));
+        return new Token(index, end, TokenType.Character, code, String.fromCharCode(code));
     }
     function newIdentifierToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.Identifier, 0, text);
+        return new Token(index, end, TokenType.Identifier, 0, text);
     }
     function newPrivateIdentifierToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.PrivateIdentifier, 0, text);
+        return new Token(index, end, TokenType.PrivateIdentifier, 0, text);
     }
     function newKeywordToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.Keyword, 0, text);
+        return new Token(index, end, TokenType.Keyword, 0, text);
     }
     function newOperatorToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.Operator, 0, text);
+        return new Token(index, end, TokenType.Operator, 0, text);
     }
     function newStringToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.String, 0, text);
+        return new Token(index, end, TokenType.String, 0, text);
     }
     function newNumberToken(index, end, n) {
-        return new Token$1(index, end, TokenType$1.Number, n, '');
+        return new Token(index, end, TokenType.Number, n, '');
     }
     function newErrorToken(index, end, message) {
-        return new Token$1(index, end, TokenType$1.Error, 0, message);
+        return new Token(index, end, TokenType.Error, 0, message);
     }
-    const EOF = new Token$1(-1, -1, TokenType$1.Character, 0, '');
+    const EOF = new Token(-1, -1, TokenType.Character, 0, '');
     class _Scanner {
         constructor(input) {
             this.input = input;
@@ -16046,7 +16045,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             // '==','!=','===','!=='
             const start = this.inputIndex;
             let result = this.parseRelational();
-            while (this.next.type == TokenType$1.Operator) {
+            while (this.next.type == TokenType.Operator) {
                 const operator = this.next.strValue;
                 switch (operator) {
                     case '==':
@@ -16066,7 +16065,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             // '<', '>', '<=', '>='
             const start = this.inputIndex;
             let result = this.parseAdditive();
-            while (this.next.type == TokenType$1.Operator) {
+            while (this.next.type == TokenType.Operator) {
                 const operator = this.next.strValue;
                 switch (operator) {
                     case '<':
@@ -16086,7 +16085,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             // '+', '-'
             const start = this.inputIndex;
             let result = this.parseMultiplicative();
-            while (this.next.type == TokenType$1.Operator) {
+            while (this.next.type == TokenType.Operator) {
                 const operator = this.next.strValue;
                 switch (operator) {
                     case '+':
@@ -16104,7 +16103,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             // '*', '%', '/'
             const start = this.inputIndex;
             let result = this.parsePrefix();
-            while (this.next.type == TokenType$1.Operator) {
+            while (this.next.type == TokenType.Operator) {
                 const operator = this.next.strValue;
                 switch (operator) {
                     case '*':
@@ -16120,7 +16119,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return result;
         }
         parsePrefix() {
-            if (this.next.type == TokenType$1.Operator) {
+            if (this.next.type == TokenType.Operator) {
                 const start = this.inputIndex;
                 const operator = this.next.strValue;
                 let result;
@@ -16146,22 +16145,24 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             let result = this.parsePrimary();
             while (true) {
                 if (this.consumeOptionalCharacter($PERIOD)) {
-                    result = this.parseAccessMemberOrMethodCall(result, start, false);
+                    result = this.parseAccessMemberOrCall(result, start, false);
                 }
                 else if (this.consumeOptionalOperator('?.')) {
                     result = this.consumeOptionalCharacter($LBRACKET) ?
                         this.parseKeyedReadOrWrite(result, start, true) :
-                        this.parseAccessMemberOrMethodCall(result, start, true);
+                        this.parseAccessMemberOrCall(result, start, true);
                 }
                 else if (this.consumeOptionalCharacter($LBRACKET)) {
                     result = this.parseKeyedReadOrWrite(result, start, false);
                 }
                 else if (this.consumeOptionalCharacter($LPAREN)) {
+                    const argumentStart = this.inputIndex;
                     this.rparensExpected++;
                     const args = this.parseCallArguments();
+                    const argumentSpan = this.span(argumentStart, this.inputIndex).toAbsolute(this.absoluteOffset);
                     this.rparensExpected--;
                     this.expectCharacter($RPAREN);
-                    result = new FunctionCall(this.span(start), this.sourceSpan(start), result, args);
+                    result = new Call(this.span(start), this.sourceSpan(start), result, args, argumentSpan);
                 }
                 else if (this.consumeOptionalOperator('!')) {
                     result = new NonNullAssert(this.span(start), this.sourceSpan(start), result);
@@ -16211,7 +16212,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 return this.parseLiteralMap();
             }
             else if (this.next.isIdentifier()) {
-                return this.parseAccessMemberOrMethodCall(new ImplicitReceiver(this.span(start), this.sourceSpan(start)), start, false);
+                return this.parseAccessMemberOrCall(new ImplicitReceiver(this.span(start), this.sourceSpan(start)), start, false);
             }
             else if (this.next.isNumber()) {
                 const value = this.next.toNumber();
@@ -16279,17 +16280,41 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             return new LiteralMap(this.span(start), this.sourceSpan(start), keys, values);
         }
-        parseAccessMemberOrMethodCall(receiver, start, isSafe) {
+        parseAccessMemberOrCall(readReceiver, start, isSafe) {
             const nameStart = this.inputIndex;
             const id = this.withContext(ParseContextFlags.Writable, () => {
                 var _a;
                 const id = (_a = this.expectIdentifierOrKeyword()) !== null && _a !== void 0 ? _a : '';
                 if (id.length === 0) {
-                    this.error(`Expected identifier for property access`, receiver.span.end);
+                    this.error(`Expected identifier for property access`, readReceiver.span.end);
                 }
                 return id;
             });
             const nameSpan = this.sourceSpan(nameStart);
+            let receiver;
+            if (isSafe) {
+                if (this.consumeOptionalOperator('=')) {
+                    this.error('The \'?.\' operator cannot be used in the assignment');
+                    receiver = new EmptyExpr(this.span(start), this.sourceSpan(start));
+                }
+                else {
+                    receiver = new SafePropertyRead(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id);
+                }
+            }
+            else {
+                if (this.consumeOptionalOperator('=')) {
+                    if (!this.parseAction) {
+                        this.error('Bindings cannot contain assignments');
+                        return new EmptyExpr(this.span(start), this.sourceSpan(start));
+                    }
+                    const value = this.parseConditional();
+                    receiver = new PropertyWrite(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id, value);
+                }
+                else {
+                    receiver =
+                        new PropertyRead(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id);
+                }
+            }
             if (this.consumeOptionalCharacter($LPAREN)) {
                 const argumentStart = this.inputIndex;
                 this.rparensExpected++;
@@ -16299,34 +16324,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 this.rparensExpected--;
                 const span = this.span(start);
                 const sourceSpan = this.sourceSpan(start);
-                return isSafe ?
-                    new SafeMethodCall(span, sourceSpan, nameSpan, receiver, id, args, argumentSpan) :
-                    new MethodCall(span, sourceSpan, nameSpan, receiver, id, args, argumentSpan);
-            }
-            else {
-                if (isSafe) {
-                    if (this.consumeOptionalOperator('=')) {
-                        this.error('The \'?.\' operator cannot be used in the assignment');
-                        return new EmptyExpr(this.span(start), this.sourceSpan(start));
-                    }
-                    else {
-                        return new SafePropertyRead(this.span(start), this.sourceSpan(start), nameSpan, receiver, id);
-                    }
-                }
-                else {
-                    if (this.consumeOptionalOperator('=')) {
-                        if (!this.parseAction) {
-                            this.error('Bindings cannot contain assignments');
-                            return new EmptyExpr(this.span(start), this.sourceSpan(start));
-                        }
-                        const value = this.parseConditional();
-                        return new PropertyWrite(this.span(start), this.sourceSpan(start), nameSpan, receiver, id, value);
-                    }
-                    else {
-                        return new PropertyRead(this.span(start), this.sourceSpan(start), nameSpan, receiver, id);
-                    }
-                }
+                return new Call(span, sourceSpan, receiver, args, argumentSpan);
             }
+            return receiver;
         }
         parseCallArguments() {
             if (this.next.isCharacter($RPAREN))
@@ -16622,9 +16622,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         visitPropertyRead(ast, context) { }
         visitPropertyWrite(ast, context) { }
         visitSafePropertyRead(ast, context) { }
-        visitMethodCall(ast, context) { }
-        visitSafeMethodCall(ast, context) { }
-        visitFunctionCall(ast, context) { }
+        visitCall(ast, context) { }
         visitLiteralArray(ast, context) {
             this.visitAll(ast.expressions, context);
         }
@@ -18052,11 +18050,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return context.visitNodeFn(el, node);
         }
         visitAttribute(attribute, context) {
-            const node = this._visitTextWithInterpolation(attribute.value, attribute.valueSpan || attribute.sourceSpan, context, attribute.i18n);
+            const node = attribute.valueTokens === undefined || attribute.valueTokens.length === 1 ?
+                new Text$1(attribute.value, attribute.valueSpan || attribute.sourceSpan) :
+                this._visitTextWithInterpolation(attribute.valueTokens, attribute.valueSpan || attribute.sourceSpan, context, attribute.i18n);
             return context.visitNodeFn(attribute, node);
         }
         visitText(text, context) {
-            const node = this._visitTextWithInterpolation(text.value, text.sourceSpan, context, text.i18n);
+            const node = text.tokens.length === 1 ?
+                new Text$1(text.value, text.sourceSpan) :
+                this._visitTextWithInterpolation(text.tokens, text.sourceSpan, context, text.i18n);
             return context.visitNodeFn(text, node);
         }
         visitComment(comment, context) {
@@ -18095,61 +18097,58 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             throw new Error('Unreachable code');
         }
         /**
-         * Split the, potentially interpolated, text up into text and placeholder pieces.
+         * Convert, text and interpolated tokens up into text and placeholder pieces.
          *
-         * @param text The potentially interpolated string to be split.
+         * @param tokens The text and interpolated tokens.
          * @param sourceSpan The span of the whole of the `text` string.
          * @param context The current context of the visitor, used to compute and store placeholders.
          * @param previousI18n Any i18n metadata associated with this `text` from a previous pass.
          */
-        _visitTextWithInterpolation(text, sourceSpan, context, previousI18n) {
-            const { strings, expressions } = this._expressionParser.splitInterpolation(text, sourceSpan.start.toString(), this._interpolationConfig);
-            // No expressions, return a single text.
-            if (expressions.length === 0) {
-                return new Text$1(text, sourceSpan);
-            }
+        _visitTextWithInterpolation(tokens, sourceSpan, context, previousI18n) {
             // Return a sequence of `Text` and `Placeholder` nodes grouped in a `Container`.
             const nodes = [];
-            for (let i = 0; i < strings.length - 1; i++) {
-                this._addText(nodes, strings[i], sourceSpan);
-                this._addPlaceholder(nodes, context, expressions[i], sourceSpan);
+            // We will only create a container if there are actually interpolations,
+            // so this flag tracks that.
+            let hasInterpolation = false;
+            for (const token of tokens) {
+                switch (token.type) {
+                    case 8 /* INTERPOLATION */:
+                    case 17 /* ATTR_VALUE_INTERPOLATION */:
+                        hasInterpolation = true;
+                        const expression = token.parts[1];
+                        const baseName = extractPlaceholderName(expression) || 'INTERPOLATION';
+                        const phName = context.placeholderRegistry.getPlaceholderName(baseName, expression);
+                        context.placeholderToContent[phName] = {
+                            text: token.parts.join(''),
+                            sourceSpan: token.sourceSpan
+                        };
+                        nodes.push(new Placeholder(expression, phName, token.sourceSpan));
+                        break;
+                    default:
+                        if (token.parts[0].length > 0) {
+                            // This token is text or an encoded entity.
+                            // If it is following on from a previous text node then merge it into that node
+                            // Otherwise, if it is following an interpolation, then add a new node.
+                            const previous = nodes[nodes.length - 1];
+                            if (previous instanceof Text$1) {
+                                previous.value += token.parts[0];
+                                previous.sourceSpan = new ParseSourceSpan(previous.sourceSpan.start, token.sourceSpan.end, previous.sourceSpan.fullStart, previous.sourceSpan.details);
+                            }
+                            else {
+                                nodes.push(new Text$1(token.parts[0], token.sourceSpan));
+                            }
+                        }
+                        break;
+                }
             }
-            // The last index contains no expression
-            this._addText(nodes, strings[strings.length - 1], sourceSpan);
-            // Whitespace removal may have invalidated the interpolation source-spans.
-            reusePreviousSourceSpans(nodes, previousI18n);
-            return new Container(nodes, sourceSpan);
-        }
-        /**
-         * Create a new `Text` node from the `textPiece` and add it to the `nodes` collection.
-         *
-         * @param nodes The nodes to which the created `Text` node should be added.
-         * @param textPiece The text and relative span information for this `Text` node.
-         * @param interpolationSpan The span of the whole interpolated text.
-         */
-        _addText(nodes, textPiece, interpolationSpan) {
-            if (textPiece.text.length > 0) {
-                // No need to add empty strings
-                const stringSpan = getOffsetSourceSpan(interpolationSpan, textPiece);
-                nodes.push(new Text$1(textPiece.text, stringSpan));
+            if (hasInterpolation) {
+                // Whitespace removal may have invalidated the interpolation source-spans.
+                reusePreviousSourceSpans(nodes, previousI18n);
+                return new Container(nodes, sourceSpan);
+            }
+            else {
+                return nodes[0];
             }
-        }
-        /**
-         * Create a new `Placeholder` node from the `expression` and add it to the `nodes` collection.
-         *
-         * @param nodes The nodes to which the created `Text` node should be added.
-         * @param context The current context of the visitor, used to compute and store placeholders.
-         * @param expression The expression text and relative span information for this `Placeholder`
-         *     node.
-         * @param interpolationSpan The span of the whole interpolated text.
-         */
-        _addPlaceholder(nodes, context, expression, interpolationSpan) {
-            const sourceSpan = getOffsetSourceSpan(interpolationSpan, expression);
-            const baseName = extractPlaceholderName(expression.text) || 'INTERPOLATION';
-            const phName = context.placeholderRegistry.getPlaceholderName(baseName, expression.text);
-            const text = this._interpolationConfig.start + expression.text + this._interpolationConfig.end;
-            context.placeholderToContent[phName] = { text, sourceSpan };
-            nodes.push(new Placeholder(expression.text, phName, sourceSpan));
         }
     }
     /**
@@ -18171,7 +18170,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
         if (previousI18n instanceof Container) {
             // The `previousI18n` is a `Container`, which means that this is a second i18n extraction pass
-            // after whitespace has been removed from the AST ndoes.
+            // after whitespace has been removed from the AST nodes.
             assertEquivalentNodes(previousI18n.children, nodes);
             // Reuse the source-spans from the first pass.
             for (let i = 0; i < nodes.length; i++) {
@@ -18200,12 +18199,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             throw new Error('The types of the i18n message children changed between first and second pass.');
         }
     }
-    /**
-     * Create a new `ParseSourceSpan` from the `sourceSpan`, offset by the `start` and `end` values.
-     */
-    function getOffsetSourceSpan(sourceSpan, { start, end }) {
-        return new ParseSourceSpan(sourceSpan.fullStart.moveBy(start), sourceSpan.fullStart.moveBy(end));
-    }
     const _CUSTOM_PH_EXP = /\/\/[\s\S]*i18n[\s\S]*\([\s\S]*ph[\s\S]*=[\s\S]*("|')([\s\S]*?)\1[\s\S]*\)/g;
     function extractPlaceholderName(input) {
         return input.split(_CUSTOM_PH_EXP)[2];
@@ -18525,7 +18518,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 context[context.length - 1].text += text.value;
             }
             else {
-                context.push(new LiteralPiece(text.value, text.sourceSpan));
+                const sourceSpan = new ParseSourceSpan(text.sourceSpan.fullStart, text.sourceSpan.end, text.sourceSpan.fullStart, text.sourceSpan.details);
+                context.push(new LiteralPiece(text.value, sourceSpan));
             }
         }
         visitContainer(container, context) {
@@ -18569,7 +18563,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     function getSourceSpan(message) {
         const startNode = message.nodes[0];
         const endNode = message.nodes[message.nodes.length - 1];
-        return new ParseSourceSpan(startNode.sourceSpan.start, endNode.sourceSpan.end, startNode.sourceSpan.fullStart, startNode.sourceSpan.details);
+        return new ParseSourceSpan(startNode.sourceSpan.fullStart, endNode.sourceSpan.end, startNode.sourceSpan.fullStart, startNode.sourceSpan.details);
     }
     /**
      * Convert the list of serialized MessagePieces into two arrays.
@@ -19803,11 +19797,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             const convertedArgs = isVarLength ?
                 this.visitAll([new LiteralArray(pipe.span, pipe.sourceSpan, args)]) :
                 this.visitAll(args);
-            const pipeBindExpr = new FunctionCall(pipe.span, pipe.sourceSpan, target, [
+            const pipeBindExpr = new Call(pipe.span, pipe.sourceSpan, target, [
                 new LiteralPrimitive(pipe.span, pipe.sourceSpan, slot),
                 new LiteralPrimitive(pipe.span, pipe.sourceSpan, pureFunctionSlot),
                 ...convertedArgs,
-            ]);
+            ], null);
             this._pipeBindExprs.push(pipeBindExpr);
             return pipeBindExpr;
         }
@@ -20602,7 +20596,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 return fn([], [new ReturnStatement(list)]);
             case 2 /* ClosureResolved */:
                 // directives: function () { return [MyDir].map(ng.resolveForwardRef); }
-                const resolvedList = list.callMethod('map', [importExpr(Identifiers.resolveForwardRef)]);
+                const resolvedList = list.prop('map').callFn([importExpr(Identifiers.resolveForwardRef)]);
                 return fn([], [new ReturnStatement(resolvedList)]);
         }
     }
@@ -21475,7 +21469,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * 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 VERSION$1 = new Version('13.0.0-next.3');
+    const VERSION$1 = new Version('13.0.0-next.7');
 
     /**
      * @license
@@ -25576,26 +25570,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             ast.falseExp.visit(this);
             return this.query.getTypeUnion(this.getType(ast.trueExp), this.getType(ast.falseExp));
         }
-        visitFunctionCall(ast) {
-            // The type of a function call is the return type of the selected signature.
-            // The signature is selected based on the types of the arguments. Angular doesn't
-            // support contextual typing of arguments so this is simpler than TypeScript's
-            // version.
-            const args = ast.args.map(arg => this.getType(arg));
-            const target = this.getType(ast.target);
-            if (!target || !target.callable) {
-                this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.call_target_not_callable, this.sourceOf(ast.target), target.name));
-                return this.anyType;
-            }
-            const signature = target.selectSignature(args);
-            if (signature) {
-                return signature.result;
-            }
-            // TODO: Consider a better error message here. See `typescript_symbols#selectSignature` for more
-            // details.
-            this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.unable_to_resolve_compatible_call_signature));
-            return this.anyType;
-        }
         visitImplicitReceiver(_ast) {
             const _this = this;
             // Return a pseudo-symbol for the implicit receiver.
@@ -25683,9 +25657,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     }
             }
         }
-        visitMethodCall(ast) {
-            return this.resolveMethodCall(this.getType(ast.receiver), ast);
-        }
         visitPipe(ast) {
             // The type of a pipe node is the return type of the pipe's transform method. The table returned
             // by getPipes() is expected to contain symbols with the corresponding transform method type.
@@ -25723,9 +25694,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             // The type of a quoted expression is any.
             return this.query.getBuiltinType(BuiltinType$1.Any);
         }
-        visitSafeMethodCall(ast) {
-            return this.resolveMethodCall(this.query.getNonNullableType(this.getType(ast.receiver)), ast);
-        }
         visitSafePropertyRead(ast) {
             return this.resolvePropertyRead(this.query.getNonNullableType(this.getType(ast.receiver)), ast);
         }
@@ -25735,6 +25703,56 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             const result = targetType.indexed(keyType, ast.key instanceof LiteralPrimitive ? ast.key.value : undefined);
             return result || this.anyType;
         }
+        visitCall(ast) {
+            if (ast.receiver instanceof Call) {
+                // The type of a function call is the return type of the selected signature.
+                // The signature is selected based on the types of the arguments. Angular doesn't
+                // support contextual typing of arguments so this is simpler than TypeScript's
+                // version.
+                const args = ast.args.map(arg => this.getType(arg));
+                const target = this.getType(ast.receiver);
+                if (!target || !target.callable) {
+                    this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.call_target_not_callable, this.sourceOf(ast.receiver), target.name));
+                    return this.anyType;
+                }
+                const signature = target.selectSignature(args);
+                if (signature) {
+                    return signature.result;
+                }
+                // TODO: Consider a better error message here. See `typescript_symbols#selectSignature` for
+                // more details.
+                this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.unable_to_resolve_compatible_call_signature));
+                return this.anyType;
+            }
+            if (ast.receiver instanceof PropertyRead || ast.receiver instanceof SafePropertyRead) {
+                const receiver = ast.receiver;
+                const receiverType = receiver instanceof SafePropertyRead ?
+                    this.query.getNonNullableType(this.getType(receiver.receiver)) :
+                    this.getType(receiver.receiver);
+                if (this.isAny(receiverType)) {
+                    return this.anyType;
+                }
+                const methodType = this.resolvePropertyRead(receiverType, receiver);
+                if (!methodType) {
+                    this.diagnostics.push(createDiagnostic(refinedSpan(receiver), Diagnostic.could_not_resolve_type, receiver.name));
+                    return this.anyType;
+                }
+                if (this.isAny(methodType)) {
+                    return this.anyType;
+                }
+                if (!methodType.callable) {
+                    this.diagnostics.push(createDiagnostic(refinedSpan(receiver), Diagnostic.identifier_not_callable, receiver.name));
+                    return this.anyType;
+                }
+                const signature = methodType.selectSignature(ast.args.map(arg => this.getType(arg)));
+                if (!signature) {
+                    this.diagnostics.push(createDiagnostic(refinedSpan(receiver), Diagnostic.unable_to_resolve_signature, receiver.name));
+                    return this.anyType;
+                }
+                return signature.result;
+            }
+            return this.anyType;
+        }
         /**
          * Gets the source of an expession AST.
          * The AST's sourceSpan is relative to the start of the template source code, which is contained
@@ -25757,29 +25775,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             return result;
         }
-        resolveMethodCall(receiverType, ast) {
-            if (this.isAny(receiverType)) {
-                return this.anyType;
-            }
-            const methodType = this.resolvePropertyRead(receiverType, ast);
-            if (!methodType) {
-                this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.could_not_resolve_type, ast.name));
-                return this.anyType;
-            }
-            if (this.isAny(methodType)) {
-                return this.anyType;
-            }
-            if (!methodType.callable) {
-                this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.identifier_not_callable, ast.name));
-                return this.anyType;
-            }
-            const signature = methodType.selectSignature(ast.args.map(arg => this.getType(arg)));
-            if (!signature) {
-                this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.unable_to_resolve_signature, ast.name));
-                return this.anyType;
-            }
-            return signature.result;
-        }
         resolvePropertyRead(receiverType, ast) {
             if (this.isAny(receiverType)) {
                 return this.anyType;
@@ -26222,7 +26217,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             visitBinary(_ast) { },
             visitChain(_ast) { },
             visitConditional(_ast) { },
-            visitFunctionCall(_ast) { },
+            visitCall(_ast) { },
             visitImplicitReceiver(_ast) { },
             visitThisReceiver(_ast) { },
             visitInterpolation(_ast) {
@@ -26243,7 +26238,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     result = undefined;
                 }
             },
-            visitMethodCall(_ast) { },
             visitPipe(ast) {
                 if (position >= ast.exp.span.end &&
                     (!ast.args || !ast.args.length || position < ast.args[0].span.start)) {
@@ -26265,10 +26259,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 // For a quote, return the members of any (if there are any).
                 result = templateInfo.query.getBuiltinType(BuiltinType$1.Any).members();
             },
-            visitSafeMethodCall(ast) {
-                const receiverType = getType(ast.receiver);
-                result = receiverType ? receiverType.members() : scope;
-            },
             visitSafePropertyRead(ast) {
                 const receiverType = getType(ast.receiver);
                 result = receiverType ? receiverType.members() : scope;
@@ -26312,7 +26302,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             visitBinary(_ast) { },
             visitChain(_ast) { },
             visitConditional(_ast) { },
-            visitFunctionCall(_ast) { },
+            visitCall(_ast) { },
             visitImplicitReceiver(_ast) { },
             visitThisReceiver(_ast) { },
             visitInterpolation(_ast) { },
@@ -26322,11 +26312,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             visitLiteralArray(_ast) { },
             visitLiteralMap(_ast) { },
             visitLiteralPrimitive(_ast) { },
-            visitMethodCall(ast) {
-                const receiverType = getType(ast.receiver);
-                symbol = receiverType && receiverType.members().get(ast.name);
-                span = spanFromName(ast);
-            },
             visitPipe(ast) {
                 if (inSpan(position, ast.nameSpan, /* exclusive */ true)) {
                     // We are in a position a pipe name is expected.
@@ -26348,11 +26333,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 span = spanFromName(ast);
             },
             visitQuote(_ast) { },
-            visitSafeMethodCall(ast) {
-                const receiverType = getType(ast.receiver);
-                symbol = receiverType && receiverType.members().get(ast.name);
-                span = spanFromName(ast);
-            },
             visitSafePropertyRead(ast) {
                 const receiverType = getType(ast.receiver);
                 symbol = receiverType && receiverType.members().get(ast.name);
@@ -32958,12 +32938,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     const ERROR_DEBUG_CONTEXT = 'ngDebugContext';
     const ERROR_ORIGINAL_ERROR = 'ngOriginalError';
     const ERROR_LOGGER = 'ngErrorLogger';
-    function wrappedError(message, originalError) {
-        const msg = `${message} caused by: ${originalError instanceof Error ? originalError.message : originalError}`;
-        const error = Error(msg);
-        error[ERROR_ORIGINAL_ERROR] = originalError;
-        return error;
-    }
 
     /**
      * @license
@@ -35794,7 +35768,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
     }
     Injector.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
-    Injector.NULL = new NullInjector();
+    Injector.NULL = ( /* @__PURE__ */new NullInjector());
     /** @nocollapse */
     Injector.ɵprov = ɵɵdefineInjectable({
         token: Injector,
@@ -36316,864 +36290,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     const SWITCH_COMPILE_INJECTABLE__PRE_R3__ = render2CompileInjectable;
     const SWITCH_COMPILE_INJECTABLE = SWITCH_COMPILE_INJECTABLE__PRE_R3__;
 
-    /**
-     * @license
-     * Copyright Google LLC 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 findFirstClosedCycle(keys) {
-        const res = [];
-        for (let i = 0; i < keys.length; ++i) {
-            if (res.indexOf(keys[i]) > -1) {
-                res.push(keys[i]);
-                return res;
-            }
-            res.push(keys[i]);
-        }
-        return res;
-    }
-    function constructResolvingPath(keys) {
-        if (keys.length > 1) {
-            const reversed = findFirstClosedCycle(keys.slice().reverse());
-            const tokenStrs = reversed.map(k => stringify$1(k.token));
-            return ' (' + tokenStrs.join(' -> ') + ')';
-        }
-        return '';
-    }
-    function injectionError(injector, key, constructResolvingMessage, originalError) {
-        const keys = [key];
-        const errMsg = constructResolvingMessage(keys);
-        const error = (originalError ? wrappedError(errMsg, originalError) : Error(errMsg));
-        error.addKey = addKey;
-        error.keys = keys;
-        error.injectors = [injector];
-        error.constructResolvingMessage = constructResolvingMessage;
-        error[ERROR_ORIGINAL_ERROR] = originalError;
-        return error;
-    }
-    function addKey(injector, key) {
-        this.injectors.push(injector);
-        this.keys.push(key);
-        // Note: This updated message won't be reflected in the `.stack` property
-        this.message = this.constructResolvingMessage(this.keys);
-    }
-    /**
-     * Thrown when trying to retrieve a dependency by key from {@link Injector}, but the
-     * {@link Injector} does not have a {@link Provider} for the given key.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * class A {
-     *   constructor(b:B) {}
-     * }
-     *
-     * expect(() => Injector.resolveAndCreate([A])).toThrowError();
-     * ```
-     */
-    function noProviderError(injector, key) {
-        return injectionError(injector, key, function (keys) {
-            const first = stringify$1(keys[0].token);
-            return `No provider for ${first}!${constructResolvingPath(keys)}`;
-        });
-    }
-    /**
-     * Thrown when dependencies form a cycle.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * var injector = Injector.resolveAndCreate([
-     *   {provide: "one", useFactory: (two) => "two", deps: [[new Inject("two")]]},
-     *   {provide: "two", useFactory: (one) => "one", deps: [[new Inject("one")]]}
-     * ]);
-     *
-     * expect(() => injector.get("one")).toThrowError();
-     * ```
-     *
-     * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.
-     */
-    function cyclicDependencyError(injector, key) {
-        return injectionError(injector, key, function (keys) {
-            return `Cannot instantiate cyclic dependency!${constructResolvingPath(keys)}`;
-        });
-    }
-    /**
-     * Thrown when a constructing type returns with an Error.
-     *
-     * The `InstantiationError` class contains the original error plus the dependency graph which caused
-     * this object to be instantiated.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * class A {
-     *   constructor() {
-     *     throw new Error('message');
-     *   }
-     * }
-     *
-     * var injector = Injector.resolveAndCreate([A]);
-
-     * try {
-     *   injector.get(A);
-     * } catch (e) {
-     *   expect(e instanceof InstantiationError).toBe(true);
-     *   expect(e.originalException.message).toEqual("message");
-     *   expect(e.originalStack).toBeDefined();
-     * }
-     * ```
-     */
-    function instantiationError(injector, originalException, originalStack, key) {
-        return injectionError(injector, key, function (keys) {
-            const first = stringify$1(keys[0].token);
-            return `${originalException.message}: Error during instantiation of ${first}!${constructResolvingPath(keys)}.`;
-        }, originalException);
-    }
-    /**
-     * Thrown when an object other then {@link Provider} (or `Type`) is passed to {@link Injector}
-     * creation.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * expect(() => Injector.resolveAndCreate(["not a type"])).toThrowError();
-     * ```
-     */
-    function invalidProviderError(provider) {
-        return Error(`Invalid provider - only instances of Provider and Type are allowed, got: ${provider}`);
-    }
-    /**
-     * Thrown when the class has no annotation information.
-     *
-     * Lack of annotation information prevents the {@link Injector} from determining which dependencies
-     * need to be injected into the constructor.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * class A {
-     *   constructor(b) {}
-     * }
-     *
-     * expect(() => Injector.resolveAndCreate([A])).toThrowError();
-     * ```
-     *
-     * This error is also thrown when the class not marked with {@link Injectable} has parameter types.
-     *
-     * ```typescript
-     * class B {}
-     *
-     * class A {
-     *   constructor(b:B) {} // no information about the parameter types of A is available at runtime.
-     * }
-     *
-     * expect(() => Injector.resolveAndCreate([A,B])).toThrowError();
-     * ```
-     *
-     */
-    function noAnnotationError(typeOrFunc, params) {
-        const signature = [];
-        for (let i = 0, ii = params.length; i < ii; i++) {
-            const parameter = params[i];
-            if (!parameter || parameter.length == 0) {
-                signature.push('?');
-            }
-            else {
-                signature.push(parameter.map(stringify$1).join(' '));
-            }
-        }
-        return Error('Cannot resolve all parameters for \'' + stringify$1(typeOrFunc) + '\'(' +
-            signature.join(', ') + '). ' +
-            'Make sure that all the parameters are decorated with Inject or have valid type annotations and that \'' +
-            stringify$1(typeOrFunc) + '\' is decorated with Injectable.');
-    }
-    /**
-     * Thrown when getting an object by index.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * class A {}
-     *
-     * var injector = Injector.resolveAndCreate([A]);
-     *
-     * expect(() => injector.getAt(100)).toThrowError();
-     * ```
-     *
-     */
-    function outOfBoundsError(index) {
-        return Error(`Index ${index} is out-of-bounds.`);
-    }
-    // TODO: add a working example after alpha38 is released
-    /**
-     * Thrown when a multi provider and a regular provider are bound to the same token.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * expect(() => Injector.resolveAndCreate([
-     *   { provide: "Strings", useValue: "string1", multi: true},
-     *   { provide: "Strings", useValue: "string2", multi: false}
-     * ])).toThrowError();
-     * ```
-     */
-    function mixingMultiProvidersWithRegularProvidersError(provider1, provider2) {
-        return Error(`Cannot mix multi providers and regular providers, got: ${provider1} ${provider2}`);
-    }
-
-    /**
-     * @license
-     * Copyright Google LLC 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
-     */
-    /**
-     * A unique object used for retrieving items from the {@link ReflectiveInjector}.
-     *
-     * Keys have:
-     * - a system-wide unique `id`.
-     * - a `token`.
-     *
-     * `Key` is used internally by {@link ReflectiveInjector} because its system-wide unique `id` allows
-     * the
-     * injector to store created objects in a more efficient way.
-     *
-     * `Key` should not be created directly. {@link ReflectiveInjector} creates keys automatically when
-     * resolving
-     * providers.
-     *
-     * @deprecated No replacement
-     * @publicApi
-     */
-    class ReflectiveKey {
-        /**
-         * Private
-         */
-        constructor(token, id) {
-            this.token = token;
-            this.id = id;
-            if (!token) {
-                throw new Error('Token must be defined!');
-            }
-            this.displayName = stringify$1(this.token);
-        }
-        /**
-         * Retrieves a `Key` for a token.
-         */
-        static get(token) {
-            return _globalKeyRegistry.get(resolveForwardRef$1(token));
-        }
-        /**
-         * @returns the number of keys registered in the system.
-         */
-        static get numberOfKeys() {
-            return _globalKeyRegistry.numberOfKeys;
-        }
-    }
-    class KeyRegistry {
-        constructor() {
-            this._allKeys = new Map();
-        }
-        get(token) {
-            if (token instanceof ReflectiveKey)
-                return token;
-            if (this._allKeys.has(token)) {
-                return this._allKeys.get(token);
-            }
-            const newKey = new ReflectiveKey(token, ReflectiveKey.numberOfKeys);
-            this._allKeys.set(token, newKey);
-            return newKey;
-        }
-        get numberOfKeys() {
-            return this._allKeys.size;
-        }
-    }
-    const _globalKeyRegistry = new KeyRegistry();
-
-    /**
-     * @license
-     * Copyright Google LLC 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
-     */
-    /**
-     * Provides access to reflection data about symbols. Used internally by Angular
-     * to power dependency injection and compilation.
-     */
-    class Reflector {
-        constructor(reflectionCapabilities) {
-            this.reflectionCapabilities = reflectionCapabilities;
-        }
-        updateCapabilities(caps) {
-            this.reflectionCapabilities = caps;
-        }
-        factory(type) {
-            return this.reflectionCapabilities.factory(type);
-        }
-        parameters(typeOrFunc) {
-            return this.reflectionCapabilities.parameters(typeOrFunc);
-        }
-        annotations(typeOrFunc) {
-            return this.reflectionCapabilities.annotations(typeOrFunc);
-        }
-        propMetadata(typeOrFunc) {
-            return this.reflectionCapabilities.propMetadata(typeOrFunc);
-        }
-        hasLifecycleHook(type, lcProperty) {
-            return this.reflectionCapabilities.hasLifecycleHook(type, lcProperty);
-        }
-        getter(name) {
-            return this.reflectionCapabilities.getter(name);
-        }
-        setter(name) {
-            return this.reflectionCapabilities.setter(name);
-        }
-        method(name) {
-            return this.reflectionCapabilities.method(name);
-        }
-        importUri(type) {
-            return this.reflectionCapabilities.importUri(type);
-        }
-        resourceUri(type) {
-            return this.reflectionCapabilities.resourceUri(type);
-        }
-        resolveIdentifier(name, moduleUrl, members, runtime) {
-            return this.reflectionCapabilities.resolveIdentifier(name, moduleUrl, members, runtime);
-        }
-        resolveEnum(identifier, name) {
-            return this.reflectionCapabilities.resolveEnum(identifier, name);
-        }
-    }
-
-    /**
-     * @license
-     * Copyright Google LLC 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
-     */
-    /**
-     * The {@link Reflector} used internally in Angular to access metadata
-     * about symbols.
-     */
-    const reflector = new Reflector(new ReflectionCapabilities());
-
-    /**
-     * @license
-     * Copyright Google LLC 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
-     */
-    /**
-     * `Dependency` is used by the framework to extend DI.
-     * This is internal to Angular and should not be used directly.
-     */
-    class ReflectiveDependency {
-        constructor(key, optional, visibility) {
-            this.key = key;
-            this.optional = optional;
-            this.visibility = visibility;
-        }
-        static fromKey(key) {
-            return new ReflectiveDependency(key, false, null);
-        }
-    }
-    const _EMPTY_LIST = [];
-    class ResolvedReflectiveProvider_ {
-        constructor(key, resolvedFactories, multiProvider) {
-            this.key = key;
-            this.resolvedFactories = resolvedFactories;
-            this.multiProvider = multiProvider;
-            this.resolvedFactory = this.resolvedFactories[0];
-        }
-    }
-    /**
-     * An internal resolved representation of a factory function created by resolving `Provider`.
-     * @publicApi
-     */
-    class ResolvedReflectiveFactory {
-        constructor(
-        /**
-         * Factory function which can return an instance of an object represented by a key.
-         */
-        factory, 
-        /**
-         * Arguments (dependencies) to the `factory` function.
-         */
-        dependencies) {
-            this.factory = factory;
-            this.dependencies = dependencies;
-        }
-    }
-    /**
-     * Resolve a single provider.
-     */
-    function resolveReflectiveFactory(provider) {
-        let factoryFn;
-        let resolvedDeps;
-        if (provider.useClass) {
-            const useClass = resolveForwardRef$1(provider.useClass);
-            factoryFn = reflector.factory(useClass);
-            resolvedDeps = _dependenciesFor(useClass);
-        }
-        else if (provider.useExisting) {
-            factoryFn = (aliasInstance) => aliasInstance;
-            resolvedDeps = [ReflectiveDependency.fromKey(ReflectiveKey.get(provider.useExisting))];
-        }
-        else if (provider.useFactory) {
-            factoryFn = provider.useFactory;
-            resolvedDeps = constructDependencies(provider.useFactory, provider.deps);
-        }
-        else {
-            factoryFn = () => provider.useValue;
-            resolvedDeps = _EMPTY_LIST;
-        }
-        return new ResolvedReflectiveFactory(factoryFn, resolvedDeps);
-    }
-    /**
-     * Converts the `Provider` into `ResolvedProvider`.
-     *
-     * `Injector` internally only uses `ResolvedProvider`, `Provider` contains convenience provider
-     * syntax.
-     */
-    function resolveReflectiveProvider(provider) {
-        return new ResolvedReflectiveProvider_(ReflectiveKey.get(provider.provide), [resolveReflectiveFactory(provider)], provider.multi || false);
-    }
-    /**
-     * Resolve a list of Providers.
-     */
-    function resolveReflectiveProviders(providers) {
-        const normalized = _normalizeProviders(providers, []);
-        const resolved = normalized.map(resolveReflectiveProvider);
-        const resolvedProviderMap = mergeResolvedReflectiveProviders(resolved, new Map());
-        return Array.from(resolvedProviderMap.values());
-    }
-    /**
-     * Merges a list of ResolvedProviders into a list where each key is contained exactly once and
-     * multi providers have been merged.
-     */
-    function mergeResolvedReflectiveProviders(providers, normalizedProvidersMap) {
-        for (let i = 0; i < providers.length; i++) {
-            const provider = providers[i];
-            const existing = normalizedProvidersMap.get(provider.key.id);
-            if (existing) {
-                if (provider.multiProvider !== existing.multiProvider) {
-                    throw mixingMultiProvidersWithRegularProvidersError(existing, provider);
-                }
-                if (provider.multiProvider) {
-                    for (let j = 0; j < provider.resolvedFactories.length; j++) {
-                        existing.resolvedFactories.push(provider.resolvedFactories[j]);
-                    }
-                }
-                else {
-                    normalizedProvidersMap.set(provider.key.id, provider);
-                }
-            }
-            else {
-                let resolvedProvider;
-                if (provider.multiProvider) {
-                    resolvedProvider = new ResolvedReflectiveProvider_(provider.key, provider.resolvedFactories.slice(), provider.multiProvider);
-                }
-                else {
-                    resolvedProvider = provider;
-                }
-                normalizedProvidersMap.set(provider.key.id, resolvedProvider);
-            }
-        }
-        return normalizedProvidersMap;
-    }
-    function _normalizeProviders(providers, res) {
-        providers.forEach(b => {
-            if (b instanceof Type$2) {
-                res.push({ provide: b, useClass: b });
-            }
-            else if (b && typeof b == 'object' && b.provide !== undefined) {
-                res.push(b);
-            }
-            else if (Array.isArray(b)) {
-                _normalizeProviders(b, res);
-            }
-            else {
-                throw invalidProviderError(b);
-            }
-        });
-        return res;
-    }
-    function constructDependencies(typeOrFunc, dependencies) {
-        if (!dependencies) {
-            return _dependenciesFor(typeOrFunc);
-        }
-        else {
-            const params = dependencies.map(t => [t]);
-            return dependencies.map(t => _extractToken(typeOrFunc, t, params));
-        }
-    }
-    function _dependenciesFor(typeOrFunc) {
-        const params = reflector.parameters(typeOrFunc);
-        if (!params)
-            return [];
-        if (params.some(p => p == null)) {
-            throw noAnnotationError(typeOrFunc, params);
-        }
-        return params.map(p => _extractToken(typeOrFunc, p, params));
-    }
-    function _extractToken(typeOrFunc, metadata, params) {
-        let token = null;
-        let optional = false;
-        if (!Array.isArray(metadata)) {
-            if (metadata instanceof Inject) {
-                return _createDependency(metadata.token, optional, null);
-            }
-            else {
-                return _createDependency(metadata, optional, null);
-            }
-        }
-        let visibility = null;
-        for (let i = 0; i < metadata.length; ++i) {
-            const paramMetadata = metadata[i];
-            if (paramMetadata instanceof Type$2) {
-                token = paramMetadata;
-            }
-            else if (paramMetadata instanceof Inject) {
-                token = paramMetadata.token;
-            }
-            else if (paramMetadata instanceof Optional) {
-                optional = true;
-            }
-            else if (paramMetadata instanceof Self || paramMetadata instanceof SkipSelf) {
-                visibility = paramMetadata;
-            }
-            else if (paramMetadata instanceof InjectionToken) {
-                token = paramMetadata;
-            }
-        }
-        token = resolveForwardRef$1(token);
-        if (token != null) {
-            return _createDependency(token, optional, visibility);
-        }
-        else {
-            throw noAnnotationError(typeOrFunc, params);
-        }
-    }
-    function _createDependency(token, optional, visibility) {
-        return new ReflectiveDependency(ReflectiveKey.get(token), optional, visibility);
-    }
-
-    /**
-     * @license
-     * Copyright Google LLC 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
-     */
-    // Threshold for the dynamic version
-    const UNDEFINED = {};
-    /**
-     * A ReflectiveDependency injection container used for instantiating objects and resolving
-     * dependencies.
-     *
-     * An `Injector` is a replacement for a `new` operator, which can automatically resolve the
-     * constructor dependencies.
-     *
-     * In typical use, application code asks for the dependencies in the constructor and they are
-     * resolved by the `Injector`.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * The following example creates an `Injector` configured to create `Engine` and `Car`.
-     *
-     * ```typescript
-     * @Injectable()
-     * class Engine {
-     * }
-     *
-     * @Injectable()
-     * class Car {
-     *   constructor(public engine:Engine) {}
-     * }
-     *
-     * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
-     * var car = injector.get(Car);
-     * expect(car instanceof Car).toBe(true);
-     * expect(car.engine instanceof Engine).toBe(true);
-     * ```
-     *
-     * Notice, we don't use the `new` operator because we explicitly want to have the `Injector`
-     * resolve all of the object's dependencies automatically.
-     *
-     * @deprecated from v5 - slow and brings in a lot of code, Use `Injector.create` instead.
-     * @publicApi
-     */
-    class ReflectiveInjector {
-        /**
-         * Turns an array of provider definitions into an array of resolved providers.
-         *
-         * A resolution is a process of flattening multiple nested arrays and converting individual
-         * providers into an array of `ResolvedReflectiveProvider`s.
-         *
-         * @usageNotes
-         * ### Example
-         *
-         * ```typescript
-         * @Injectable()
-         * class Engine {
-         * }
-         *
-         * @Injectable()
-         * class Car {
-         *   constructor(public engine:Engine) {}
-         * }
-         *
-         * var providers = ReflectiveInjector.resolve([Car, [[Engine]]]);
-         *
-         * expect(providers.length).toEqual(2);
-         *
-         * expect(providers[0] instanceof ResolvedReflectiveProvider).toBe(true);
-         * expect(providers[0].key.displayName).toBe("Car");
-         * expect(providers[0].dependencies.length).toEqual(1);
-         * expect(providers[0].factory).toBeDefined();
-         *
-         * expect(providers[1].key.displayName).toBe("Engine");
-         * });
-         * ```
-         *
-         */
-        static resolve(providers) {
-            return resolveReflectiveProviders(providers);
-        }
-        /**
-         * Resolves an array of providers and creates an injector from those providers.
-         *
-         * The passed-in providers can be an array of `Type`, `Provider`,
-         * or a recursive array of more providers.
-         *
-         * @usageNotes
-         * ### Example
-         *
-         * ```typescript
-         * @Injectable()
-         * class Engine {
-         * }
-         *
-         * @Injectable()
-         * class Car {
-         *   constructor(public engine:Engine) {}
-         * }
-         *
-         * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
-         * expect(injector.get(Car) instanceof Car).toBe(true);
-         * ```
-         */
-        static resolveAndCreate(providers, parent) {
-            const ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
-            return ReflectiveInjector.fromResolvedProviders(ResolvedReflectiveProviders, parent);
-        }
-        /**
-         * Creates an injector from previously resolved providers.
-         *
-         * This API is the recommended way to construct injectors in performance-sensitive parts.
-         *
-         * @usageNotes
-         * ### Example
-         *
-         * ```typescript
-         * @Injectable()
-         * class Engine {
-         * }
-         *
-         * @Injectable()
-         * class Car {
-         *   constructor(public engine:Engine) {}
-         * }
-         *
-         * var providers = ReflectiveInjector.resolve([Car, Engine]);
-         * var injector = ReflectiveInjector.fromResolvedProviders(providers);
-         * expect(injector.get(Car) instanceof Car).toBe(true);
-         * ```
-         */
-        static fromResolvedProviders(providers, parent) {
-            return new ReflectiveInjector_(providers, parent);
-        }
-    }
-    class ReflectiveInjector_ {
-        /**
-         * Private
-         */
-        constructor(_providers, _parent) {
-            /** @internal */
-            this._constructionCounter = 0;
-            this._providers = _providers;
-            this.parent = _parent || null;
-            const len = _providers.length;
-            this.keyIds = [];
-            this.objs = [];
-            for (let i = 0; i < len; i++) {
-                this.keyIds[i] = _providers[i].key.id;
-                this.objs[i] = UNDEFINED;
-            }
-        }
-        get(token, notFoundValue = THROW_IF_NOT_FOUND) {
-            return this._getByKey(ReflectiveKey.get(token), null, notFoundValue);
-        }
-        resolveAndCreateChild(providers) {
-            const ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
-            return this.createChildFromResolved(ResolvedReflectiveProviders);
-        }
-        createChildFromResolved(providers) {
-            const inj = new ReflectiveInjector_(providers);
-            inj.parent = this;
-            return inj;
-        }
-        resolveAndInstantiate(provider) {
-            return this.instantiateResolved(ReflectiveInjector.resolve([provider])[0]);
-        }
-        instantiateResolved(provider) {
-            return this._instantiateProvider(provider);
-        }
-        getProviderAtIndex(index) {
-            if (index < 0 || index >= this._providers.length) {
-                throw outOfBoundsError(index);
-            }
-            return this._providers[index];
-        }
-        /** @internal */
-        _new(provider) {
-            if (this._constructionCounter++ > this._getMaxNumberOfObjects()) {
-                throw cyclicDependencyError(this, provider.key);
-            }
-            return this._instantiateProvider(provider);
-        }
-        _getMaxNumberOfObjects() {
-            return this.objs.length;
-        }
-        _instantiateProvider(provider) {
-            if (provider.multiProvider) {
-                const res = [];
-                for (let i = 0; i < provider.resolvedFactories.length; ++i) {
-                    res[i] = this._instantiate(provider, provider.resolvedFactories[i]);
-                }
-                return res;
-            }
-            else {
-                return this._instantiate(provider, provider.resolvedFactories[0]);
-            }
-        }
-        _instantiate(provider, ResolvedReflectiveFactory) {
-            const factory = ResolvedReflectiveFactory.factory;
-            let deps;
-            try {
-                deps =
-                    ResolvedReflectiveFactory.dependencies.map(dep => this._getByReflectiveDependency(dep));
-            }
-            catch (e) {
-                if (e.addKey) {
-                    e.addKey(this, provider.key);
-                }
-                throw e;
-            }
-            let obj;
-            try {
-                obj = factory(...deps);
-            }
-            catch (e) {
-                throw instantiationError(this, e, e.stack, provider.key);
-            }
-            return obj;
-        }
-        _getByReflectiveDependency(dep) {
-            return this._getByKey(dep.key, dep.visibility, dep.optional ? null : THROW_IF_NOT_FOUND);
-        }
-        _getByKey(key, visibility, notFoundValue) {
-            if (key === ReflectiveInjector_.INJECTOR_KEY) {
-                return this;
-            }
-            if (visibility instanceof Self) {
-                return this._getByKeySelf(key, notFoundValue);
-            }
-            else {
-                return this._getByKeyDefault(key, notFoundValue, visibility);
-            }
-        }
-        _getObjByKeyId(keyId) {
-            for (let i = 0; i < this.keyIds.length; i++) {
-                if (this.keyIds[i] === keyId) {
-                    if (this.objs[i] === UNDEFINED) {
-                        this.objs[i] = this._new(this._providers[i]);
-                    }
-                    return this.objs[i];
-                }
-            }
-            return UNDEFINED;
-        }
-        /** @internal */
-        _throwOrNull(key, notFoundValue) {
-            if (notFoundValue !== THROW_IF_NOT_FOUND) {
-                return notFoundValue;
-            }
-            else {
-                throw noProviderError(this, key);
-            }
-        }
-        /** @internal */
-        _getByKeySelf(key, notFoundValue) {
-            const obj = this._getObjByKeyId(key.id);
-            return (obj !== UNDEFINED) ? obj : this._throwOrNull(key, notFoundValue);
-        }
-        /** @internal */
-        _getByKeyDefault(key, notFoundValue, visibility) {
-            let inj;
-            if (visibility instanceof SkipSelf) {
-                inj = this.parent;
-            }
-            else {
-                inj = this;
-            }
-            while (inj instanceof ReflectiveInjector_) {
-                const inj_ = inj;
-                const obj = inj_._getObjByKeyId(key.id);
-                if (obj !== UNDEFINED)
-                    return obj;
-                inj = inj_.parent;
-            }
-            if (inj !== null) {
-                return inj.get(key.token, notFoundValue);
-            }
-            else {
-                return this._throwOrNull(key, notFoundValue);
-            }
-        }
-        get displayName() {
-            const providers = _mapProviders(this, (b) => ' "' + b.key.displayName + '" ')
-                .join(', ');
-            return `ReflectiveInjector(providers: [${providers}])`;
-        }
-        toString() {
-            return this.displayName;
-        }
-    }
-    ReflectiveInjector_.INJECTOR_KEY = ReflectiveKey.get(Injector);
-    function _mapProviders(injector, fn) {
-        const res = [];
-        for (let i = 0; i < injector._providers.length; ++i) {
-            res[i] = fn(injector.getProviderAtIndex(i));
-        }
-        return res;
-    }
-
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -37397,7 +36513,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      */
     class ComponentFactoryResolver {
     }
-    ComponentFactoryResolver.NULL = new _NullComponentFactoryResolver();
+    ComponentFactoryResolver.NULL = ( /* @__PURE__ */new _NullComponentFactoryResolver());
     class ComponentFactoryBoundToModule extends ComponentFactory {
         constructor(factory, ngModule) {
             super();
@@ -37554,7 +36670,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     /**
      * @publicApi
      */
-    const VERSION$2 = new Version$1('13.0.0-next.3');
+    const VERSION$2 = new Version$1('13.0.0-next.7');
 
     /**
      * @license