@angular/language-service 9.1.5 → 9.1.9

package/bundles/language-service.umd.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v9.1.5
+ * @license Angular v9.1.9
  * 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.5');
+    var VERSION$1 = new Version('9.1.9');
 
     /**
      * @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; }
-            }
+    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);
         }
-    }
-    /**
-     * 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;
-        }
-        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.
@@ -31659,7 +31704,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * without having to remember the specific indices.
      * Uglify will inline these when minifying so there shouldn't be a cost.
      */
-    var ACTIVE_INDEX = 2;
+    /**
+     * Flag to signify that this `LContainer` may have transplanted views which need to be change
+     * detected. (see: `LView[DECLARATION_COMPONENT_VIEW])`.
+     *
+     * This flag, once set, is never unset for the `LContainer`. This means that when unset we can skip
+     * a lot of work in `refreshEmbeddedViews`. But when set we still need to verify
+     * that the `MOVED_VIEWS` are transplanted and on-push.
+     */
+    var HAS_TRANSPLANTED_VIEWS = 2;
     // 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.
     // T_HOST is index 6
@@ -31952,9 +32005,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     function resetPreOrderHookFlags(lView) {
         lView[PREORDER_HOOK_FLAGS] = 0;
     }
-    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
@@ -34070,6 +34120,24 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         var parent = lView[PARENT];
         return isLContainer(parent) ? parent[PARENT] : parent;
     }
+    /**
+     * Gets the first `LContainer` in the LView or `null` if none exists.
+     */
+    function getFirstLContainer(lView) {
+        return getNearestLContainer(lView[CHILD_HEAD]);
+    }
+    /**
+     * Gets the next `LContainer` that is a sibling of the given container.
+     */
+    function getNextLContainer(container) {
+        return getNearestLContainer(container[NEXT]);
+    }
+    function getNearestLContainer(viewOrContainer) {
+        while (viewOrContainer !== null && !isLContainer(viewOrContainer)) {
+            viewOrContainer = viewOrContainer[NEXT];
+        }
+        return viewOrContainer;
+    }
 
     /**
      * @license
@@ -34354,8 +34422,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         parent, //
         projection, //
         styles, //
+        stylesWithoutHost, //
         residualStyles, //
         classes, //
+        classesWithoutHost, //
         residualClasses, //
         classBindings, //
         styleBindings) {
@@ -34383,8 +34453,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             this.parent = parent;
             this.projection = projection;
             this.styles = styles;
+            this.stylesWithoutHost = stylesWithoutHost;
             this.residualStyles = residualStyles;
             this.classes = classes;
+            this.classesWithoutHost = classesWithoutHost;
             this.residualClasses = residualClasses;
             this.classBindings = classBindings;
             this.styleBindings = styleBindings;
@@ -34775,17 +34847,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         function LContainerDebug(_raw_lContainer) {
             this._raw_lContainer = _raw_lContainer;
         }
-        Object.defineProperty(LContainerDebug.prototype, "activeIndex", {
-            get: function () {
-                return getLContainerActiveIndex(this._raw_lContainer);
-            },
-            enumerable: true,
-            configurable: true
-        });
         Object.defineProperty(LContainerDebug.prototype, "hasTransplantedViews", {
             get: function () {
-                return (this._raw_lContainer[ACTIVE_INDEX] & 1 /* HAS_TRANSPLANTED_VIEWS */) ===
-                    1 /* HAS_TRANSPLANTED_VIEWS */;
+                return this._raw_lContainer[HAS_TRANSPLANTED_VIEWS];
             },
             enumerable: true,
             configurable: true
@@ -35219,7 +35283,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             tView.node = tNode = createTNode(tView, tParentNode, //
             2 /* View */, index, null, null);
         }
-        return lView[T_HOST] = tNode;
+        lView[T_HOST] = tNode;
     }
     //////////////////////////
     //// Render
@@ -35327,7 +35391,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             // 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);
+            refreshEmbeddedViews(lView);
             // Content query results must be refreshed before content hooks are called.
             if (tView.contentQueries !== null) {
                 refreshContentQueries(tView, lView);
@@ -35640,8 +35704,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         tParent, // parent: TElementNode|TContainerNode|null
         null, // projection: number|(ITNode|RNode[])[]|null
         null, // styles: string|null
+        null, // stylesWithoutHost: string|null
         undefined, // residualStyles: string|null
         null, // classes: string|null
+        null, // classesWithoutHost: string|null
         undefined, // residualClasses: string|null
         0, // classBindings: TStylingRange;
         0) :
@@ -35669,8 +35735,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 parent: tParent,
                 projection: null,
                 styles: null,
+                stylesWithoutHost: null,
                 residualStyles: undefined,
                 classes: null,
+                classesWithoutHost: null,
                 residualClasses: undefined,
                 classBindings: 0,
                 styleBindings: 0,
@@ -35806,10 +35874,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     var LContainerArray = ((typeof ngDevMode === 'undefined' || ngDevMode) && initNgDevMode()) &&
         createNamedArrayType('LContainer');
     /**
-     * Goes over dynamic embedded views (ones created through ViewContainerRef APIs) and refreshes
+     * Goes over embedded views (ones created through ViewContainerRef APIs) and refreshes
      * them by executing an associated template function.
      */
