@angular/language-service 9.1.3 → 9.1.7

package/bundles/language-service.umd.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v9.1.3
+ * @license Angular v9.1.7
  * Copyright Google Inc. All Rights Reserved.
  * License: MIT
  */
@@ -3691,7 +3691,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         Identifiers.stylePropInterpolate7 = { name: 'ɵɵstylePropInterpolate7', moduleName: CORE$1 };
         Identifiers.stylePropInterpolate8 = { name: 'ɵɵstylePropInterpolate8', moduleName: CORE$1 };
         Identifiers.stylePropInterpolateV = { name: 'ɵɵstylePropInterpolateV', moduleName: CORE$1 };
-        Identifiers.containerCreate = { name: 'ɵɵcontainer', moduleName: CORE$1 };
         Identifiers.nextContext = { name: 'ɵɵnextContext', moduleName: CORE$1 };
         Identifiers.templateCreate = { name: 'ɵɵtemplate', moduleName: CORE$1 };
         Identifiers.text = { name: 'ɵɵtext', moduleName: CORE$1 };
@@ -7196,6 +7195,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         };
         return AST;
     }());
+    var ASTWithName = /** @class */ (function (_super) {
+        __extends(ASTWithName, _super);
+        function ASTWithName(span, sourceSpan, nameSpan) {
+            var _this = _super.call(this, span, sourceSpan) || this;
+            _this.nameSpan = nameSpan;
+            return _this;
+        }
+        return ASTWithName;
+    }(AST));
     /**
      * Represents a quoted expression of the form:
      *
@@ -7281,8 +7289,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     }(AST));
     var PropertyRead = /** @class */ (function (_super) {
         __extends(PropertyRead, _super);
-        function PropertyRead(span, sourceSpan, receiver, name) {
-            var _this = _super.call(this, span, sourceSpan) || this;
+        function PropertyRead(span, sourceSpan, nameSpan, receiver, name) {
+            var _this = _super.call(this, span, sourceSpan, nameSpan) || this;
             _this.receiver = receiver;
             _this.name = name;
             return _this;
@@ -7292,11 +7300,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return visitor.visitPropertyRead(this, context);
         };
         return PropertyRead;
-    }(AST));
+    }(ASTWithName));
     var PropertyWrite = /** @class */ (function (_super) {
         __extends(PropertyWrite, _super);
-        function PropertyWrite(span, sourceSpan, receiver, name, value) {
-            var _this = _super.call(this, span, sourceSpan) || this;
+        function PropertyWrite(span, sourceSpan, nameSpan, receiver, name, value) {
+            var _this = _super.call(this, span, sourceSpan, nameSpan) || this;
             _this.receiver = receiver;
             _this.name = name;
             _this.value = value;
@@ -7307,11 +7315,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return visitor.visitPropertyWrite(this, context);
         };
         return PropertyWrite;
-    }(AST));
+    }(ASTWithName));
     var SafePropertyRead = /** @class */ (function (_super) {
         __extends(SafePropertyRead, _super);
-        function SafePropertyRead(span, sourceSpan, receiver, name) {
-            var _this = _super.call(this, span, sourceSpan) || this;
+        function SafePropertyRead(span, sourceSpan, nameSpan, receiver, name) {
+            var _this = _super.call(this, span, sourceSpan, nameSpan) || this;
             _this.receiver = receiver;
             _this.name = name;
             return _this;
@@ -7321,7 +7329,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return visitor.visitSafePropertyRead(this, context);
         };
         return SafePropertyRead;
-    }(AST));
+    }(ASTWithName));
     var KeyedRead = /** @class */ (function (_super) {
         __extends(KeyedRead, _super);
         function KeyedRead(span, sourceSpan, obj, key) {
@@ -7354,11 +7362,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     var BindingPipe = /** @class */ (function (_super) {
         __extends(BindingPipe, _super);
         function BindingPipe(span, sourceSpan, exp, name, args, nameSpan) {
-            var _this = _super.call(this, span, sourceSpan) || this;
+            var _this = _super.call(this, span, sourceSpan, nameSpan) || this;
             _this.exp = exp;
             _this.name = name;
             _this.args = args;
-            _this.nameSpan = nameSpan;
             return _this;
         }
         BindingPipe.prototype.visit = function (visitor, context) {
@@ -7366,7 +7373,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return visitor.visitPipe(this, context);
         };
         return BindingPipe;
-    }(AST));
+    }(ASTWithName));
     var LiteralPrimitive = /** @class */ (function (_super) {
         __extends(LiteralPrimitive, _super);
         function LiteralPrimitive(span, sourceSpan, value) {
@@ -7464,8 +7471,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     }(AST));
     var MethodCall = /** @class */ (function (_super) {
         __extends(MethodCall, _super);
-        function MethodCall(span, sourceSpan, receiver, name, args) {
-            var _this = _super.call(this, span, sourceSpan) || this;
+        function MethodCall(span, sourceSpan, nameSpan, receiver, name, args) {
+            var _this = _super.call(this, span, sourceSpan, nameSpan) || this;
             _this.receiver = receiver;
             _this.name = name;
             _this.args = args;
@@ -7476,11 +7483,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return visitor.visitMethodCall(this, context);
         };
         return MethodCall;
-    }(AST));
+    }(ASTWithName));
     var SafeMethodCall = /** @class */ (function (_super) {
         __extends(SafeMethodCall, _super);
-        function SafeMethodCall(span, sourceSpan, receiver, name, args) {
-            var _this = _super.call(this, span, sourceSpan) || this;
+        function SafeMethodCall(span, sourceSpan, nameSpan, receiver, name, args) {
+            var _this = _super.call(this, span, sourceSpan, nameSpan) || this;
             _this.receiver = receiver;
             _this.name = name;
             _this.args = args;
@@ -7491,7 +7498,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return visitor.visitSafeMethodCall(this, context);
         };
         return SafeMethodCall;
-    }(AST));
+    }(ASTWithName));
     var FunctionCall = /** @class */ (function (_super) {
         __extends(FunctionCall, _super);
         function FunctionCall(span, sourceSpan, target, args) {
@@ -7678,19 +7685,19 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return new LiteralPrimitive(ast.span, ast.sourceSpan, ast.value);
         };
         AstTransformer.prototype.visitPropertyRead = function (ast, context) {
-            return new PropertyRead(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.name);
+            return new PropertyRead(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name);
         };
         AstTransformer.prototype.visitPropertyWrite = function (ast, context) {
-            return new PropertyWrite(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.name, ast.value.visit(this));
+            return new PropertyWrite(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name, ast.value.visit(this));
         };
         AstTransformer.prototype.visitSafePropertyRead = function (ast, context) {
-            return new SafePropertyRead(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.name);
+            return new SafePropertyRead(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name);
         };
         AstTransformer.prototype.visitMethodCall = function (ast, context) {
-            return new MethodCall(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.name, this.visitAll(ast.args));
+            return new MethodCall(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name, this.visitAll(ast.args));
         };
         AstTransformer.prototype.visitSafeMethodCall = function (ast, context) {
-            return new SafeMethodCall(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.name, this.visitAll(ast.args));
+            return new SafeMethodCall(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name, this.visitAll(ast.args));
         };
         AstTransformer.prototype.visitFunctionCall = function (ast, context) {
             return new FunctionCall(ast.span, ast.sourceSpan, ast.target.visit(this), this.visitAll(ast.args));
@@ -7757,7 +7764,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         AstMemoryEfficientTransformer.prototype.visitPropertyRead = function (ast, context) {
             var receiver = ast.receiver.visit(this);
             if (receiver !== ast.receiver) {
-                return new PropertyRead(ast.span, ast.sourceSpan, receiver, ast.name);
+                return new PropertyRead(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name);
             }
             return ast;
         };
@@ -7765,14 +7772,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var receiver = ast.receiver.visit(this);
             var value = ast.value.visit(this);
             if (receiver !== ast.receiver || value !== ast.value) {
-                return new PropertyWrite(ast.span, ast.sourceSpan, receiver, ast.name, value);
+                return new PropertyWrite(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name, value);
             }
             return ast;
         };
         AstMemoryEfficientTransformer.prototype.visitSafePropertyRead = function (ast, context) {
             var receiver = ast.receiver.visit(this);
             if (receiver !== ast.receiver) {
-                return new SafePropertyRead(ast.span, ast.sourceSpan, receiver, ast.name);
+                return new SafePropertyRead(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name);
             }
             return ast;
         };
@@ -7780,7 +7787,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var receiver = ast.receiver.visit(this);
             var args = this.visitAll(ast.args);
             if (receiver !== ast.receiver || args !== ast.args) {
-                return new MethodCall(ast.span, ast.sourceSpan, receiver, ast.name, args);
+                return new MethodCall(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name, args);
             }
             return ast;
         };
@@ -7788,7 +7795,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var receiver = ast.receiver.visit(this);
             var args = this.visitAll(ast.args);
             if (receiver !== ast.receiver || args !== ast.args) {
-                return new SafeMethodCall(ast.span, ast.sourceSpan, receiver, ast.name, args);
+                return new SafeMethodCall(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name, args);
             }
             return ast;
         };