-    function refreshDynamicEmbeddedViews(lView) {
+    function refreshEmbeddedViews(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];
@@ -35821,60 +35889,31 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
         }
     }
-    /**
-     * 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;
-    }
-    /**
-     * 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 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 */;
+            if (!lContainer[HAS_TRANSPLANTED_VIEWS])
+                continue;
+            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
+                // `refreshEmbeddedViews` for the view currently being refreshed.
+                movedLView[FLAGS] |= 1024 /* RefreshTransplantedView */;
             }
         }
     }
@@ -36654,10 +36693,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             this._cdRefInjectingView = _cdRefInjectingView;
             this._appRef = null;
             this._viewContainerRef = null;
-            /**
-             * @internal
-             */
-            this._tViewNode = null;
         }
         Object.defineProperty(ViewRef.prototype, "rootNodes", {
             get: function () {
@@ -37105,7 +37140,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     var DELEGATE_CTOR = /^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*arguments\)/;
     var INHERITED_CLASS = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{/;
     var INHERITED_CLASS_WITH_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(/;
-    var INHERITED_CLASS_WITH_DELEGATE_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{\s+super\(\.\.\.arguments\)/;
+    var INHERITED_CLASS_WITH_DELEGATE_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{\s*super\(\.\.\.arguments\)/;
     /**
      * Determine whether a stringified type is a class which delegates its constructor
      * to its parent.
@@ -39240,29 +39275,34 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      *
      * @param tNode The `TNode` into which the styling information should be loaded.
      * @param attrs `TAttributes` containing the styling information.
+     * @param writeToHost Where should the resulting static styles be written?
+     *   - `false` Write to `TNode.stylesWithoutHost` / `TNode.classesWithoutHost`
+     *   - `true` Write to `TNode.styles` / `TNode.classes`
      */
-    function computeStaticStyling(tNode, attrs) {
+    function computeStaticStyling(tNode, attrs, writeToHost) {
         ngDevMode &&
             assertFirstCreatePass(getTView(), 'Expecting to be called in first template pass only');
-        var styles = tNode.styles;
-        var classes = tNode.classes;
+        var styles = writeToHost ? tNode.styles : null;
+        var classes = writeToHost ? tNode.classes : null;
         var mode = 0;
-        for (var i = 0; i < attrs.length; i++) {
-            var value = attrs[i];
-            if (typeof value === 'number') {
-                mode = value;
-            }
-            else if (mode == 1 /* Classes */) {
-                classes = concatStringsWithSpace(classes, value);
-            }
-            else if (mode == 2 /* Styles */) {
-                var style = value;
-                var styleValue = attrs[++i];
-                styles = concatStringsWithSpace(styles, style + ': ' + styleValue + ';');
+        if (attrs !== null) {
+            for (var i = 0; i < attrs.length; i++) {
+                var value = attrs[i];
+                if (typeof value === 'number') {
+                    mode = value;
+                }
+                else if (mode == 1 /* Classes */) {
+                    classes = concatStringsWithSpace(classes, value);
+                }
+                else if (mode == 2 /* Styles */) {
+                    var style = value;
+                    var styleValue = attrs[++i];
+                    styles = concatStringsWithSpace(styles, style + ': ' + styleValue + ';');
+                }
             }
         }
-        styles !== null && (tNode.styles = styles);
-        classes !== null && (tNode.classes = classes);
+        writeToHost ? tNode.styles = styles : tNode.stylesWithoutHost = styles;
+        writeToHost ? tNode.classes = classes : tNode.classesWithoutHost = classes;
     }
 
     /**
@@ -39724,7 +39764,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         var tNode = getOrCreateTNode(tView, null, 0, 3 /* Element */, null, null);
         var mergedAttrs = tNode.mergedAttrs = def.hostAttrs;
         if (mergedAttrs !== null) {
-            computeStaticStyling(tNode, mergedAttrs);
+            computeStaticStyling(tNode, mergedAttrs, true);
             if (rNode !== null) {
                 setUpAttributes(hostRenderer, rNode, mergedAttrs);
                 if (tNode.classes !== null) {
@@ -40087,7 +40127,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     /**
      * @publicApi
      */
-    var VERSION$2 = new Version$1('9.1.5');
+    var VERSION$2 = new Version$1('9.1.9');
 
     /**
      * @license
@@ -42938,7 +42978,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             if (!rootSelectorOrNode || isIsolated) {
                 // The host element of the internal or isolated root view is attached to the component's host
                 // view node.
-                componentRef.hostView._tViewNode.child = tElementNode;
+                ngDevMode && assertNodeOfPossibleTypes(rootTView.node, 2 /* View */);
+                rootTView.node.child = tElementNode;
             }
             return componentRef;
         };
@@ -42963,7 +43004,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             _this.destroyCbs = [];
             _this.instance = instance;
             _this.hostView = _this.changeDetectorRef = new RootViewRef(_rootLView);
-            _this.hostView._tViewNode = assignTViewNodeToLView(_rootLView[TVIEW], null, -1, _rootLView);
+            assignTViewNodeToLView(_rootLView[TVIEW], null, -1, _rootLView);
             _this.componentType = componentType;
             return _this;
         }
@@ -51968,8 +52009,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);