@@ -8515,10 +8522,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             // 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.receiver, leftMostSafe.name, leftMostSafe.args));
+                this._nodeMap.set(leftMostSafe, new MethodCall(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan, leftMostSafe.receiver, leftMostSafe.name, leftMostSafe.args));
             }
             else {
-                this._nodeMap.set(leftMostSafe, new PropertyRead(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.receiver, leftMostSafe.name));
+                this._nodeMap.set(leftMostSafe, new PropertyRead(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan, leftMostSafe.receiver, leftMostSafe.name));
             }
             // Recursively convert the node now without the guarded member access.
             var access = this._visit(ast, _Mode.Expression);
@@ -14380,10 +14387,41 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(_ParseAST.prototype, "atEOF", {
+            /** Whether all the parser input has been processed. */
+            get: function () {
+                return this.index >= this.tokens.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
         Object.defineProperty(_ParseAST.prototype, "inputIndex", {
+            /**
+             * Index of the next token to be processed, or the end of the last token if all have been
+             * processed.
+             */
             get: function () {
-                return (this.index < this.tokens.length) ? this.next.index + this.offset :
-                    this.inputLength + this.offset;
+                return this.atEOF ? this.currentEndIndex : this.next.index + this.offset;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(_ParseAST.prototype, "currentEndIndex", {
+            /**
+             * End index of the last processed token, or the start of the first token if none have been
+             * processed.
+             */
+            get: function () {
+                if (this.index > 0) {
+                    var curToken = this.peek(-1);
+                    return curToken.end + this.offset;
+                }
+                // No tokens have been processed yet; return the next token's start or the length of the input
+                // if there is no token.
+                if (this.tokens.length === 0) {
+                    return this.inputLength + this.offset;
+                }
+                return this.next.index + this.offset;
             },
             enumerable: true,
             configurable: true
@@ -14399,12 +14437,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             configurable: true
         });
         _ParseAST.prototype.span = function (start) {
-            // `end` is either the
-            //   - end index of the current token
-            //   - start of the first token (this can happen e.g. when creating an implicit receiver)
-            var curToken = this.peek(-1);
-            var end = this.index > 0 ? curToken.end + this.offset : this.inputIndex;
-            return new ParseSpan(start, end);
+            return new ParseSpan(start, this.currentEndIndex);
         };
         _ParseAST.prototype.sourceSpan = function (start) {
             var serial = start + "@" + this.inputIndex;
@@ -14788,7 +14821,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         _ParseAST.prototype.parseAccessMemberOrMethodCall = function (receiver, isSafe) {
             if (isSafe === void 0) { isSafe = false; }
             var start = receiver.span.start;
+            var nameStart = this.inputIndex;
             var id = this.expectIdentifierOrKeyword();
+            var nameSpan = this.sourceSpan(nameStart);
             if (this.consumeOptionalCharacter($LPAREN)) {
                 this.rparensExpected++;
                 var args = this.parseCallArguments();
@@ -14796,8 +14831,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 this.rparensExpected--;
                 var span = this.span(start);
                 var sourceSpan = this.sourceSpan(start);
-                return isSafe ? new SafeMethodCall(span, sourceSpan, receiver, id, args) :
-                    new MethodCall(span, sourceSpan, receiver, id, args);
+                return isSafe ? new SafeMethodCall(span, sourceSpan, nameSpan, receiver, id, args) :
+                    new MethodCall(span, sourceSpan, nameSpan, receiver, id, args);
             }
             else {
                 if (isSafe) {
@@ -14806,7 +14841,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                         return new EmptyExpr(this.span(start), this.sourceSpan(start));
                     }
                     else {
-                        return new SafePropertyRead(this.span(start), this.sourceSpan(start), receiver, id);
+                        return new SafePropertyRead(this.span(start), this.sourceSpan(start), nameSpan, receiver, id);
                     }
                 }
                 else {
@@ -14816,10 +14851,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                             return new EmptyExpr(this.span(start), this.sourceSpan(start));
                         }
                         var value = this.parseConditional();
-                        return new PropertyWrite(this.span(start), this.sourceSpan(start), receiver, id, value);
+                        return new PropertyWrite(this.span(start), this.sourceSpan(start), nameSpan, receiver, id, value);
                     }
                     else {
-                        return new PropertyRead(this.span(start), this.sourceSpan(start), receiver, id);
+                        return new PropertyRead(this.span(start), this.sourceSpan(start), nameSpan, receiver, id);
                     }
                 }
             }
@@ -18114,7 +18149,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var slotPseudoLocal = "PIPE:" + slot;
             // Allocate one slot for the result plus one slot per pipe argument
             var pureFunctionSlot = this.allocatePureFunctionSlots(2 + pipe.args.length);
-            var target = new PropertyRead(pipe.span, pipe.sourceSpan, new ImplicitReceiver(pipe.span, pipe.sourceSpan), slotPseudoLocal);
+            var target = new PropertyRead(pipe.span, pipe.sourceSpan, pipe.nameSpan, new ImplicitReceiver(pipe.span, pipe.sourceSpan), slotPseudoLocal);
             var _a = pipeBindingCallInfo(pipe.args), identifier = _a.identifier, isVarLength = _a.isVarLength;
             this.definePipe(pipe.name, slotPseudoLocal, slot, importExpr(identifier));
             var args = __spread([pipe.exp], pipe.args);
@@ -19566,7 +19601,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 VERSION$1 = new Version('9.1.3');
+    var VERSION$1 = new Version('9.1.7');
 
     /**
      * @license
@@ -25729,6 +25764,250 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         BuiltinType[BuiltinType["Object"] = 128] = "Object";
     })(BuiltinType$1 || (BuiltinType$1 = {}));
 
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    function isParseSourceSpan(value) {
+        return value && !!value.start;
+    }
+    function spanOf(span) {
+        if (!span)
+            return undefined;
+        if (isParseSourceSpan(span)) {
+            return { start: span.start.offset, end: span.end.offset };
+        }
+        else {
+            if (span.endSourceSpan) {
+                return { start: span.sourceSpan.start.offset, end: span.endSourceSpan.end.offset };
+            }
+            else if (span.children && span.children.length) {
+                return {
+                    start: span.sourceSpan.start.offset,
+                    end: spanOf(span.children[span.children.length - 1]).end
+                };
+            }
+            return { start: span.sourceSpan.start.offset, end: span.sourceSpan.end.offset };
+        }
+    }
+    function inSpan(position, span, exclusive) {
+        return span != null &&
+            (exclusive ? position >= span.start && position < span.end :
+                position >= span.start && position <= span.end);
+    }
+    function offsetSpan(span, amount) {
+        return { start: span.start + amount, end: span.end + amount };
+    }
+    function isNarrower(spanA, spanB) {
+        return spanA.start >= spanB.start && spanA.end <= spanB.end;
+    }
+    function isStructuralDirective(type) {
+        var e_1, _a;
+        var _b;
+        try {
+            for (var _c = __values(type.diDeps), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var diDep = _d.value;
+                var diDepName = identifierName((_b = diDep.token) === null || _b === void 0 ? void 0 : _b.identifier);
+                if (diDepName === Identifiers.TemplateRef.name ||
+                    diDepName === Identifiers.ViewContainerRef.name) {
+                    return true;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return false;
+    }
+    function getSelectors(info) {
+        var e_2, _a, e_3, _b;
+        var map = new Map();
+        var results = [];
+        try {
+            for (var _c = __values(info.directives), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var directive = _d.value;
+                var selectors = CssSelector.parse(directive.selector);
+                try {
+                    for (var selectors_1 = (e_3 = void 0, __values(selectors)), selectors_1_1 = selectors_1.next(); !selectors_1_1.done; selectors_1_1 = selectors_1.next()) {
+                        var selector = selectors_1_1.value;
+                        results.push(selector);
+                        map.set(selector, directive);
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (selectors_1_1 && !selectors_1_1.done && (_b = selectors_1.return)) _b.call(selectors_1);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return { selectors: results, map: map };
+    }
+    function diagnosticInfoFromTemplateInfo(info) {
+        return {
+            fileName: info.template.fileName,
+            offset: info.template.span.start,
+            query: info.template.query,
+            members: info.template.members,
+            htmlAst: info.htmlAst,
+            templateAst: info.templateAst,
+            source: info.template.source,
+        };
+    }
+    function findTemplateAstAt(ast, position) {
+        var path = [];
+        var visitor = new /** @class */ (function (_super) {
+            __extends(class_1, _super);
+            function class_1() {
+                return _super !== null && _super.apply(this, arguments) || this;
+            }
+            class_1.prototype.visit = function (ast) {
+                var span = spanOf(ast);
+                if (inSpan(position, span)) {
+                    var len = path.length;
+                    if (!len || isNarrower(span, spanOf(path[len - 1]))) {
+                        path.push(ast);
+                    }
+                }
+                else {
+                    // Returning a value here will result in the children being skipped.
+                    return true;
+                }
+            };
+            class_1.prototype.visitEmbeddedTemplate = function (ast, context) {
+                return this.visitChildren(context, function (visit) {
+                    // Ignore reference, variable and providers
+                    visit(ast.attrs);
+                    visit(ast.directives);
+                    visit(ast.children);
+                });
+            };
+            class_1.prototype.visitElement = function (ast, context) {
+                return this.visitChildren(context, function (visit) {
+                    // Ingnore providers
+                    visit(ast.attrs);
+                    visit(ast.inputs);
+                    visit(ast.outputs);
+                    visit(ast.references);
+                    visit(ast.directives);
+                    visit(ast.children);
+                });
+            };
+            class_1.prototype.visitDirective = function (ast, context) {
+                // Ignore the host properties of a directive
+                var result = this.visitChildren(context, function (visit) {
+                    visit(ast.inputs);
+                });
+                // We never care about the diretive itself, just its inputs.
+                if (path[path.length - 1] === ast) {
+                    path.pop();
+                }
+                return result;
+            };
+            return class_1;
+        }(RecursiveTemplateAstVisitor));
+        templateVisitAll(visitor, ast);
+        return new AstPath(path, position);
+    }
+    /**
+     * Find the tightest node at the specified `position` from the AST `nodes`, and
+     * return the path to the node.
+     * @param nodes HTML AST nodes
+     * @param position
+     */
+    function getPathToNodeAtPosition(nodes, position) {
+        var path = [];
+        var visitor = new /** @class */ (function (_super) {
+            __extends(class_2, _super);
+            function class_2() {
+                return _super !== null && _super.apply(this, arguments) || this;
+            }
+            class_2.prototype.visit = function (ast) {
+                var span = spanOf(ast);
+                if (inSpan(position, span)) {
+                    path.push(ast);
+                }
+                else {
+                    // Returning a truthy value here will skip all children and terminate
+                    // the visit.
+                    return true;
+                }
+            };
+            return class_2;
+        }(RecursiveVisitor));
+        visitAll$1(visitor, nodes);
+        return new AstPath(path, position);
+    }
+    /**
+     * Inverts an object's key-value pairs.
+     */
+    function invertMap(obj) {
+        var e_4, _a;
+        var result = {};
+        try {
+            for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var name_1 = _c.value;
+                var v = obj[name_1];
+                result[v] = name_1;
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return result;
+    }
+    /**
+     * Finds the directive member providing a template output binding, if one exists.
+     * @param info aggregate template AST information
+     * @param path narrowing
+     */
+    function findOutputBinding(binding, path, query) {
+        var e_5, _a;
+        var element = path.first(ElementAst);
+        if (element) {
+            try {
+                for (var _b = __values(element.directives), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var directive = _c.value;
+                    var invertedOutputs = invertMap(directive.directive.outputs);
+                    var fieldName = invertedOutputs[binding.name];
+                    if (fieldName) {
+                        var classSymbol = query.getTypeSymbol(directive.directive.type.reference);
+                        if (classSymbol) {
+                            return classSymbol.members().get(fieldName);
+                        }
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }
+    }
+
     /**
      * @license
      * Copyright Google Inc. All Rights Reserved.
@@ -25751,7 +26030,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         AstType.prototype.getDiagnostics = function (ast) {
             var type = ast.visit(this);
             if (this.context.inEvent && type.callable) {
-                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.callable_expression_expected_method_call));
+                this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.callable_expression_expected_method_call));
             }
             return this.diagnostics;
         };
@@ -25770,7 +26049,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                             // Nullable allowed.
                             break;
                         default:
-                            _this_1.diagnostics.push(createDiagnostic(ast.span, Diagnostic.expression_might_be_null));
+                            _this_1.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.expression_might_be_null));
                             break;
                     }
                 }
@@ -25843,7 +26122,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                             this.diagnostics.push(createDiagnostic(ast.right.span, Diagnostic.expected_a_number_type));
                             return this.anyType;
                         default:
-                            this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.expected_a_string_or_number_type));
+                            this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.expected_a_string_or_number_type));
                             return this.anyType;
                     }
                 case '>':
@@ -25859,7 +26138,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                         // Two values are comparable only if
                         //   - they have some type overlap, or
                         //   - at least one is not defined
-                        this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.expected_operands_of_comparable_types_or_any));
+                        this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.expected_operands_of_comparable_types_or_any));
                     }
                     return this.query.getBuiltinType(BuiltinType$1.Boolean);
                 case '&&':
@@ -25867,7 +26146,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 case '||':
                     return this.query.getTypeUnion(leftType, rightType);
             }
-            this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.unrecognized_operator, ast.operation));
+            this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.unrecognized_operator, ast.operation));
             return this.anyType;
         };
         AstType.prototype.visitChain = function (ast) {
@@ -25905,7 +26184,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var args = ast.args.map(function (arg) { return _this_1.getType(arg); });
             var target = this.getType(ast.target);
             if (!target || !target.callable) {
-                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.call_target_not_callable, this.sourceOf(ast.target), target.name));
+                this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.call_target_not_callable, this.sourceOf(ast.target), target.name));
                 return this.anyType;
             }
             var signature = target.selectSignature(args);
@@ -25914,7 +26193,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             // TODO: Consider a better error message here. See `typescript_symbols#selectSignature` for more
             // details.
-            this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.unable_to_resolve_compatible_call_signature));
+            this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.unable_to_resolve_compatible_call_signature));
             return this.anyType;
         };
         AstType.prototype.visitImplicitReceiver = function (_ast) {
@@ -26020,7 +26299,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                         case 'number':
                             return this.query.getBuiltinType(BuiltinType$1.Number);
                         default:
-                            this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.unrecognized_primitive, typeof ast.value));
+                            this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.unrecognized_primitive, typeof ast.value));
                             return this.anyType;
                     }
             }
@@ -26034,13 +26313,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             // by getPipes() is expected to contain symbols with the corresponding transform method type.
             var pipe = this.query.getPipes().get(ast.name);
             if (!pipe) {
-                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.no_pipe_found, ast.name));
+                this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.no_pipe_found, ast.name));
                 return this.anyType;
             }
             var expType = this.getType(ast.exp);
             var signature = pipe.selectSignature([expType].concat(ast.args.map(function (arg) { return _this_1.getType(arg); })));
             if (!signature) {
-                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.unable_to_resolve_signature, ast.name));
+                this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.unable_to_resolve_signature, ast.name));
                 return this.anyType;
             }
             return signature.result;
@@ -26109,19 +26388,19 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             var methodType = this.resolvePropertyRead(receiverType, ast);
             if (!methodType) {
-                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.could_not_resolve_type, ast.name));
+                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(ast.span, Diagnostic.identifier_not_callable, ast.name));
+                this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.identifier_not_callable, ast.name));
                 return this.anyType;
             }
             var signature = methodType.selectSignature(ast.args.map(function (arg) { return _this_1.getType(arg); }));
             if (!signature) {
-                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.unable_to_resolve_signature, ast.name));
+                this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.unable_to_resolve_signature, ast.name));
                 return this.anyType;
             }
             return signature.result;
@@ -26134,20 +26413,20 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var member = receiverType.members().get(ast.name);
             if (!member) {
                 if (receiverType.name === '$implicit') {
-                    this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.identifier_not_defined_in_app_context, ast.name));
+                    this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.identifier_not_defined_in_app_context, ast.name));
                 }
                 else if (receiverType.nullable && ast.receiver instanceof PropertyRead) {
                     var receiver = ast.receiver.name;
-                    this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.identifier_possibly_undefined, receiver, receiver + "?." + ast.name, receiver + "!." + ast.name));
+                    this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.identifier_possibly_undefined, receiver, receiver + "?." + ast.name, receiver + "!." + ast.name));
                 }
                 else {
-                    this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.identifier_not_defined_on_receiver, ast.name, receiverType.name));
+                    this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.identifier_not_defined_on_receiver, ast.name, receiverType.name));
                 }
                 return this.anyType;
             }
             if (!member.public) {
                 var container = receiverType.name === '$implicit' ? 'the component' : "'" + receiverType.name + "'";
-                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.identifier_is_private, ast.name, container));
+                this.diagnostics.push(createDiagnostic(refinedSpan(ast), Diagnostic.identifier_is_private, ast.name, container));
             }
             return member.type;
         };
@@ -26157,379 +26436,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         };
         return AstType;
     }());
-
-    /**
-     * @license
-     * Copyright Google Inc. All Rights Reserved.
-     *
-     * Use of this source code is governed by an MIT-style license that can be
-     * found in the LICENSE file at https://angular.io/license
-     */
-    function isParseSourceSpan(value) {
-        return value && !!value.start;
-    }
-    function spanOf(span) {
-        if (!span)
-            return undefined;
-        if (isParseSourceSpan(span)) {
-            return { start: span.start.offset, end: span.end.offset };
-        }
-        else {
-            if (span.endSourceSpan) {
-                return { start: span.sourceSpan.start.offset, end: span.endSourceSpan.end.offset };
-            }
-            else if (span.children && span.children.length) {
-                return {
-                    start: span.sourceSpan.start.offset,
-                    end: spanOf(span.children[span.children.length - 1]).end
-                };
-            }
-            return { start: span.sourceSpan.start.offset, end: span.sourceSpan.end.offset };
-        }
-    }
-    function inSpan(position, span, exclusive) {
-        return span != null &&
-            (exclusive ? position >= span.start && position < span.end :
-                position >= span.start && position <= span.end);
-    }
-    function offsetSpan(span, amount) {
-        return { start: span.start + amount, end: span.end + amount };
-    }
-    function isNarrower(spanA, spanB) {
-        return spanA.start >= spanB.start && spanA.end <= spanB.end;
-    }
-    function isStructuralDirective(type) {
-        var e_1, _a;
-        var _b;
-        try {
-            for (var _c = __values(type.diDeps), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var diDep = _d.value;
-                var diDepName = identifierName((_b = diDep.token) === null || _b === void 0 ? void 0 : _b.identifier);
-                if (diDepName === Identifiers.TemplateRef.name ||
-                    diDepName === Identifiers.ViewContainerRef.name) {
-                    return true;
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return false;
-    }
-    function getSelectors(info) {
-        var e_2, _a, e_3, _b;
-        var map = new Map();
-        var results = [];
-        try {
-            for (var _c = __values(info.directives), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var directive = _d.value;
-                var selectors = CssSelector.parse(directive.selector);
-                try {
-                    for (var selectors_1 = (e_3 = void 0, __values(selectors)), selectors_1_1 = selectors_1.next(); !selectors_1_1.done; selectors_1_1 = selectors_1.next()) {
-                        var selector = selectors_1_1.value;
-                        results.push(selector);
-                        map.set(selector, directive);
-                    }
-                }
-                catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                finally {
-                    try {
-                        if (selectors_1_1 && !selectors_1_1.done && (_b = selectors_1.return)) _b.call(selectors_1);
-                    }
-                    finally { if (e_3) throw e_3.error; }
-                }
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        return { selectors: results, map: map };
-    }
-    function diagnosticInfoFromTemplateInfo(info) {
-        return {
-            fileName: info.template.fileName,
-            offset: info.template.span.start,
-            query: info.template.query,
-            members: info.template.members,
-            htmlAst: info.htmlAst,
-            templateAst: info.templateAst,
-            source: info.template.source,
-        };
-    }
-    function findTemplateAstAt(ast, position) {
-        var path = [];
-        var visitor = new /** @class */ (function (_super) {
-            __extends(class_1, _super);
-            function class_1() {
-                return _super !== null && _super.apply(this, arguments) || this;
-            }
-            class_1.prototype.visit = function (ast) {
-                var span = spanOf(ast);
-                if (inSpan(position, span)) {
-                    var len = path.length;
-                    if (!len || isNarrower(span, spanOf(path[len - 1]))) {
-                        path.push(ast);
-                    }
-                }
-                else {
-                    // Returning a value here will result in the children being skipped.
-                    return true;
-                }
-            };
-            class_1.prototype.visitEmbeddedTemplate = function (ast, context) {
-                return this.visitChildren(context, function (visit) {
-                    // Ignore reference, variable and providers
-                    visit(ast.attrs);
-                    visit(ast.directives);
-                    visit(ast.children);
-                });
-            };
-            class_1.prototype.visitElement = function (ast, context) {
-                return this.visitChildren(context, function (visit) {
-                    // Ingnore providers
-                    visit(ast.attrs);
-                    visit(ast.inputs);
-                    visit(ast.outputs);
-                    visit(ast.references);
-                    visit(ast.directives);
-                    visit(ast.children);
-                });
-            };
-            class_1.prototype.visitDirective = function (ast, context) {
-                // Ignore the host properties of a directive
-                var result = this.visitChildren(context, function (visit) {
-                    visit(ast.inputs);
-                });
-                // We never care about the diretive itself, just its inputs.
-                if (path[path.length - 1] === ast) {
-                    path.pop();
-                }
-                return result;
-            };
-            return class_1;
-        }(RecursiveTemplateAstVisitor));
-        templateVisitAll(visitor, ast);
-        return new AstPath(path, position);
-    }
-    /**
-     * Return the node that most tightly encompass the specified `position`.
-     * @param node
-     * @param position
-     */
-    function findTightestNode(node, position) {
-        if (node.getStart() <= position && position < node.getEnd()) {
-            return node.forEachChild(function (c) { return findTightestNode(c, position); }) || node;
-        }
-    }
-    /**
-     * Return metadata about `node` if it looks like an Angular directive class.
-     * In this case, potential matches are `@NgModule`, `@Component`, `@Directive`,
-     * `@Pipe`, etc.
-     * These class declarations all share some common attributes, namely their
-     * decorator takes exactly one parameter and the parameter must be an object
-     * literal.
-     *
-     * For example,
-     *     v---------- `decoratorId`
-     * @NgModule({           <
-     *   declarations: [],   < classDecl
-     * })                    <
-     * class AppModule {}    <
-     *          ^----- `classId`
-     *
-     * @param node Potential node that represents an Angular directive.
-     */
-    function getDirectiveClassLike(node) {
-        var e_4, _a;
-        if (!ts.isClassDeclaration(node) || !node.name || !node.decorators) {
-            return;
-        }
-        try {
-            for (var _b = __values(node.decorators), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var d = _c.value;
-                var expr = d.expression;
-                if (!ts.isCallExpression(expr) || expr.arguments.length !== 1 ||
-                    !ts.isIdentifier(expr.expression)) {
-                    continue;
-                }
-                var arg = expr.arguments[0];
-                if (ts.isObjectLiteralExpression(arg)) {
-                    return {
-                        decoratorId: expr.expression,
-                        classId: node.name,
-                    };
-                }
-            }
-        }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_4) throw e_4.error; }
-        }
-    }
-    /**
-     * Finds the value of a property assignment that is nested in a TypeScript node and is of a certain
-     * type T.
-     *
-     * @param startNode node to start searching for nested property assignment from
-     * @param propName property assignment name
-     * @param predicate function to verify that a node is of type T.
-     * @return node property assignment value of type T, or undefined if none is found
-     */
-    function findPropertyValueOfType(startNode, propName, predicate) {
-        if (ts.isPropertyAssignment(startNode) && startNode.name.getText() === propName) {
-            var initializer = startNode.initializer;
-            if (predicate(initializer))
-                return initializer;
-        }
-        return startNode.forEachChild(function (c) { return findPropertyValueOfType(c, propName, predicate); });
-    }
-    /**
-     * Find the tightest node at the specified `position` from the AST `nodes`, and
-     * return the path to the node.
-     * @param nodes HTML AST nodes
-     * @param position
-     */
-    function getPathToNodeAtPosition(nodes, position) {
-        var path = [];
-        var visitor = new /** @class */ (function (_super) {
-            __extends(class_2, _super);
-            function class_2() {
-                return _super !== null && _super.apply(this, arguments) || this;
-            }
-            class_2.prototype.visit = function (ast) {
-                var span = spanOf(ast);
-                if (inSpan(position, span)) {
-                    path.push(ast);
-                }
-                else {
-                    // Returning a truthy value here will skip all children and terminate
-                    // the visit.
-                    return true;
-                }
-            };
-            return class_2;
-        }(RecursiveVisitor));
-        visitAll$1(visitor, nodes);
-        return new AstPath(path, position);
-    }
-    /**
-     * Inverts an object's key-value pairs.
-     */
-    function invertMap(obj) {
-        var e_5, _a;
-        var result = {};
-        try {
-            for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var name_1 = _c.value;
-                var v = obj[name_1];
-                result[v] = name_1;
-            }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_5) throw e_5.error; }
-        }
-        return result;
-    }
-    /**
-     * Finds the directive member providing a template output binding, if one exists.
-     * @param info aggregate template AST information
-     * @param path narrowing
-     */
-    function findOutputBinding(binding, path, query) {
-        var e_6, _a;
-        var element = path.first(ElementAst);
-        if (element) {
-            try {
-                for (var _b = __values(element.directives), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var directive = _c.value;
-                    var invertedOutputs = invertMap(directive.directive.outputs);
-                    var fieldName = invertedOutputs[binding.name];
-                    if (fieldName) {
-                        var classSymbol = query.getTypeSymbol(directive.directive.type.reference);
-                        if (classSymbol) {
-                            return classSymbol.members().get(fieldName);
-                        }
-                    }
-                }
-            }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_6) throw e_6.error; }
-            }
-        }
-    }
-    /**
-     * Returns a property assignment from the assignment value, or `undefined` if there is no
-     * assignment.
-     */
-    function getPropertyAssignmentFromValue(value) {
-        if (!value.parent || !ts.isPropertyAssignment(value.parent)) {
-            return;
-        }
-        return value.parent;
-    }
-    /**
-     * Given a decorator property assignment, return the ClassDeclaration node that corresponds to the
-     * directive class the property applies to.
-     * If the property assignment is not on a class decorator, no declaration is returned.
-     *
-     * For example,
-     *
-     * @Component({
-     *   template: '<div></div>'
-     *   ^^^^^^^^^^^^^^^^^^^^^^^---- property assignment
-     * })
-     * class AppComponent {}
-     *           ^---- class declaration node
-     *
-     * @param propAsgn property assignment
-     */
-    function getClassDeclFromDecoratorProp(propAsgnNode) {
-        if (!propAsgnNode.parent || !ts.isObjectLiteralExpression(propAsgnNode.parent)) {
-            return;
+    function refinedSpan(ast) {
+        // nameSpan is an absolute span, but the spans returned by the expression visitor are expected to
+        // be relative to the start of the expression.
+        // TODO: migrate to only using absolute spans
+        var absoluteOffset = ast.sourceSpan.start - ast.span.start;
+        if (ast instanceof ASTWithName) {
+            return offsetSpan(ast.nameSpan, -absoluteOffset);
         }
-        var objLitExprNode = propAsgnNode.parent;
-        if (!objLitExprNode.parent || !ts.isCallExpression(objLitExprNode.parent)) {
-            return;
-        }
-        var callExprNode = objLitExprNode.parent;
-        if (!callExprNode.parent || !ts.isDecorator(callExprNode.parent)) {
-            return;
-        }
-        var decorator = callExprNode.parent;
-        if (!decorator.parent || !ts.isClassDeclaration(decorator.parent)) {
-            return;
-        }
-        var classDeclNode = decorator.parent;
-        return classDeclNode;
-    }
-    /**
-     * Determines if a property assignment is on a class decorator.
-     * See `getClassDeclFromDecoratorProperty`, which gets the class the decorator is applied to, for
-     * more details.
-     *
-     * @param prop property assignment
-     */
-    function isClassDecoratorProperty(propAsgn) {
-        return !!getClassDeclFromDecoratorProp(propAsgn);
+        return offsetSpan(ast.sourceSpan, -absoluteOffset);
     }
 
     /**
@@ -27058,6 +26973,16 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         function getType(ast) {
             return new AstType(scope, templateInfo.query, {}, templateInfo.source).getType(ast);
         }
+        function spanFromName(ast) {
+            // `nameSpan` is an absolute span, but the span expected by the result of this method is
+            // relative to the start of the expression.
+            // TODO(ayazhafiz): migrate to only using absolute spans
+            var offset = ast.sourceSpan.start - ast.span.start;
+            return {
+                start: ast.nameSpan.start - offset,
+                end: ast.nameSpan.end - offset,
+            };
+        }
         var symbol = undefined;
         var span = undefined;
         // If the completion request is in a not in a pipe or property access then the global scope
@@ -27078,21 +27003,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             visitMethodCall: function (ast) {
                 var receiverType = getType(ast.receiver);
                 symbol = receiverType && receiverType.members().get(ast.name);
-                span = ast.span;
+                span = spanFromName(ast);
             },
             visitPipe: function (ast) {
                 if (inSpan(position, ast.nameSpan, /* exclusive */ true)) {
                     // We are in a position a pipe name is expected.
                     var pipes = templateInfo.query.getPipes();
                     symbol = pipes.get(ast.name);
-                    // `nameSpan` is an absolute span, but the span expected by the result of this method is
-                    // relative to the start of the expression.
-                    // TODO(ayazhafiz): migrate to only using absolute spans
-                    var offset = ast.sourceSpan.start - ast.span.start;
-                    span = {
-                        start: ast.nameSpan.start - offset,
-                        end: ast.nameSpan.end - offset,
-                    };
+                    span = spanFromName(ast);
                 }
             },
             visitPrefixNot: function (_ast) { },
@@ -27100,29 +27018,23 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             visitPropertyRead: function (ast) {
                 var receiverType = getType(ast.receiver);
                 symbol = receiverType && receiverType.members().get(ast.name);
-                span = ast.span;
+                span = spanFromName(ast);
             },
             visitPropertyWrite: function (ast) {
                 var receiverType = getType(ast.receiver);
-                var start = ast.span.start;
                 symbol = receiverType && receiverType.members().get(ast.name);
-                // A PropertyWrite span includes both the LHS (name) and the RHS (value) of the write. In this
-                // visit, only the name is relevant.
-                //   prop=$event
-                //   ^^^^        name
-                //        ^^^^^^ value; visited separately as a nested AST
-                span = { start: start, end: start + ast.name.length };
+                span = spanFromName(ast);
             },
             visitQuote: function (_ast) { },
             visitSafeMethodCall: function (ast) {
                 var receiverType = getType(ast.receiver);
                 symbol = receiverType && receiverType.members().get(ast.name);
-                span = ast.span;
+                span = spanFromName(ast);
             },
             visitSafePropertyRead: function (ast) {
                 var receiverType = getType(ast.receiver);
                 symbol = receiverType && receiverType.members().get(ast.name);
-                span = ast.span;
+                span = spanFromName(ast);
             },
         });
         if (symbol && span) {
@@ -29203,7 +29115,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             // no-op for now
         };
         ExpressionVisitor.prototype.visitAttr = function (ast) {
-            var _this = this;
             var binding = getBindingDescriptor(ast.name);
             if (binding && binding.kind === ATTR.KW_MICROSYNTAX) {
                 // This a template binding given by micro syntax expression.
@@ -29217,8 +29128,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 var absKeyOffset = 0;
                 var absValueOffset = ast.sourceSpan.start.offset;
                 var templateBindings = this.info.expressionParser.parseTemplateBindings(templateKey, templateValue, templateUrl, absKeyOffset, absValueOffset).templateBindings;
-                // Find the template binding that contains the position.
-                var templateBinding = templateBindings.find(function (b) { return inSpan(_this.position, b.sourceSpan); });
+                // Find the nearest template binding to the position.
+                var lastBindingEnd = templateBindings.length > 0 &&
+                    templateBindings[templateBindings.length - 1].sourceSpan.end;
+                var normalizedPositionToBinding_1 = lastBindingEnd && this.position > lastBindingEnd ? lastBindingEnd : this.position;
+                var templateBinding = templateBindings.find(function (b) { return inSpan(normalizedPositionToBinding_1, b.sourceSpan); });
                 if (!templateBinding) {
                     return;
                 }
@@ -29827,6 +29741,136 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         return OverrideKindSymbol;
     }());
 
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    /**
+     * Return the node that most tightly encompass the specified `position`.
+     * @param node
+     * @param position
+     */
+    function findTightestNode(node, position) {
+        if (node.getStart() <= position && position < node.getEnd()) {
+            return node.forEachChild(function (c) { return findTightestNode(c, position); }) || node;
+        }
+    }
+    /**
+     * Returns a property assignment from the assignment value if the property name
+     * matches the specified `key`, or `undefined` if there is no match.
+     */
+    function getPropertyAssignmentFromValue(value, key) {
+        var propAssignment = value.parent;
+        if (!propAssignment || !tss.isPropertyAssignment(propAssignment) ||
+            propAssignment.name.getText() !== key) {
+            return;
+        }
+        return propAssignment;
+    }
+    /**
+     * Given a decorator property assignment, return the ClassDeclaration node that corresponds to the
+     * directive class the property applies to.
+     * If the property assignment is not on a class decorator, no declaration is returned.
+     *
+     * For example,
+     *
+     * @Component({
+     *   template: '<div></div>'
+     *   ^^^^^^^^^^^^^^^^^^^^^^^---- property assignment
+     * })
+     * class AppComponent {}
+     *           ^---- class declaration node
+     *
+     * @param propAsgn property assignment
+     */
+    function getClassDeclFromDecoratorProp(propAsgnNode) {
+        if (!propAsgnNode.parent || !tss.isObjectLiteralExpression(propAsgnNode.parent)) {
+            return;
+        }
+        var objLitExprNode = propAsgnNode.parent;
+        if (!objLitExprNode.parent || !tss.isCallExpression(objLitExprNode.parent)) {
+            return;
+        }
+        var callExprNode = objLitExprNode.parent;
+        if (!callExprNode.parent || !tss.isDecorator(callExprNode.parent)) {
+            return;
+        }
+        var decorator = callExprNode.parent;
+        if (!decorator.parent || !tss.isClassDeclaration(decorator.parent)) {
+            return;
+        }
+        var classDeclNode = decorator.parent;
+        return classDeclNode;
+    }
+    /**
+     * Return metadata about `node` if it looks like an Angular directive class.
+     * In this case, potential matches are `@NgModule`, `@Component`, `@Directive`,
+     * `@Pipe`, etc.
+     * These class declarations all share some common attributes, namely their
+     * decorator takes exactly one parameter and the parameter must be an object
+     * literal.
+     *
+     * For example,
+     *     v---------- `decoratorId`
+     * @NgModule({           <
+     *   declarations: [],   < classDecl
+     * })                    <
+     * class AppModule {}    <
+     *          ^----- `classId`
+     *
+     * @param node Potential node that represents an Angular directive.
+     */
+    function getDirectiveClassLike(node) {
+        var e_1, _a;
+        if (!tss.isClassDeclaration(node) || !node.name || !node.decorators) {
+            return;
+        }
+        try {
+            for (var _b = __values(node.decorators), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var d = _c.value;
+                var expr = d.expression;
+                if (!tss.isCallExpression(expr) || expr.arguments.length !== 1 ||
+                    !tss.isIdentifier(expr.expression)) {
+                    continue;
+                }
+                var arg = expr.arguments[0];
+                if (tss.isObjectLiteralExpression(arg)) {
+                    return {
+                        decoratorId: expr.expression,
+                        classId: node.name,
+                    };
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    /**
+     * Finds the value of a property assignment that is nested in a TypeScript node and is of a certain
+     * type T.
+     *
+     * @param startNode node to start searching for nested property assignment from
+     * @param propName property assignment name
+     * @param predicate function to verify that a node is of type T.
+     * @return node property assignment value of type T, or undefined if none is found
+     */
+    function findPropertyValueOfType(startNode, propName, predicate) {
+        if (tss.isPropertyAssignment(startNode) && startNode.name.getText() === propName) {
+            var initializer = startNode.initializer;
+            if (predicate(initializer))
+                return initializer;
+        }
+        return startNode.forEachChild(function (c) { return findPropertyValueOfType(c, propName, predicate); });
+    }
+
     /**
      * @license
      * Copyright Google Inc. All Rights Reserved.
@@ -29949,19 +29993,20 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         // `styleUrls`'s property assignment can be found from the array (parent) node.
         //
         // First search for `templateUrl`.
-        var asgn = getPropertyAssignmentFromValue(urlNode);
-        if (!asgn || asgn.name.getText() !== 'templateUrl') {
+        var asgn = getPropertyAssignmentFromValue(urlNode, 'templateUrl');
+        if (!asgn) {
             // `templateUrl` assignment not found; search for `styleUrls` array assignment.
-            asgn = getPropertyAssignmentFromValue(urlNode.parent);
-            if (!asgn || asgn.name.getText() !== 'styleUrls') {
+            asgn = getPropertyAssignmentFromValue(urlNode.parent, 'styleUrls');
+            if (!asgn) {
                 // Nothing found, bail.
                 return;
             }
         }
         // If the property assignment is not a property of a class decorator, don't generate definitions
         // for it.
-        if (!isClassDecoratorProperty(asgn))
+        if (!getClassDeclFromDecoratorProp(asgn)) {
             return;
+        }
         var sf = urlNode.getSourceFile();
         // Extract url path specified by the url node, which is relative to the TypeScript source file
         // the url node is defined in.
@@ -31623,7 +31668,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     var FLAGS = 2;
     var PARENT = 3;
     var NEXT = 4;
-    var QUERIES = 5;
+    var TRANSPLANTED_VIEWS_TO_REFRESH = 5;
     var T_HOST = 6;
     var CLEANUP = 7;
     var CONTEXT = 8;
@@ -31637,8 +31682,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     var DECLARATION_COMPONENT_VIEW = 16;
     var DECLARATION_LCONTAINER = 17;
     var PREORDER_HOOK_FLAGS = 18;
+    var QUERIES = 19;
     /** Size of LView's header. Necessary to adjust for it when setting slots.  */
-    var HEADER_OFFSET = 19;
+    var HEADER_OFFSET = 20;
 
     /**
      * @license
@@ -31659,19 +31705,19 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * Uglify will inline these when minifying so there shouldn't be a cost.
      */
     var ACTIVE_INDEX = 2;
-    // PARENT and NEXT are indices 3 and 4
+    // PARENT, NEXT, TRANSPLANTED_VIEWS_TO_REFRESH are indices 3, 4, and 5
     // As we already have these constants in LView, we don't need to re-create them.
-    var MOVED_VIEWS = 5;
     // T_HOST is index 6
     // We already have this constants in LView, we don't need to re-create it.
     var NATIVE = 7;
+    var MOVED_VIEWS = 9;
     /**
      * Size of LContainer's header. Represents the index after which all views in the
      * container will be inserted. We need to keep a record of current views so we know
      * which views are already in the DOM (and don't need to be re-added) and so we can
      * remove views from the DOM when they are no longer required.
      */
-    var CONTAINER_HEADER_OFFSET = 9;
+    var CONTAINER_HEADER_OFFSET = 10;
 
     /**
      * @license
@@ -31954,6 +32000,25 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     function getLContainerActiveIndex(lContainer) {
         return lContainer[ACTIVE_INDEX] >> 1 /* SHIFT */;
     }
+    /**
+     * Updates the `TRANSPLANTED_VIEWS_TO_REFRESH` counter on the `LContainer` as well as the parents
+     * whose
+     *  1. counter goes from 0 to 1, indicating that there is a new child that has a view to refresh
+     *  or
+     *  2. counter goes from 1 to 0, indicating there are no more descendant views to refresh
+     */
+    function updateTransplantedViewCount(lContainer, amount) {
+        lContainer[TRANSPLANTED_VIEWS_TO_REFRESH] += amount;
+        var viewOrContainer = lContainer;
+        var parent = lContainer[PARENT];
+        while (parent !== null &&
+            ((amount === 1 && viewOrContainer[TRANSPLANTED_VIEWS_TO_REFRESH] === 1) ||
+                (amount === -1 && viewOrContainer[TRANSPLANTED_VIEWS_TO_REFRESH] === 0))) {
+            parent[TRANSPLANTED_VIEWS_TO_REFRESH] += amount;
+            viewOrContainer = parent;
+            parent = parent[PARENT];
+        }
+    }
 
     /**
      * @license
@@ -32007,7 +32072,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     function setBindingRootForHostBindings(bindingRootIndex, currentDirectiveIndex) {
         var lFrame = instructionState.lFrame;
         lFrame.bindingIndex = lFrame.bindingRootIndex = bindingRootIndex;
-        lFrame.currentDirectiveIndex = currentDirectiveIndex;
+        setCurrentDirectiveIndex(currentDirectiveIndex);
+    }
+    /**
+     * Sets an index of a directive whose `hostBindings` are being processed.
+     *
+     * @param currentDirectiveIndex `TData` index where current directive instance can be found.
+     */
+    function setCurrentDirectiveIndex(currentDirectiveIndex) {
+        instructionState.lFrame.currentDirectiveIndex = currentDirectiveIndex;
     }
     function setCurrentQueryIndex(value) {
         instructionState.lFrame.currentQueryIndex = value;
@@ -32295,7 +32368,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             assertNotEqual(initPhase, 3 /* InitPhaseCompleted */, 'Init hooks phase should not be incremented after all init hooks have been run.');
         var flags = lView[FLAGS];
         if ((flags & 3 /* InitPhaseStateMask */) === initPhase) {
-            flags &= 1023 /* IndexWithinInitPhaseReset */;
+            flags &= 2047 /* IndexWithinInitPhaseReset */;
             flags += 1 /* InitPhaseStateIncrementer */;
             lView[FLAGS] = flags;
         }
@@ -32358,13 +32431,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         var directiveIndex = isInitHook ? -arr[i] : arr[i];
         var directive = currentView[directiveIndex];
         if (isInitHook) {
-            var indexWithintInitPhase = currentView[FLAGS] >> 10 /* IndexWithinInitPhaseShift */;
+            var indexWithintInitPhase = currentView[FLAGS] >> 11 /* IndexWithinInitPhaseShift */;
             // The init phase state must be always checked here as it may have been recursively
             // updated
             if (indexWithintInitPhase <
                 (currentView[PREORDER_HOOK_FLAGS] >> 16 /* NumberOfInitHooksCalledShift */) &&
                 (currentView[FLAGS] & 3 /* InitPhaseStateMask */) === initPhase) {
-                currentView[FLAGS] += 1024 /* IndexWithinInitPhaseIncrementer */;
+                currentView[FLAGS] += 2048 /* IndexWithinInitPhaseIncrementer */;
                 hook.call(directive);
             }
         }
@@ -34255,7 +34328,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         pipeRegistry, //
         firstChild, //
         schemas, //
-        consts) {
+        consts, //
+        incompleteFirstPass //
+        ) {
             this.type = type;
             this.id = id;
             this.blueprint = blueprint;
@@ -34286,6 +34361,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             this.firstChild = firstChild;
             this.schemas = schemas;
             this.consts = consts;
+            this.incompleteFirstPass = incompleteFirstPass;
         }
         Object.defineProperty(TView.prototype, "template_", {
             get: function () {
@@ -34559,7 +34635,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     attached: !!(flags & 128 /* Attached */),
                     destroyed: !!(flags & 256 /* Destroyed */),
                     isRoot: !!(flags & 512 /* IsRoot */),
-                    indexWithinInitPhase: flags >> 10 /* IndexWithinInitPhaseShift */,
+                    indexWithinInitPhase: flags >> 11 /* IndexWithinInitPhaseShift */,
                 };
             },
             enumerable: true,
@@ -35240,6 +35316,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 renderChildComponents(lView, components);
             }
         }
+        catch (error) {
+            // If we didn't manage to get past the first template pass due to
+            // an error, mark the view as corrupted so we can try to recover.
+            if (tView.firstCreatePass) {
+                tView.incompleteFirstPass = true;
+            }
+            throw error;
+        }
         finally {
             lView[FLAGS] &= ~4 /* CreationMode */;
             leaveView();
@@ -35284,6 +35368,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     incrementInitPhaseFlags(lView, 0 /* OnInitHooksToBeRun */);
                 }
             }
+            // First mark transplanted views that are declared in this lView as needing a refresh at their
+            // insertion points. This is needed to avoid the situation where the template is defined in this
+            // `LView` but its declaration appears after the insertion component.
+            markTransplantedViewsForRefresh(lView);
             refreshDynamicEmbeddedViews(lView);
             // Content query results must be refreshed before content hooks are called.
             if (tView.contentQueries !== null) {
@@ -35354,6 +35442,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             if (!checkNoChangesMode) {
                 lView[FLAGS] &= ~(64 /* Dirty */ | 8 /* FirstLViewPass */);
             }
+            if (lView[FLAGS] & 1024 /* RefreshTransplantedView */) {
+                lView[FLAGS] &= ~1024 /* RefreshTransplantedView */;
+                updateTransplantedViewCount(lView[PARENT], -1);
+            }
         }
         finally {
             leaveView();
@@ -35401,8 +35493,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * @returns TView
      */
     function getOrCreateTComponentView(def) {
-        return def.tView ||
-            (def.tView = createTView(1 /* Component */, -1, def.template, def.decls, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery, def.schemas, def.consts));
+        var tView = def.tView;
+        // Create a TView if there isn't one, or recreate it if the first create pass didn't
+        // complete successfuly since we can't know for sure whether it's in a usable shape.
+        if (tView === null || tView.incompleteFirstPass) {
+            return def.tView = createTView(1 /* Component */, -1, def.template, def.decls, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery, def.schemas, def.consts);
+        }
+        return tView;
     }
     /**
      * Creates a TView instance
@@ -35455,7 +35552,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             typeof pipes === 'function' ? pipes() : pipes, // pipeRegistry: PipeDefList|null,
             null, // firstChild: TNode|null,
             schemas, // schemas: SchemaMetadata[]|null,
-            consts) : // consts: TConstants|null
+            consts, // consts: TConstants|null
+            false // incompleteFirstPass: boolean
+            ) :
             {
                 type: type,
                 id: viewIndex,
@@ -35487,6 +35586,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 firstChild: null,
                 schemas: schemas,
                 consts: consts,
+                incompleteFirstPass: false
             };
     }
     function createViewBlueprint(bindingStartIndex, initialViewLength) {
@@ -35755,66 +35855,70 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * them by executing an associated template function.
      */
     function refreshDynamicEmbeddedViews(lView) {
-        var viewOrContainer = lView[CHILD_HEAD];
-        while (viewOrContainer !== null) {
-            // Note: viewOrContainer can be an LView or an LContainer instance, but here we are only
-            // interested in LContainer
-            var activeIndexFlag = void 0;
-            if (isLContainer(viewOrContainer) &&
-                (activeIndexFlag = viewOrContainer[ACTIVE_INDEX]) >> 1 /* SHIFT */ ===
-                    -1 /* DYNAMIC_EMBEDDED_VIEWS_ONLY */) {
-                for (var i = CONTAINER_HEADER_OFFSET; i < viewOrContainer.length; i++) {
-                    var embeddedLView = viewOrContainer[i];
-                    var embeddedTView = embeddedLView[TVIEW];
-                    ngDevMode && assertDefined(embeddedTView, 'TView must be allocated');
-                    if (viewAttachedToChangeDetector(embeddedLView)) {
-                        refreshView(embeddedTView, embeddedLView, embeddedTView.template, embeddedLView[CONTEXT]);
-                    }
-                }
-                if ((activeIndexFlag & 1 /* HAS_TRANSPLANTED_VIEWS */) !== 0) {
-                    // We should only CD moved views if the component where they were inserted does not match
-                    // the component where they were declared and insertion is on-push. Moved views also
-                    // contains intra component moves, or check-always which need to be skipped.
-                    refreshTransplantedViews(viewOrContainer, lView[DECLARATION_COMPONENT_VIEW]);
+        for (var lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
+            for (var i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+                var embeddedLView = lContainer[i];
+                var embeddedTView = embeddedLView[TVIEW];
+                ngDevMode && assertDefined(embeddedTView, 'TView must be allocated');
+                if (viewAttachedToChangeDetector(embeddedLView)) {
+                    refreshView(embeddedTView, embeddedLView, embeddedTView.template, embeddedLView[CONTEXT]);
                 }
             }
+        }
+    }
+    /**
+     * Gets the first `LContainer` in the LView or `null` if none exists.
+     */
+    function getFirstLContainer(lView) {
+        var viewOrContainer = lView[CHILD_HEAD];
+        while (viewOrContainer !== null &&
+            !(isLContainer(viewOrContainer) &&
+                viewOrContainer[ACTIVE_INDEX] >> 1 /* SHIFT */ ===
+                    -1 /* DYNAMIC_EMBEDDED_VIEWS_ONLY */)) {
             viewOrContainer = viewOrContainer[NEXT];
         }
+        return viewOrContainer;
     }
     /**
-     * Refresh transplanted LViews.
+     * Gets the next `LContainer` that is a sibling of the given container.
+     */
+    function getNextLContainer(container) {
+        var viewOrContainer = container[NEXT];
+        while (viewOrContainer !== null &&
+            !(isLContainer(viewOrContainer) &&
+                viewOrContainer[ACTIVE_INDEX] >> 1 /* SHIFT */ ===
+                    -1 /* DYNAMIC_EMBEDDED_VIEWS_ONLY */)) {
+            viewOrContainer = viewOrContainer[NEXT];
+        }
+        return viewOrContainer;
+    }
+    /**
+     * Mark transplanted views as needing to be refreshed at their insertion points.
      *
      * See: `ActiveIndexFlag.HAS_TRANSPLANTED_VIEWS` and `LView[DECLARATION_COMPONENT_VIEW]` for
      * explanation of transplanted views.
      *
-     * @param lContainer The `LContainer` which has transplanted views.
-     * @param declaredComponentLView The `lContainer` parent component `LView`.
-     */
-    function refreshTransplantedViews(lContainer, declaredComponentLView) {
-        var movedViews = lContainer[MOVED_VIEWS];
-        ngDevMode && assertDefined(movedViews, 'Transplanted View flags set but missing MOVED_VIEWS');
-        for (var i = 0; i < movedViews.length; i++) {
-            var movedLView = movedViews[i];
-            var insertionLContainer = movedLView[PARENT];
-            ngDevMode && assertLContainer(insertionLContainer);
-            var insertedComponentLView = insertionLContainer[PARENT][DECLARATION_COMPONENT_VIEW];
-            ngDevMode && assertDefined(insertedComponentLView, 'Missing LView');
-            // Check if we have a transplanted view by compering declaration and insertion location.
-            if (insertedComponentLView !== declaredComponentLView) {
-                // Yes the `LView` is transplanted.
-                // Here we would like to know if the component is `OnPush`. We don't have
-                // explicit `OnPush` flag instead we set `CheckAlways` to false (which is `OnPush`)
-                // Not to be confused with `ManualOnPush` which is used with wether a DOM event
-                // should automatically mark a view as dirty.
-                var insertionComponentIsOnPush = (insertedComponentLView[FLAGS] & 16 /* CheckAlways */) === 0;
-                if (insertionComponentIsOnPush) {
-                    // Here we know that the template has been transplanted across components and is
-                    // on-push (not just moved within a component). If the insertion is marked dirty, then
-                    // there is no need to CD here as we will do it again later when we get to insertion
-                    // point.
-                    var movedTView = movedLView[TVIEW];
-                    ngDevMode && assertDefined(movedTView, 'TView must be allocated');
-                    refreshView(movedTView, movedLView, movedTView.template, movedLView[CONTEXT]);
+     * @param lView The `LView` that may have transplanted views.
+     */
+    function markTransplantedViewsForRefresh(lView) {
+        for (var lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
+            if ((lContainer[ACTIVE_INDEX] & 1 /* HAS_TRANSPLANTED_VIEWS */) !== 0) {
+                var movedViews = lContainer[MOVED_VIEWS];
+                ngDevMode && assertDefined(movedViews, 'Transplanted View flags set but missing MOVED_VIEWS');
+                for (var i = 0; i < movedViews.length; i++) {
+                    var movedLView = movedViews[i];
+                    var insertionLContainer = movedLView[PARENT];
+                    ngDevMode && assertLContainer(insertionLContainer);
+                    // We don't want to increment the counter if the moved LView was already marked for
+                    // refresh.
+                    if ((movedLView[FLAGS] & 1024 /* RefreshTransplantedView */) === 0) {
+                        updateTransplantedViewCount(insertionLContainer, 1);
+                    }
+                    // Note, it is possible that the `movedViews` is tracking views that are transplanted *and*
+                    // those that aren't (declaration component === insertion component). In the latter case,
+                    // it's fine to add the flag, as we will clear it immediately in
+                    // `refreshDynamicEmbeddedViews` for the view currently being refreshed.
+                    movedLView[FLAGS] |= 1024 /* RefreshTransplantedView */;
                 }
             }
         }
@@ -35829,10 +35933,49 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         ngDevMode && assertEqual(isCreationMode(hostLView), false, 'Should be run in update mode');
         var componentView = getComponentLViewByIndex(componentHostIdx, hostLView);
         // Only attached components that are CheckAlways or OnPush and dirty should be refreshed
-        if (viewAttachedToChangeDetector(componentView) &&
-            componentView[FLAGS] & (16 /* CheckAlways */ | 64 /* Dirty */)) {
-            var componentTView = componentView[TVIEW];
-            refreshView(componentTView, componentView, componentTView.template, componentView[CONTEXT]);
+        if (viewAttachedToChangeDetector(componentView)) {
+            var tView = componentView[TVIEW];
+            if (componentView[FLAGS] & (16 /* CheckAlways */ | 64 /* Dirty */)) {
+                refreshView(tView, componentView, tView.template, componentView[CONTEXT]);
+            }
+            else if (componentView[TRANSPLANTED_VIEWS_TO_REFRESH] > 0) {
+                // Only attached components that are CheckAlways or OnPush and dirty should be refreshed
+                refreshContainsDirtyView(componentView);
+            }
+        }
+    }
+    /**
+     * Refreshes all transplanted views marked with `LViewFlags.RefreshTransplantedView` that are
+     * children or descendants of the given lView.
+     *
+     * @param lView The lView which contains descendant transplanted views that need to be refreshed.
+     */
+    function refreshContainsDirtyView(lView) {
+        for (var lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
+            for (var i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+                var embeddedLView = lContainer[i];
+                if (embeddedLView[FLAGS] & 1024 /* RefreshTransplantedView */) {
+                    var embeddedTView = embeddedLView[TVIEW];
+                    ngDevMode && assertDefined(embeddedTView, 'TView must be allocated');
+                    refreshView(embeddedTView, embeddedLView, embeddedTView.template, embeddedLView[CONTEXT]);
+                }
+                else if (embeddedLView[TRANSPLANTED_VIEWS_TO_REFRESH] > 0) {
+                    refreshContainsDirtyView(embeddedLView);
+                }
+            }
+        }
+        var tView = lView[TVIEW];
+        // Refresh child component views.
+        var components = tView.components;
+        if (components !== null) {
+            for (var i = 0; i < components.length; i++) {
+                var componentView = getComponentLViewByIndex(components[i], lView);
+                // Only attached components that are CheckAlways or OnPush and dirty should be refreshed
+                if (viewAttachedToChangeDetector(componentView) &&
+                    componentView[TRANSPLANTED_VIEWS_TO_REFRESH] > 0) {
+                    refreshContainsDirtyView(componentView);
+                }
+            }
         }
     }
     function renderComponent(hostLView, componentHostIdx) {
@@ -36135,8 +36278,16 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         ngDevMode &&
             assertDefined(declarationContainer[MOVED_VIEWS], 'A projected view should belong to a non-empty projected views collection');
         var movedViews = declarationContainer[MOVED_VIEWS];
-        var declaredViewIndex = movedViews.indexOf(lView);
-        movedViews.splice(declaredViewIndex, 1);
+        var declarationViewIndex = movedViews.indexOf(lView);
+        var insertionLContainer = lView[PARENT];
+        ngDevMode && assertLContainer(insertionLContainer);
+        // If the view was marked for refresh but then detached before it was checked (where the flag
+        // would be cleared and the counter decremented), we need to decrement the view counter here
+        // instead.
+        if (lView[FLAGS] & 1024 /* RefreshTransplantedView */) {
+            updateTransplantedViewCount(insertionLContainer, -1);
+        }
+        movedViews.splice(declarationViewIndex, 1);
     }
     /**
      * A standalone function which destroys an LView,
@@ -36849,10 +37000,18 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             else if (tNodeType === 1 /* Projection */) {
                 var componentView = lView[DECLARATION_COMPONENT_VIEW];
                 var componentHost = componentView[T_HOST];
-                var parentView = getLViewParent(componentView);
-                var firstProjectedNode = componentHost.projection[tNode.projection];
-                if (firstProjectedNode !== null && parentView !== null) {
-                    collectNativeNodes(parentView[TVIEW], parentView, firstProjectedNode, result, true);
+                var slotIdx = tNode.projection;
+                ngDevMode &&
+                    assertDefined(componentHost.projection, 'Components with projection nodes (<ng-content>) must have projection slots defined.');
+                var nodesInSlot = componentHost.projection[slotIdx];
+                if (Array.isArray(nodesInSlot)) {
+                    result.push.apply(result, __spread(nodesInSlot));
+                }
+                else {
+                    var parentView = getLViewParent(componentView);
+                    ngDevMode &&
+                        assertDefined(parentView, 'Component views should always have a parent view (component\'s host view)');
+                    collectNativeNodes(parentView[TVIEW], parentView, nodesInSlot, result, true);
                 }
             }
             tNode = isProjection ? tNode.projectionNext : tNode.next;
@@ -39973,7 +40132,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     /**
      * @publicApi
      */
-    var VERSION$2 = new Version$1('9.1.3');
+    var VERSION$2 = new Version$1('9.1.7');
 
     /**
      * @license
@@ -42798,14 +42957,18 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                         }
                     }
                 }
-                tElementNode = getTNode(rootLView[TVIEW], 0);
-                if (projectableNodes) {
-                    // projectable nodes can be passed as array of arrays or an array of iterables (ngUpgrade
-                    // case). Here we do normalize passed data structure to be an array of arrays to avoid
-                    // complex checks down the line.
-                    tElementNode.projection = projectableNodes.map(function (nodesforSlot) {
-                        return Array.from(nodesforSlot);
-                    });
+                tElementNode = getTNode(rootTView, 0);
+                if (projectableNodes !== undefined) {
+                    var projection = tElementNode.projection = [];
+                    for (var i = 0; i < this.ngContentSelectors.length; i++) {
+                        var nodesforSlot = projectableNodes[i];
+                        // Projectable nodes can be passed as array of arrays or an array of iterables (ngUpgrade
+                        // case). Here we do normalize passed data structure to be an array of arrays to avoid
+                        // complex checks down the line.
+                        // We also normalize the length of the passed in projectable nodes (to match the number of
+                        // <ng-container> slots defined by a component).
+                        projection.push(nodesforSlot != null ? Array.from(nodesforSlot) : null);
+                    }
                 }
                 // TODO: should LifecycleHooksFeature and other host features be generated by the compiler and
                 // executed here?
@@ -51666,9 +51829,20 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var filesChangedOrRemoved = [];
             // Check if any source files have been added / changed since last computation.
             var seen = new Set();
+            var ANGULAR_CORE = '@angular/core';
+            var corePath = this.reflectorHost.moduleNameToFileName(ANGULAR_CORE);
             try {
                 for (var _e = __values(program.getSourceFiles()), _f = _e.next(); !_f.done; _f = _e.next()) {
                     var fileName = _f.value.fileName;
+                    // If `@angular/core` is edited, the language service would have to be
+                    // restarted, so ignore changes to `@angular/core`.
+                    // When the StaticReflector is initialized at startup, it loads core
+                    // symbols from @angular/core by calling initializeConversionMap(). This
+                    // is only done once. If the file is invalidated, some of the core symbols
+                    // will be lost permanently.
+                    if (fileName === corePath) {
+                        continue;
+                    }
                     seen.add(fileName);
                     var version = this.tsLsHost.getScriptVersion(fileName);
                     var lastVersion = this.fileVersions.get(fileName);
@@ -51839,8 +52013,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             if (!tss.isStringLiteralLike(node)) {
                 return;
             }
-            var tmplAsgn = getPropertyAssignmentFromValue(node);
-            if (!tmplAsgn || tmplAsgn.name.getText() !== 'template') {
+            var tmplAsgn = getPropertyAssignmentFromValue(node, 'template');
+            if (!tmplAsgn) {
                 return;
             }
             var classDecl = getClassDeclFromDecoratorProp(tmplAsgn);