@angular/language-service 8.1.0-next.3 → 8.1.2

package/bundles/language-service.umd.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v8.1.0-next.3
+ * @license Angular v8.1.2
  * (c) 2010-2019 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2502,6 +2502,9 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         if (token.name) {
             return "" + token.name;
         }
+        if (!token.toString) {
+            return 'object';
+        }
         // WARNING: do not try to `JSON.stringify(token)` here
         // see https://github.com/angular/angular/issues/23440
         var res = token.toString();
@@ -3389,7 +3392,6 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         Identifiers.templateCreate = { name: 'ɵɵtemplate', moduleName: CORE$1 };
         Identifiers.text = { name: 'ɵɵtext', moduleName: CORE$1 };
         Identifiers.textBinding = { name: 'ɵɵtextBinding', moduleName: CORE$1 };
-        Identifiers.bind = { name: 'ɵɵbind', moduleName: CORE$1 };
         Identifiers.enableBindings = { name: 'ɵɵenableBindings', moduleName: CORE$1 };
         Identifiers.disableBindings = { name: 'ɵɵdisableBindings', moduleName: CORE$1 };
         Identifiers.allocHostVars = { name: 'ɵɵallocHostVars', moduleName: CORE$1 };
@@ -3525,6 +3527,237 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         return Identifiers;
     }());
 
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    var $EOF = 0;
+    var $BSPACE = 8;
+    var $TAB = 9;
+    var $LF = 10;
+    var $VTAB = 11;
+    var $FF = 12;
+    var $CR = 13;
+    var $SPACE = 32;
+    var $BANG = 33;
+    var $DQ = 34;
+    var $HASH = 35;
+    var $$ = 36;
+    var $PERCENT = 37;
+    var $AMPERSAND = 38;
+    var $SQ = 39;
+    var $LPAREN = 40;
+    var $RPAREN = 41;
+    var $STAR = 42;
+    var $PLUS = 43;
+    var $COMMA = 44;
+    var $MINUS = 45;
+    var $PERIOD = 46;
+    var $SLASH = 47;
+    var $COLON = 58;
+    var $SEMICOLON = 59;
+    var $LT = 60;
+    var $EQ = 61;
+    var $GT = 62;
+    var $QUESTION = 63;
+    var $0 = 48;
+    var $7 = 55;
+    var $9 = 57;
+    var $A = 65;
+    var $E = 69;
+    var $F = 70;
+    var $X = 88;
+    var $Z = 90;
+    var $LBRACKET = 91;
+    var $BACKSLASH = 92;
+    var $RBRACKET = 93;
+    var $CARET = 94;
+    var $_ = 95;
+    var $a = 97;
+    var $b = 98;
+    var $e = 101;
+    var $f = 102;
+    var $n = 110;
+    var $r = 114;
+    var $t = 116;
+    var $u = 117;
+    var $v = 118;
+    var $x = 120;
+    var $z = 122;
+    var $LBRACE = 123;
+    var $BAR = 124;
+    var $RBRACE = 125;
+    var $NBSP = 160;
+    var $BT = 96;
+    function isWhitespace(code) {
+        return (code >= $TAB && code <= $SPACE) || (code == $NBSP);
+    }
+    function isDigit(code) {
+        return $0 <= code && code <= $9;
+    }
+    function isAsciiLetter(code) {
+        return code >= $a && code <= $z || code >= $A && code <= $Z;
+    }
+    function isAsciiHexDigit(code) {
+        return code >= $a && code <= $f || code >= $A && code <= $F || isDigit(code);
+    }
+    function isNewLine(code) {
+        return code === $LF || code === $CR;
+    }
+    function isOctalDigit(code) {
+        return $0 <= code && code <= $7;
+    }
+
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    var ParseLocation = /** @class */ (function () {
+        function ParseLocation(file, offset, line, col) {
+            this.file = file;
+            this.offset = offset;
+            this.line = line;
+            this.col = col;
+        }
+        ParseLocation.prototype.toString = function () {
+            return this.offset != null ? this.file.url + "@" + this.line + ":" + this.col : this.file.url;
+        };
+        ParseLocation.prototype.moveBy = function (delta) {
+            var source = this.file.content;
+            var len = source.length;
+            var offset = this.offset;
+            var line = this.line;
+            var col = this.col;
+            while (offset > 0 && delta < 0) {
+                offset--;
+                delta++;
+                var ch = source.charCodeAt(offset);
+                if (ch == $LF) {
+                    line--;
+                    var priorLine = source.substr(0, offset - 1).lastIndexOf(String.fromCharCode($LF));
+                    col = priorLine > 0 ? offset - priorLine : offset;
+                }
+                else {
+                    col--;
+                }
+            }
+            while (offset < len && delta > 0) {
+                var ch = source.charCodeAt(offset);
+                offset++;
+                delta--;
+                if (ch == $LF) {
+                    line++;
+                    col = 0;
+                }
+                else {
+                    col++;
+                }
+            }
+            return new ParseLocation(this.file, offset, line, col);
+        };
+        // Return the source around the location
+        // Up to `maxChars` or `maxLines` on each side of the location
+        ParseLocation.prototype.getContext = function (maxChars, maxLines) {
+            var content = this.file.content;
+            var startOffset = this.offset;
+            if (startOffset != null) {
+                if (startOffset > content.length - 1) {
+                    startOffset = content.length - 1;
+                }
+                var endOffset = startOffset;
+                var ctxChars = 0;
+                var ctxLines = 0;
+                while (ctxChars < maxChars && startOffset > 0) {
+                    startOffset--;
+                    ctxChars++;
+                    if (content[startOffset] == '\n') {
+                        if (++ctxLines == maxLines) {
+                            break;
+                        }
+                    }
+                }
+                ctxChars = 0;
+                ctxLines = 0;
+                while (ctxChars < maxChars && endOffset < content.length - 1) {
+                    endOffset++;
+                    ctxChars++;
+                    if (content[endOffset] == '\n') {
+                        if (++ctxLines == maxLines) {
+                            break;
+                        }
+                    }
+                }
+                return {
+                    before: content.substring(startOffset, this.offset),
+                    after: content.substring(this.offset, endOffset + 1),
+                };
+            }
+            return null;
+        };
+        return ParseLocation;
+    }());
+    var ParseSourceFile = /** @class */ (function () {
+        function ParseSourceFile(content, url) {
+            this.content = content;
+            this.url = url;
+        }
+        return ParseSourceFile;
+    }());
+    var ParseSourceSpan = /** @class */ (function () {
+        function ParseSourceSpan(start, end, details) {
+            if (details === void 0) { details = null; }
+            this.start = start;
+            this.end = end;
+            this.details = details;
+        }
+        ParseSourceSpan.prototype.toString = function () {
+            return this.start.file.content.substring(this.start.offset, this.end.offset);
+        };
+        return ParseSourceSpan;
+    }());
+    var ParseErrorLevel;
+    (function (ParseErrorLevel) {
+        ParseErrorLevel[ParseErrorLevel["WARNING"] = 0] = "WARNING";
+        ParseErrorLevel[ParseErrorLevel["ERROR"] = 1] = "ERROR";
+    })(ParseErrorLevel || (ParseErrorLevel = {}));
+    var ParseError = /** @class */ (function () {
+        function ParseError(span, msg, level) {
+            if (level === void 0) { level = ParseErrorLevel.ERROR; }
+            this.span = span;
+            this.msg = msg;
+            this.level = level;
+        }
+        ParseError.prototype.contextualMessage = function () {
+            var ctx = this.span.start.getContext(100, 3);
+            return ctx ? this.msg + " (\"" + ctx.before + "[" + ParseErrorLevel[this.level] + " ->]" + ctx.after + "\")" :
+                this.msg;
+        };
+        ParseError.prototype.toString = function () {
+            var details = this.span.details ? ", " + this.span.details : '';
+            return this.contextualMessage() + ": " + this.span.start + details;
+        };
+        return ParseError;
+    }());
+    /**
+     * Generates Source Span object for a given R3 Type for JIT mode.
+     *
+     * @param kind Component or Directive.
+     * @param typeName name of the Component or Directive.
+     * @param sourceUrl reference to Component or Directive source.
+     * @returns instance of ParseSourceSpan that represent a given Component or Directive.
+     */
+    function r3JitTypeSourceSpan(kind, typeName, sourceUrl) {
+        var sourceFileName = "in " + kind + " " + typeName + " in " + sourceUrl;
+        var sourceFile = new ParseSourceFile('', sourceFileName);
+        return new ParseSourceSpan(new ParseLocation(sourceFile, -1, -1, -1), new ParseLocation(sourceFile, -1, -1, -1));
+    }
+
     /**
      * @license
      * Copyright Google Inc. All Rights Reserved.
@@ -3608,7 +3841,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             this.i18n = i18n;
             // If the element is empty then the source span should include any closing tag
             if (children.length === 0 && startSourceSpan && endSourceSpan) {
-                this.sourceSpan = __assign({}, sourceSpan, { end: endSourceSpan.end });
+                this.sourceSpan = new ParseSourceSpan(sourceSpan.start, endSourceSpan.end);
             }
         }
         Element.prototype.visit = function (visitor) { return visitor.visitElement(this); };
@@ -4751,7 +4984,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
      * TODO(FW-1136): this is a temporary solution, we need to come up with a better way of working with
      * inputs that contain potentially unsafe chars.
      */
-    var UNSAFE_OBJECT_KEY_NAME_REGEXP = /-/;
+    var UNSAFE_OBJECT_KEY_NAME_REGEXP = /[-.]/;
     /** Name of the temporary to use during data binding */
     var TEMPORARY_NAME = '_t';
     /** Name of the context parameter passed into a template function */
@@ -6195,237 +6428,6 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         return statement.isEquivalent(literal('use strict').toStmt());
     }
 
-    /**
-     * @license
-     * Copyright Google Inc. All Rights Reserved.
-     *
-     * Use of this source code is governed by an MIT-style license that can be
-     * found in the LICENSE file at https://angular.io/license
-     */
-    var $EOF = 0;
-    var $BSPACE = 8;
-    var $TAB = 9;
-    var $LF = 10;
-    var $VTAB = 11;
-    var $FF = 12;
-    var $CR = 13;
-    var $SPACE = 32;
-    var $BANG = 33;
-    var $DQ = 34;
-    var $HASH = 35;
-    var $$ = 36;
-    var $PERCENT = 37;
-    var $AMPERSAND = 38;
-    var $SQ = 39;
-    var $LPAREN = 40;
-    var $RPAREN = 41;
-    var $STAR = 42;
-    var $PLUS = 43;
-    var $COMMA = 44;
-    var $MINUS = 45;
-    var $PERIOD = 46;
-    var $SLASH = 47;
-    var $COLON = 58;
-    var $SEMICOLON = 59;
-    var $LT = 60;
-    var $EQ = 61;
-    var $GT = 62;
-    var $QUESTION = 63;
-    var $0 = 48;
-    var $7 = 55;
-    var $9 = 57;
-    var $A = 65;
-    var $E = 69;
-    var $F = 70;
-    var $X = 88;
-    var $Z = 90;
-    var $LBRACKET = 91;
-    var $BACKSLASH = 92;
-    var $RBRACKET = 93;
-    var $CARET = 94;
-    var $_ = 95;
-    var $a = 97;
-    var $b = 98;
-    var $e = 101;
-    var $f = 102;
-    var $n = 110;
-    var $r = 114;
-    var $t = 116;
-    var $u = 117;
-    var $v = 118;
-    var $x = 120;
-    var $z = 122;
-    var $LBRACE = 123;
-    var $BAR = 124;
-    var $RBRACE = 125;
-    var $NBSP = 160;
-    var $BT = 96;
-    function isWhitespace(code) {
-        return (code >= $TAB && code <= $SPACE) || (code == $NBSP);
-    }
-    function isDigit(code) {
-        return $0 <= code && code <= $9;
-    }
-    function isAsciiLetter(code) {
-        return code >= $a && code <= $z || code >= $A && code <= $Z;
-    }
-    function isAsciiHexDigit(code) {
-        return code >= $a && code <= $f || code >= $A && code <= $F || isDigit(code);
-    }
-    function isNewLine(code) {
-        return code === $LF || code === $CR;
-    }
-    function isOctalDigit(code) {
-        return $0 <= code && code <= $7;
-    }
-
-    /**
-     * @license
-     * Copyright Google Inc. All Rights Reserved.
-     *
-     * Use of this source code is governed by an MIT-style license that can be
-     * found in the LICENSE file at https://angular.io/license
-     */
-    var ParseLocation = /** @class */ (function () {
-        function ParseLocation(file, offset, line, col) {
-            this.file = file;
-            this.offset = offset;
-            this.line = line;
-            this.col = col;
-        }
-        ParseLocation.prototype.toString = function () {
-            return this.offset != null ? this.file.url + "@" + this.line + ":" + this.col : this.file.url;
-        };
-        ParseLocation.prototype.moveBy = function (delta) {
-            var source = this.file.content;
-            var len = source.length;
-            var offset = this.offset;
-            var line = this.line;
-            var col = this.col;
-            while (offset > 0 && delta < 0) {
-                offset--;
-                delta++;
-                var ch = source.charCodeAt(offset);
-                if (ch == $LF) {
-                    line--;
-                    var priorLine = source.substr(0, offset - 1).lastIndexOf(String.fromCharCode($LF));
-                    col = priorLine > 0 ? offset - priorLine : offset;
-                }
-                else {
-                    col--;
-                }
-            }
-            while (offset < len && delta > 0) {
-                var ch = source.charCodeAt(offset);
-                offset++;
-                delta--;
-                if (ch == $LF) {
-                    line++;
-                    col = 0;
-                }
-                else {
-                    col++;
-                }
-            }
-            return new ParseLocation(this.file, offset, line, col);
-        };
-        // Return the source around the location
-        // Up to `maxChars` or `maxLines` on each side of the location
-        ParseLocation.prototype.getContext = function (maxChars, maxLines) {
-            var content = this.file.content;
-            var startOffset = this.offset;
-            if (startOffset != null) {
-                if (startOffset > content.length - 1) {
-                    startOffset = content.length - 1;
-                }
-                var endOffset = startOffset;
-                var ctxChars = 0;
-                var ctxLines = 0;
-                while (ctxChars < maxChars && startOffset > 0) {
-                    startOffset--;
-                    ctxChars++;
-                    if (content[startOffset] == '\n') {
-                        if (++ctxLines == maxLines) {
-                            break;
-                        }
-                    }
-                }
-                ctxChars = 0;
-                ctxLines = 0;
-                while (ctxChars < maxChars && endOffset < content.length - 1) {
-                    endOffset++;
-                    ctxChars++;
-                    if (content[endOffset] == '\n') {
-                        if (++ctxLines == maxLines) {
-                            break;
-                        }
-                    }
-                }
-                return {
-                    before: content.substring(startOffset, this.offset),
-                    after: content.substring(this.offset, endOffset + 1),
-                };
-            }
-            return null;
-        };
-        return ParseLocation;
-    }());
-    var ParseSourceFile = /** @class */ (function () {
-        function ParseSourceFile(content, url) {
-            this.content = content;
-            this.url = url;
-        }
-        return ParseSourceFile;
-    }());
-    var ParseSourceSpan = /** @class */ (function () {
-        function ParseSourceSpan(start, end, details) {
-            if (details === void 0) { details = null; }
-            this.start = start;
-            this.end = end;
-            this.details = details;
-        }
-        ParseSourceSpan.prototype.toString = function () {
-            return this.start.file.content.substring(this.start.offset, this.end.offset);
-        };
-        return ParseSourceSpan;
-    }());
-    var ParseErrorLevel;
-    (function (ParseErrorLevel) {
-        ParseErrorLevel[ParseErrorLevel["WARNING"] = 0] = "WARNING";
-        ParseErrorLevel[ParseErrorLevel["ERROR"] = 1] = "ERROR";
-    })(ParseErrorLevel || (ParseErrorLevel = {}));
-    var ParseError = /** @class */ (function () {
-        function ParseError(span, msg, level) {
-            if (level === void 0) { level = ParseErrorLevel.ERROR; }
-            this.span = span;
-            this.msg = msg;
-            this.level = level;
-        }
-        ParseError.prototype.contextualMessage = function () {
-            var ctx = this.span.start.getContext(100, 3);
-            return ctx ? this.msg + " (\"" + ctx.before + "[" + ParseErrorLevel[this.level] + " ->]" + ctx.after + "\")" :
-                this.msg;
-        };
-        ParseError.prototype.toString = function () {
-            var details = this.span.details ? ", " + this.span.details : '';
-            return this.contextualMessage() + ": " + this.span.start + details;
-        };
-        return ParseError;
-    }());
-    /**
-     * Generates Source Span object for a given R3 Type for JIT mode.
-     *
-     * @param kind Component or Directive.
-     * @param typeName name of the Component or Directive.
-     * @param sourceUrl reference to Component or Directive source.
-     * @returns instance of ParseSourceSpan that represent a given Component or Directive.
-     */
-    function r3JitTypeSourceSpan(kind, typeName, sourceUrl) {
-        var sourceFileName = "in " + kind + " " + typeName + " in " + sourceUrl;
-        var sourceFile = new ParseSourceFile('', sourceFileName);
-        return new ParseSourceSpan(new ParseLocation(sourceFile, -1, -1, -1), new ParseLocation(sourceFile, -1, -1, -1));
-    }
-
     /**
      * @license
      * Copyright Google Inc. All Rights Reserved.
@@ -7004,24 +7006,24 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         function RecursiveAstVisitor() {
         }
         RecursiveAstVisitor.prototype.visitBinary = function (ast, context) {
-            ast.left.visit(this);
-            ast.right.visit(this);
+            ast.left.visit(this, context);
+            ast.right.visit(this, context);
             return null;
         };
         RecursiveAstVisitor.prototype.visitChain = function (ast, context) { return this.visitAll(ast.expressions, context); };
         RecursiveAstVisitor.prototype.visitConditional = function (ast, context) {
-            ast.condition.visit(this);
-            ast.trueExp.visit(this);
-            ast.falseExp.visit(this);
+            ast.condition.visit(this, context);
+            ast.trueExp.visit(this, context);
+            ast.falseExp.visit(this, context);
             return null;
         };
         RecursiveAstVisitor.prototype.visitPipe = function (ast, context) {
-            ast.exp.visit(this);
+            ast.exp.visit(this, context);
             this.visitAll(ast.args, context);
             return null;
         };
         RecursiveAstVisitor.prototype.visitFunctionCall = function (ast, context) {
-            ast.target.visit(this);
+            ast.target.visit(this, context);
             this.visitAll(ast.args, context);
             return null;
         };
@@ -7030,14 +7032,14 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             return this.visitAll(ast.expressions, context);
         };
         RecursiveAstVisitor.prototype.visitKeyedRead = function (ast, context) {
-            ast.obj.visit(this);
-            ast.key.visit(this);
+            ast.obj.visit(this, context);
+            ast.key.visit(this, context);
             return null;
         };
         RecursiveAstVisitor.prototype.visitKeyedWrite = function (ast, context) {
-            ast.obj.visit(this);
-            ast.key.visit(this);
-            ast.value.visit(this);
+            ast.obj.visit(this, context);
+            ast.key.visit(this, context);
+            ast.value.visit(this, context);
             return null;
         };
         RecursiveAstVisitor.prototype.visitLiteralArray = function (ast, context) {
@@ -7046,32 +7048,32 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         RecursiveAstVisitor.prototype.visitLiteralMap = function (ast, context) { return this.visitAll(ast.values, context); };
         RecursiveAstVisitor.prototype.visitLiteralPrimitive = function (ast, context) { return null; };
         RecursiveAstVisitor.prototype.visitMethodCall = function (ast, context) {
-            ast.receiver.visit(this);
+            ast.receiver.visit(this, context);
             return this.visitAll(ast.args, context);
         };
         RecursiveAstVisitor.prototype.visitPrefixNot = function (ast, context) {
-            ast.expression.visit(this);
+            ast.expression.visit(this, context);
             return null;
         };
         RecursiveAstVisitor.prototype.visitNonNullAssert = function (ast, context) {
-            ast.expression.visit(this);
+            ast.expression.visit(this, context);
             return null;
         };
         RecursiveAstVisitor.prototype.visitPropertyRead = function (ast, context) {
-            ast.receiver.visit(this);
+            ast.receiver.visit(this, context);
             return null;
         };
         RecursiveAstVisitor.prototype.visitPropertyWrite = function (ast, context) {
-            ast.receiver.visit(this);
-            ast.value.visit(this);
+            ast.receiver.visit(this, context);
+            ast.value.visit(this, context);
             return null;
         };
         RecursiveAstVisitor.prototype.visitSafePropertyRead = function (ast, context) {
-            ast.receiver.visit(this);
+            ast.receiver.visit(this, context);
             return null;
         };
         RecursiveAstVisitor.prototype.visitSafeMethodCall = function (ast, context) {
-            ast.receiver.visit(this);
+            ast.receiver.visit(this, context);
             return this.visitAll(ast.args, context);
         };
         RecursiveAstVisitor.prototype.visitAll = function (asts, context) {
@@ -15797,9 +15799,11 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             // setup accumulated bindings
             var _a = this.i18n, index = _a.index, bindings = _a.bindings;
             if (bindings.size) {
+                var chainBindings_1 = [];
                 bindings.forEach(function (binding) {
-                    _this.updateInstruction(index, span, Identifiers$1.i18nExp, function () { return [_this.convertPropertyBinding(binding, /* skipBindFn */ true)]; });
+                    chainBindings_1.push({ sourceSpan: span, value: function () { return _this.convertPropertyBinding(binding); } });
                 });
+                this.updateInstructionChain(index, Identifiers$1.i18nExp, chainBindings_1);
                 this.updateInstruction(index, span, Identifiers$1.i18nApply, [literal(index)]);
             }
             if (!selfClosing) {
@@ -15968,6 +15972,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 if (i18nAttrs.length) {
                     var hasBindings_1 = false;
                     var i18nAttrArgs_1 = [];
+                    var bindings_1 = [];
                     i18nAttrs.forEach(function (attr) {
                         var message = attr.i18n;
                         if (attr instanceof TextAttribute) {
@@ -15982,11 +15987,17 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                                 i18nAttrArgs_1.push(literal(attr.name), _this.i18nTranslate(message, params));
                                 converted.expressions.forEach(function (expression) {
                                     hasBindings_1 = true;
-                                    _this.updateInstruction(elementIndex, element.sourceSpan, Identifiers$1.i18nExp, function () { return [_this.convertExpressionBinding(expression, /* skipBindFn */ true)]; });
+                                    bindings_1.push({
+                                        sourceSpan: element.sourceSpan,
+                                        value: function () { return _this.convertExpressionBinding(expression); }
+                                    });
                                 });
                             }
                         }
                     });
+                    if (bindings_1.length) {
+                        this.updateInstructionChain(elementIndex, Identifiers$1.i18nExp, bindings_1);
+                    }
                     if (i18nAttrArgs_1.length) {
                         var index = literal(this.allocateDataSlot());
                         var args = this.constantPool.getConstLiteral(literalArr(i18nAttrArgs_1), true);
@@ -16028,6 +16039,8 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             // special value to symbolize that there is no RHS to this binding
             // TODO (matsko): revisit this once FW-959 is approached
             var emptyValueBindInstruction = literal(undefined);
+            var propertyBindings = [];
+            var attributeBindings = [];
             // Generate element input bindings
             allOtherInputs.forEach(function (input) {
                 var inputType = input.type;
@@ -16044,13 +16057,10 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                     // defined in...
                     var hasValue_1 = value_1 instanceof LiteralPrimitive ? !!value_1.value : true;
                     _this.allocateBindingSlots(value_1);
-                    var bindingName_1 = prepareSyntheticPropertyName(input.name);
-                    _this.updateInstruction(elementIndex, input.sourceSpan, Identifiers$1.property, function () {
-                        return [
-                            literal(bindingName_1),
-                            (hasValue_1 ? _this.convertPropertyBinding(value_1, /* skipBindFn */ true) :
-                                emptyValueBindInstruction),
-                        ];
+                    propertyBindings.push({
+                        name: prepareSyntheticPropertyName(input.name),
+                        sourceSpan: input.sourceSpan,
+                        value: function () { return hasValue_1 ? _this.convertPropertyBinding(value_1) : emptyValueBindInstruction; }
                     });
                 }
                 else {
@@ -16085,7 +16095,12 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                             }
                             else {
                                 // [prop]="value"
-                                _this.boundUpdateInstruction(Identifiers$1.property, elementIndex, attrName_1, input, value_2, params_2);
+                                // Collect all the properties so that we can chain into a single function at the end.
+                                propertyBindings.push({
+                                    name: attrName_1,
+                                    sourceSpan: input.sourceSpan,
+                                    value: function () { return _this.convertPropertyBinding(value_2); }, params: params_2
+                                });
                             }
                         }
                         else if (inputType === 1 /* Attribute */) {
@@ -16094,9 +16109,14 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                                 _this.interpolatedUpdateInstruction(getAttributeInterpolationExpression(value_2), elementIndex, attrName_1, input, value_2, params_2);
                             }
                             else {
-                                var boundValue = value_2 instanceof Interpolation ? value_2.expressions[0] : value_2;
+                                var boundValue_1 = value_2 instanceof Interpolation ? value_2.expressions[0] : value_2;
                                 // [attr.name]="value" or attr.name="{{value}}"
-                                _this.boundUpdateInstruction(Identifiers$1.attribute, elementIndex, attrName_1, input, boundValue, params_2);
+                                // Collect the attribute bindings so that they can be chained at the end.
+                                attributeBindings.push({
+                                    name: attrName_1,
+                                    sourceSpan: input.sourceSpan,
+                                    value: function () { return _this.convertPropertyBinding(boundValue_1); }, params: params_2
+                                });
                             }
                         }
                         else {
@@ -16110,6 +16130,12 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                     }
                 }
             });
+            if (propertyBindings.length > 0) {
+                this.updateInstructionChain(elementIndex, Identifiers$1.property, propertyBindings);
+            }
+            if (attributeBindings.length > 0) {
+                this.updateInstructionChain(elementIndex, Identifiers$1.attribute, attributeBindings);
+            }
             // Traverse element child nodes
             visitAll(this, element.children);
             if (!isI18nRootElement && this.i18n) {
@@ -16127,18 +16153,6 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 this.creationInstruction(span, isNgContainer$1 ? Identifiers$1.elementContainerEnd : Identifiers$1.elementEnd);
             }
         };
-        /**
-         * Adds an update instruction for a bound property or attribute, such as `[prop]="value"` or
-         * `[attr.title]="value"`
-         */
-        TemplateDefinitionBuilder.prototype.boundUpdateInstruction = function (instruction, elementIndex, attrName, input, value, params) {
-            var _this = this;
-            this.updateInstruction(elementIndex, input.sourceSpan, instruction, function () {
-                return __spread([
-                    literal(attrName), _this.convertPropertyBinding(value, /* skipBindFn */ true)
-                ], params);
-            });
-        };
         /**
          * Adds an update instruction for an interpolated property or attribute, such as
          * `prop="{{value}}"` or `attr.title="{{value}}"`
@@ -16196,11 +16210,11 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 return trimTrailingNulls(parameters);
             });
             // handle property bindings e.g. ɵɵproperty('ngForOf', ctx.items), et al;
-            this.templatePropertyBindings(template, templateIndex, template.templateAttrs);
+            this.templatePropertyBindings(templateIndex, template.templateAttrs);
             // Only add normal input/output binding instructions on explicit ng-template elements.
             if (template.tagName === NG_TEMPLATE_TAG_NAME) {
                 // Add the input bindings
-                this.templatePropertyBindings(template, templateIndex, template.inputs);
+                this.templatePropertyBindings(templateIndex, template.inputs);
                 // Generate listeners for directive output
                 template.outputs.forEach(function (outputAst) {
                     _this.creationInstruction(outputAst.sourceSpan, Identifiers$1.listener, _this.prepareListenerParameter('ng_template', outputAst, templateIndex));
@@ -16279,20 +16293,25 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 null;
         };
         TemplateDefinitionBuilder.prototype.bindingContext = function () { return "" + this._bindingContext++; };
-        TemplateDefinitionBuilder.prototype.templatePropertyBindings = function (template, templateIndex, attrs) {
+        TemplateDefinitionBuilder.prototype.templatePropertyBindings = function (templateIndex, attrs) {
             var _this = this;
+            var propertyBindings = [];
             attrs.forEach(function (input) {
                 if (input instanceof BoundAttribute) {
                     var value_4 = input.value.visit(_this._valueConverter);
                     if (value_4 !== undefined) {
                         _this.allocateBindingSlots(value_4);
-                        _this.updateInstruction(templateIndex, template.sourceSpan, Identifiers$1.property, function () {
-                            return [literal(input.name),
-                                _this.convertPropertyBinding(value_4, /* skipBindFn */ true)];
+                        propertyBindings.push({
+                            name: input.name,
+                            sourceSpan: input.sourceSpan,
+                            value: function () { return _this.convertPropertyBinding(value_4); }
                         });
                     }
                 }
             });
+            if (propertyBindings.length > 0) {
+                this.updateInstructionChain(templateIndex, Identifiers$1.property, propertyBindings);
+            }
         };
         // Bindings must only be resolved after all local refs have been visited, so all
         // instructions are queued in callbacks that execute once the initial pass has completed.
@@ -16308,7 +16327,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         TemplateDefinitionBuilder.prototype.processStylingInstruction = function (elementIndex, instruction, createMode) {
             var _this = this;
             if (instruction) {
-                var paramsFn = function () { return instruction.buildParams(function (value) { return _this.convertPropertyBinding(value, /* skipBindFn */ true); }); };
+                var paramsFn = function () { return instruction.buildParams(function (value) { return _this.convertPropertyBinding(value); }); };
                 if (createMode) {
                     this.creationInstruction(instruction.sourceSpan, instruction.reference, paramsFn);
                 }
@@ -16321,13 +16340,30 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             this.instructionFn(this._creationCodeFns, span, reference, paramsOrFn || [], prepend);
         };
         TemplateDefinitionBuilder.prototype.updateInstruction = function (nodeIndex, span, reference, paramsOrFn) {
+            this.addSelectInstructionIfNecessary(nodeIndex, span);
+            this.instructionFn(this._updateCodeFns, span, reference, paramsOrFn || []);
+        };
+        TemplateDefinitionBuilder.prototype.updateInstructionChain = function (nodeIndex, reference, bindings) {
+            var span = bindings.length ? bindings[0].sourceSpan : null;
+            this.addSelectInstructionIfNecessary(nodeIndex, span);
+            this._updateCodeFns.push(function () {
+                var calls = bindings.map(function (property) {
+                    var fnParams = __spread([property.value()], (property.params || []));
+                    if (property.name) {
+                        fnParams.unshift(literal(property.name));
+                    }
+                    return fnParams;
+                });
+                return chainedInstruction(span, reference, calls).toStmt();
+            });
+        };
+        TemplateDefinitionBuilder.prototype.addSelectInstructionIfNecessary = function (nodeIndex, span) {
             if (this._lastNodeIndexWithFlush < nodeIndex) {
                 if (nodeIndex > 0) {
                     this.instructionFn(this._updateCodeFns, span, Identifiers$1.select, [literal(nodeIndex)]);
                 }
                 this._lastNodeIndexWithFlush = nodeIndex;
             }
-            this.instructionFn(this._updateCodeFns, span, reference, paramsOrFn || []);
         };
         TemplateDefinitionBuilder.prototype.allocatePureFunctionSlots = function (numSlots) {
             var originalSlots = this._pureFunctionSlots;
@@ -16349,19 +16385,17 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 variable(CONTEXT_NAME) :
                 this._bindingScope.getOrCreateSharedContextVar(0);
         };
-        TemplateDefinitionBuilder.prototype.convertExpressionBinding = function (value, skipBindFn) {
+        TemplateDefinitionBuilder.prototype.convertExpressionBinding = function (value) {
             var convertedPropertyBinding = convertPropertyBinding(this, this.getImplicitReceiverExpr(), value, this.bindingContext(), BindingForm.TrySimple);
-            var valExpr = convertedPropertyBinding.currValExpr;
-            return skipBindFn ? valExpr : importExpr(Identifiers$1.bind).callFn([valExpr]);
+            return convertedPropertyBinding.currValExpr;
         };
-        TemplateDefinitionBuilder.prototype.convertPropertyBinding = function (value, skipBindFn) {
+        TemplateDefinitionBuilder.prototype.convertPropertyBinding = function (value) {
             var _a;
             var interpolationFn = value instanceof Interpolation ? interpolate : function () { return error('Unexpected interpolation'); };
             var convertedPropertyBinding = convertPropertyBinding(this, this.getImplicitReceiverExpr(), value, this.bindingContext(), BindingForm.TrySimple, interpolationFn);
             var valExpr = convertedPropertyBinding.currValExpr;
             (_a = this._tempVariables).push.apply(_a, __spread(convertedPropertyBinding.stmts));
-            return value instanceof Interpolation || skipBindFn ? valExpr :
-                importExpr(Identifiers$1.bind).callFn([valExpr]);
+            return valExpr;
         };
         /**
          * Gets a list of argument expressions to pass to an update instruction expression. Also updates
@@ -16587,6 +16621,19 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
     function instruction(span, reference, params) {
         return importExpr(reference, null, span).callFn(params, span);
     }
+    function chainedInstruction(span, reference, calls) {
+        var expression = importExpr(reference, null, span);
+        if (calls.length > 0) {
+            for (var i = 0; i < calls.length; i++) {
+                expression = expression.callFn(calls[i], span);
+            }
+        }
+        else {
+            // Add a blank invocation, in case the `calls` array is empty.
+            expression = expression.callFn([], span);
+        }
+        return expression;
+    }
     // e.g. x(2);
     function generateNextContextExpr(relativeLevelDiff) {
         return importExpr(Identifiers$1.nextContext)
@@ -16993,7 +17040,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         var interpolationConfig = options.interpolationConfig, preserveWhitespaces = options.preserveWhitespaces;
         var bindingParser = makeBindingParser(interpolationConfig);
         var htmlParser = new HtmlParser();
-        var parseResult = htmlParser.parse(template, templateUrl, __assign({}, options, { tokenizeExpansionForms: true, leadingTriviaChars: LEADING_TRIVIA_CHARS }));
+        var parseResult = htmlParser.parse(template, templateUrl, __assign({ leadingTriviaChars: LEADING_TRIVIA_CHARS }, options, { tokenizeExpansionForms: true }));
         if (parseResult.errors && parseResult.errors.length > 0) {
             return { errors: parseResult.errors, nodes: [], styleUrls: [], styles: [] };
         }
@@ -17961,7 +18008,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
      * 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('8.1.0-next.3');
+    var VERSION$1 = new Version('8.1.2');
 
     /**
      * @license
@@ -20701,7 +20748,8 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                         else if (createInject.isTypeOf(paramEntry)) {
                             token = paramEntry.token;
                         }
-                        else if (createInjectionToken.isTypeOf(paramEntry) || paramEntry instanceof StaticSymbol) {
+                        else if (createInjectionToken.isTypeOf(paramEntry) ||
+                            paramEntry instanceof StaticSymbol) {
                             token = paramEntry;
                         }
                         else if (isValidType(paramEntry) && token == null) {
@@ -25697,11 +25745,11 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             else if (type.flags & ts.TypeFlags.Union) {
                 // If all the constituent types of a union are the same kind, it is also that kind.
                 var candidate = null;
-                var unionType = type;
-                if (unionType.types.length > 0) {
-                    candidate = typeKindOf(unionType.types[0]);
+                var unionType_1 = type;
+                if (unionType_1.types.length > 0) {
+                    candidate = typeKindOf(unionType_1.types[0]);
                     try {
-                        for (var _b = __values(unionType.types), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        for (var _b = __values(unionType_1.types), _c = _b.next(); !_c.done; _c = _b.next()) {
                             var subType = _c.value;
                             if (candidate != typeKindOf(subType)) {
                                 return BuiltinType$1.Other;
@@ -26250,9 +26298,9 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                     }
                     return recordEntry(typeReference, node);
                 case ts.SyntaxKind.UnionType:
-                    var unionType = node;
+                    var unionType_1 = node;
                     // Remove null and undefined from the list of unions.
-                    var references = unionType.types
+                    var references = unionType_1.types
                         .filter(function (n) { return n.kind != ts.SyntaxKind.NullKeyword &&
                         n.kind != ts.SyntaxKind.UndefinedKeyword; })
                         .map(function (n) { return _this.evaluateNode(n); });
@@ -26973,8 +27021,9 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                             if (name) {
                                 if (!metadata)
                                     metadata = {};
-                                metadata[name] =
-                                    maybeFunc ? recordEntry(maybeFunc.func, node) : { __symbolic: 'function' };
+                                // TODO(alxhub): The literal here is not valid FunctionMetadata.
+                                metadata[name] = maybeFunc ? recordEntry(maybeFunc.func, node) :
+                                    { __symbolic: 'function' };
                             }
                         }
                         break;
@@ -27006,13 +27055,15 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                                         nextDefaultValue = enumValue + 1;
                                     }
                                     else if (name) {
+                                        // TODO(alxhub): 'left' here has a name propery which is not valid for
+                                        // MetadataSymbolicSelectExpression.
                                         nextDefaultValue = {
                                             __symbolic: 'binary',
                                             operator: '+',
                                             left: {
                                                 __symbolic: 'select',
                                                 expression: recordEntry({ __symbolic: 'reference', name: enumName }, node), name: name
-                                            }
+                                            },
                                         };
                                     }
                                     else {
@@ -29007,56 +29058,12 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
      * 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 getTemplateDiagnostics(fileName, astProvider, templates) {
-        var e_1, _a;
-        var results = [];
-        var _loop_1 = function (template) {
-            var ast = astProvider.getTemplateAst(template, fileName);
-            if (ast) {
-                if (ast.parseErrors && ast.parseErrors.length) {
-                    results.push.apply(results, __spread(ast.parseErrors.map(function (e) { return ({
-                        kind: DiagnosticKind$1.Error,
-                        span: offsetSpan$1(spanOf$2(e.span), template.span.start),
-                        message: e.msg
-                    }); })));
-                }
-                else if (ast.templateAst && ast.htmlAst) {
-                    var info = {
-                        templateAst: ast.templateAst,
-                        htmlAst: ast.htmlAst,
-                        offset: template.span.start,
-                        query: template.query,
-                        members: template.members
-                    };
-                    var expressionDiagnostics = getTemplateExpressionDiagnostics(info);
-                    results.push.apply(results, __spread(expressionDiagnostics));
-                }
-                if (ast.errors) {
-                    results.push.apply(results, __spread(ast.errors.map(function (e) { return ({ kind: e.kind, span: e.span || template.span, message: e.message }); })));
-                }
-            }
-        };
-        try {
-            for (var templates_1 = __values(templates), templates_1_1 = templates_1.next(); !templates_1_1.done; templates_1_1 = templates_1.next()) {
-                var template = templates_1_1.value;
-                _loop_1(template);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (templates_1_1 && !templates_1_1.done && (_a = templates_1.return)) _a.call(templates_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return results;
-    }
     function getDeclarationDiagnostics(declarations, modules) {
-        var e_2, _a;
+        var e_1, _a;
         var results = [];
         var directives = undefined;
-        var _loop_2 = function (declaration) {
-            var e_3, _a;
+        var _loop_1 = function (declaration) {
+            var e_2, _a;
             var report = function (message, span) {
                 results.push({
                     kind: DiagnosticKind$1.Error,
@@ -29069,12 +29076,12 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                     report(error.message, error.span);
                 }
             }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_3) throw e_3.error; }
+                finally { if (e_2) throw e_2.error; }
             }
             if (declaration.metadata) {
                 if (declaration.metadata.isComponent) {
@@ -29105,15 +29112,15 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         try {
             for (var declarations_1 = __values(declarations), declarations_1_1 = declarations_1.next(); !declarations_1_1.done; declarations_1_1 = declarations_1.next()) {
                 var declaration = declarations_1_1.value;
-                _loop_2(declaration);
+                _loop_1(declaration);
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
                 if (declarations_1_1 && !declarations_1_1.done && (_a = declarations_1.return)) _a.call(declarations_1);
             }
-            finally { if (e_2) throw e_2.error; }
+            finally { if (e_1) throw e_1.error; }
         }
         return results;
     }
@@ -29169,7 +29176,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             var results = [];
             var templates = this.host.getTemplates(fileName);
             if (templates && templates.length) {
-                results.push.apply(results, __spread(getTemplateDiagnostics(fileName, this, templates)));
+                results.push.apply(results, __spread(this.getTemplateDiagnostics(fileName, templates)));
             }
             var declarations = this.host.getDeclarations(fileName);
             if (declarations && declarations.length) {
@@ -29179,101 +29186,79 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             return uniqueBySpan(results);
         };
         LanguageServiceImpl.prototype.getPipesAt = function (fileName, position) {
-            var templateInfo = this.getTemplateAstAtPosition(fileName, position);
+            var templateInfo = this.host.getTemplateAstAtPosition(fileName, position);
             if (templateInfo) {
                 return templateInfo.pipes;
             }
             return [];
         };
         LanguageServiceImpl.prototype.getCompletionsAt = function (fileName, position) {
-            var templateInfo = this.getTemplateAstAtPosition(fileName, position);
+            var templateInfo = this.host.getTemplateAstAtPosition(fileName, position);
             if (templateInfo) {
                 return getTemplateCompletions(templateInfo);
             }
         };
         LanguageServiceImpl.prototype.getDefinitionAt = function (fileName, position) {
-            var templateInfo = this.getTemplateAstAtPosition(fileName, position);
+            var templateInfo = this.host.getTemplateAstAtPosition(fileName, position);
             if (templateInfo) {
                 return getDefinition(templateInfo);
             }
         };
         LanguageServiceImpl.prototype.getHoverAt = function (fileName, position) {
-            var templateInfo = this.getTemplateAstAtPosition(fileName, position);
+            var templateInfo = this.host.getTemplateAstAtPosition(fileName, position);
             if (templateInfo) {
                 return getHover(templateInfo);
             }
         };
-        LanguageServiceImpl.prototype.getTemplateAstAtPosition = function (fileName, position) {
-            var template = this.host.getTemplateAt(fileName, position);
-            if (template) {
-                var astResult = this.getTemplateAst(template, fileName);
-                if (astResult && astResult.htmlAst && astResult.templateAst && astResult.directive &&
-                    astResult.directives && astResult.pipes && astResult.expressionParser)
-                    return {
-                        position: position,
-                        fileName: fileName,
-                        template: template,
-                        htmlAst: astResult.htmlAst,
-                        directive: astResult.directive,
-                        directives: astResult.directives,
-                        pipes: astResult.pipes,
-                        templateAst: astResult.templateAst,
-                        expressionParser: astResult.expressionParser
-                    };
-            }
-            return undefined;
-        };
-        LanguageServiceImpl.prototype.getTemplateAst = function (template, contextFile) {
-            var _this = this;
-            var result = undefined;
-            try {
-                var resolvedMetadata = this.metadataResolver.getNonNormalizedDirectiveMetadata(template.type);
-                var metadata = resolvedMetadata && resolvedMetadata.metadata;
-                if (metadata) {
-                    var rawHtmlParser = new HtmlParser();
-                    var htmlParser = new I18NHtmlParser(rawHtmlParser);
-                    var expressionParser = new Parser$1(new Lexer());
-                    var config = new CompilerConfig();
-                    var parser = new TemplateParser(config, this.host.resolver.getReflector(), expressionParser, new DomElementSchemaRegistry(), htmlParser, null, []);
-                    var htmlResult = htmlParser.parse(template.source, '', { tokenizeExpansionForms: true });
-                    var analyzedModules = this.host.getAnalyzedModules();
-                    var errors = undefined;
-                    var ngModule = analyzedModules.ngModuleByPipeOrDirective.get(template.type);
-                    if (!ngModule) {
-                        // Reported by the the declaration diagnostics.
-                        ngModule = findSuitableDefaultModule(analyzedModules);
-                    }
-                    if (ngModule) {
-                        var resolvedDirectives = ngModule.transitiveModule.directives.map(function (d) { return _this.host.resolver.getNonNormalizedDirectiveMetadata(d.reference); });
-                        var directives = removeMissing(resolvedDirectives).map(function (d) { return d.metadata.toSummary(); });
-                        var pipes = ngModule.transitiveModule.pipes.map(function (p) { return _this.host.resolver.getOrLoadPipeMetadata(p.reference).toSummary(); });
-                        var schemas = ngModule.schemas;
-                        var parseResult = parser.tryParseHtml(htmlResult, metadata, directives, pipes, schemas);
-                        result = {
-                            htmlAst: htmlResult.rootNodes,
-                            templateAst: parseResult.templateAst,
-                            directive: metadata, directives: directives, pipes: pipes,
-                            parseErrors: parseResult.errors, expressionParser: expressionParser, errors: errors
+        LanguageServiceImpl.prototype.getTemplateDiagnostics = function (fileName, templates) {
+            var e_1, _a;
+            var results = [];
+            var _loop_1 = function (template) {
+                var ast = this_1.host.getTemplateAst(template, fileName);
+                if (ast) {
+                    if (ast.parseErrors && ast.parseErrors.length) {
+                        results.push.apply(results, __spread(ast.parseErrors.map(function (e) { return ({
+                            kind: DiagnosticKind$1.Error,
+                            span: offsetSpan$1(spanOf$2(e.span), template.span.start),
+                            message: e.msg
+                        }); })));
+                    }
+                    else if (ast.templateAst && ast.htmlAst) {
+                        var info = {
+                            templateAst: ast.templateAst,
+                            htmlAst: ast.htmlAst,
+                            offset: template.span.start,
+                            query: template.query,
+                            members: template.members
                         };
+                        var expressionDiagnostics = getTemplateExpressionDiagnostics(info);
+                        results.push.apply(results, __spread(expressionDiagnostics));
                     }
+                    if (ast.errors) {
+                        results.push.apply(results, __spread(ast.errors.map(function (e) { return ({ kind: e.kind, span: e.span || template.span, message: e.message }); })));
+                    }
+                }
+            };
+            var this_1 = this;
+            try {
+                for (var templates_1 = __values(templates), templates_1_1 = templates_1.next(); !templates_1_1.done; templates_1_1 = templates_1.next()) {
+                    var template = templates_1_1.value;
+                    _loop_1(template);
                 }
             }
-            catch (e) {
-                var span = template.span;
-                if (e.fileName == contextFile) {
-                    span = template.query.getSpanAt(e.line, e.column) || span;
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (templates_1_1 && !templates_1_1.done && (_a = templates_1.return)) _a.call(templates_1);
                 }
-                result = { errors: [{ kind: DiagnosticKind$1.Error, message: e.message, span: span }] };
+                finally { if (e_1) throw e_1.error; }
             }
-            return result || {};
+            return results;
         };
         return LanguageServiceImpl;
     }());
-    function removeMissing(values) {
-        return values.filter(function (e) { return !!e; });
-    }
     function uniqueBySpan(elements) {
-        var e_1, _a;
+        var e_2, _a;
         if (elements) {
             var result = [];
             var map = new Map();
@@ -29292,39 +29277,16 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                     }
                 }
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
             finally {
                 try {
                     if (elements_1_1 && !elements_1_1.done && (_a = elements_1.return)) _a.call(elements_1);
                 }
-                finally { if (e_1) throw e_1.error; }
+                finally { if (e_2) throw e_2.error; }
             }
             return result;
         }
     }
-    function findSuitableDefaultModule(modules) {
-        var e_2, _a;
-        var result = undefined;
-        var resultSize = 0;
-        try {
-            for (var _b = __values(modules.ngModules), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var module_1 = _c.value;
-                var moduleSize = module_1.transitiveModule.directives.length;
-                if (moduleSize > resultSize) {
-                    result = module_1;
-                    resultSize = moduleSize;
-                }
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        return result;
-    }
 
     /**
      * @license
@@ -30107,7 +30069,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 if (typeof paramTypes === 'undefined') {
                     result[i] = [];
                 }
-                else if (paramTypes[i] != Object) {
+                else if (paramTypes[i] && paramTypes[i] != Object) {
                     result[i] = [paramTypes[i]];
                 }
                 else {
@@ -32574,7 +32536,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
     function assertDomNode(node) {
         // If we're in a worker, `Node` will not be defined.
         assertEqual((typeof Node !== 'undefined' && node instanceof Node) ||
-            (typeof node === 'object' && node.constructor.name === 'WebWorkerRenderNode'), true, 'The provided value must be an instance of a DOM Node');
+            (typeof node === 'object' && node.constructor.name === 'WebWorkerRenderNode'), true, "The provided value must be an instance of a DOM Node but got " + stringify$1(node));
     }
     function assertDataInRange(arr, index) {
         var maxLen = arr ? arr.length : 0;
@@ -32609,7 +32571,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
      * 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 = 8;
+    var CONTAINER_HEADER_OFFSET = 9;
 
     /**
      * @license
@@ -33120,8 +33082,11 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
      * the direction of traversal (up or down the view tree) a bit clearer.
      *
      * @param newView New state to become active
+     * @param safeToRunHooks Whether the runtime is in a state where running lifecycle hooks is valid.
+     * This is not always the case (for example, the application may have crashed and `leaveView` is
+     * being executed while unwinding the call stack).
      */
-    function leaveView(newView) {
+    function leaveView(newView, safeToRunHooks) {
         var tView = lView[TVIEW];
         if (isCreationMode(lView)) {
             lView[FLAGS] &= ~4 /* CreationMode */;
@@ -33129,7 +33094,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         else {
             try {
                 resetPreOrderHookFlags(lView);
-                executeHooks(lView, tView.viewHooks, tView.viewCheckHooks, checkNoChangesMode, 2 /* AfterViewInitHooksToBeRun */, undefined);
+                safeToRunHooks && executeHooks(lView, tView.viewHooks, tView.viewCheckHooks, checkNoChangesMode, 2 /* AfterViewInitHooksToBeRun */, undefined);
             }
             finally {
                 // Views are clean and in update mode after being checked, so these bits are cleared
@@ -34014,7 +33979,12 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         return lView;
     }
     /**
-     * Given a current view, finds the nearest component's host (LElement).
+     * Given an `LView`, find the closest declaration view which is not an embedded view.
+     *
+     * This method searches for the `LView` associated with the component which declared the `LView`.
+     *
+     * This function may return itself if the `LView` passed in is not an embedded `LView`. Otherwise
+     * it walks the declaration parents until it finds a component view (non-embedded-view.)
      *
      * @param lView LView for which we want a host element node
      * @returns The host node
@@ -36413,6 +36383,8 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             tickRootContext(getRootContext(viewToRender));
         }
         else {
+            // Will become true if the `try` block executes with no errors.
+            var safeToRunHooks = false;
             try {
                 setPreviousOrParentTNode(null, true);
                 oldView = enterView(viewToRender, viewToRender[T_HOST]);
@@ -36424,9 +36396,10 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 // matching, etc again and again.
                 viewToRender[TVIEW].firstTemplatePass = false;
                 refreshDescendantViews(viewToRender);
+                safeToRunHooks = true;
             }
             finally {
-                leaveView(oldView);
+                leaveView(oldView, safeToRunHooks);
                 setPreviousOrParentTNode(_previousOrParentTNode, _isParent);
             }
         }
@@ -36436,6 +36409,8 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         var oldView = enterView(hostView, hostView[T_HOST]);
         var normalExecutionPath = !getCheckNoChangesMode();
         var creationModeIsActive = isCreationMode(hostView);
+        // Will become true if the `try` block executes with no errors.
+        var safeToRunHooks = false;
         try {
             if (normalExecutionPath && !creationModeIsActive && rendererFactory.begin) {
                 rendererFactory.begin();
@@ -36450,12 +36425,13 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             resetPreOrderHookFlags(hostView);
             templateFn && executeTemplate(hostView, templateFn, 2 /* Update */, context);
             refreshDescendantViews(hostView);
+            safeToRunHooks = true;
         }
         finally {
             if (normalExecutionPath && !creationModeIsActive && rendererFactory.end) {
                 rendererFactory.end();
             }
-            leaveView(oldView);
+            leaveView(oldView, safeToRunHooks);
         }
     }
     function executeTemplate(lView, templateFn, rf, context) {
@@ -36935,6 +36911,8 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         var oldView = enterView(hostView, hostView[T_HOST]);
         var templateFn = hostTView.template;
         var creationMode = isCreationMode(hostView);
+        // Will become true if the `try` block executes with no errors.
+        var safeToRunHooks = false;
         try {
             resetPreOrderHookFlags(hostView);
             creationMode && executeViewQueryFn(1 /* Create */, hostTView, component);
@@ -36944,9 +36922,10 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             if (!creationMode || hostTView.staticViewQueries) {
                 executeViewQueryFn(2 /* Update */, hostTView, component);
             }
+            safeToRunHooks = true;
         }
         finally {
-            leaveView(oldView);
+            leaveView(oldView, safeToRunHooks);
         }
     }
     function executeViewQueryFn(flags, tView, component) {
@@ -37201,181 +37180,39 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             return container;
         }
     }
-    /**
-     * Stack used to keep track of projection nodes in walkTNodeTree.
-     *
-     * This is deliberately created outside of walkTNodeTree to avoid allocating
-     * a new array each time the function is called. Instead the array will be
-     * re-used by each invocation. This works because the function is not reentrant.
-     */
-    var projectionNodeStack = [];
-    /**
-     * Walks a tree of TNodes, applying a transformation on the element nodes, either only on the first
-     * one found, or on all of them.
-     *
-     * @param viewToWalk the view to walk
-     * @param action identifies the action to be performed on the elements
-     * @param renderer the current renderer.
-     * @param renderParent Optional the render parent node to be set in all LContainers found,
-     * required for action modes Insert and Destroy.
-     * @param beforeNode Optional the node before which elements should be added, required for action
-     * Insert.
-     */
-    function walkTNodeTree(viewToWalk, action, renderer, renderParent, beforeNode) {
-        var e_1, _a;
-        var rootTNode = viewToWalk[TVIEW].node;
-        var projectionNodeIndex = -1;
-        var currentView = viewToWalk;
-        var tNode = rootTNode.child;
-        while (tNode) {
-            var nextTNode = null;
-            if (tNode.type === 3 /* Element */ || tNode.type === 4 /* ElementContainer */) {
-                executeNodeAction(action, renderer, renderParent, getNativeByTNode(tNode, currentView), tNode, beforeNode);
-                var nodeOrContainer = currentView[tNode.index];
-                if (isLContainer(nodeOrContainer)) {
-                    // This element has an LContainer, and its comment needs to be handled
-                    executeNodeAction(action, renderer, renderParent, nodeOrContainer[NATIVE], tNode, beforeNode);
-                    var firstView = nodeOrContainer[CONTAINER_HEADER_OFFSET];
-                    if (firstView) {
-                        currentView = firstView;
-                        nextTNode = currentView[TVIEW].node;
-                        // When the walker enters a container, then the beforeNode has to become the local native
-                        // comment node.
-                        beforeNode = nodeOrContainer[NATIVE];
-                    }
-                }
-            }
-            else if (tNode.type === 0 /* Container */) {
-                var lContainer = currentView[tNode.index];
-                executeNodeAction(action, renderer, renderParent, lContainer[NATIVE], tNode, beforeNode);
-                var firstView = lContainer[CONTAINER_HEADER_OFFSET];
-                if (firstView) {
-                    currentView = firstView;
-                    nextTNode = currentView[TVIEW].node;
-                    // When the walker enters a container, then the beforeNode has to become the local native
-                    // comment node.
-                    beforeNode = lContainer[NATIVE];
-                }
-            }
-            else if (tNode.type === 1 /* Projection */) {
-                var componentView = findComponentView(currentView);
-                var componentHost = componentView[T_HOST];
-                var head = componentHost.projection[tNode.projection];
-                if (Array.isArray(head)) {
-                    try {
-                        for (var head_1 = __values(head), head_1_1 = head_1.next(); !head_1_1.done; head_1_1 = head_1.next()) {
-                            var nativeNode = head_1_1.value;
-                            executeNodeAction(action, renderer, renderParent, nativeNode, tNode, beforeNode);
-                        }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (head_1_1 && !head_1_1.done && (_a = head_1.return)) _a.call(head_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                    }
-                }
-                else {
-                    // Must store both the TNode and the view because this projection node could be nested
-                    // deeply inside embedded views, and we need to get back down to this particular nested
-                    // view.
-                    projectionNodeStack[++projectionNodeIndex] = tNode;
-                    projectionNodeStack[++projectionNodeIndex] = currentView;
-                    if (head) {
-                        currentView = componentView[PARENT];
-                        nextTNode = currentView[TVIEW].data[head.index];
-                    }
-                }
-            }
-            else {
-                // Otherwise, this is a View
-                nextTNode = tNode.child;
-            }
-            if (nextTNode === null) {
-                // this last node was projected, we need to get back down to its projection node
-                if (tNode.projectionNext === null && (tNode.flags & 2 /* isProjected */)) {
-                    currentView = projectionNodeStack[projectionNodeIndex--];
-                    tNode = projectionNodeStack[projectionNodeIndex--];
-                }
-                if (tNode.flags & 2 /* isProjected */) {
-                    nextTNode = tNode.projectionNext;
-                }
-                else if (tNode.type === 4 /* ElementContainer */) {
-                    nextTNode = tNode.child || tNode.next;
-                }
-                else {
-                    nextTNode = tNode.next;
-                }
-                /**
-                 * Find the next node in the TNode tree, taking into account the place where a node is
-                 * projected (in the shadow DOM) rather than where it comes from (in the light DOM).
-                 *
-                 * If there is no sibling node, then it goes to the next sibling of the parent node...
-                 * until it reaches rootNode (at which point null is returned).
-                 */
-                while (!nextTNode) {
-                    // If parent is null, we're crossing the view boundary, so we should get the host TNode.
-                    tNode = tNode.parent || currentView[T_HOST];
-                    if (tNode === null || tNode === rootTNode)
-                        return;
-                    // When exiting a container, the beforeNode must be restored to the previous value
-                    if (tNode.type === 0 /* Container */) {
-                        currentView = getLViewParent(currentView);
-                        beforeNode = currentView[tNode.index][NATIVE];
-                    }
-                    if (tNode.type === 2 /* View */) {
-                        /**
-                         * If current lView doesn't have next pointer, we try to find it by going up parents
-                         * chain until:
-                         * - we find an lView with a next pointer
-                         * - or find a tNode with a parent that has a next pointer
-                         * - or find a lContainer
-                         * - or reach root TNode (in which case we exit, since we traversed all nodes)
-                         */
-                        while (!currentView[NEXT] && currentView[PARENT] &&
-                            !(tNode.parent && tNode.parent.next)) {
-                            if (tNode === rootTNode)
-                                return;
-                            currentView = currentView[PARENT];
-                            if (isLContainer(currentView)) {
-                                tNode = currentView[T_HOST];
-                                currentView = currentView[PARENT];
-                                beforeNode = currentView[tNode.index][NATIVE];
-                                break;
-                            }
-                            tNode = currentView[T_HOST];
-                        }
-                        if (currentView[NEXT]) {
-                            currentView = currentView[NEXT];
-                            nextTNode = currentView[T_HOST];
-                        }
-                        else {
-                            nextTNode = tNode.type === 4 /* ElementContainer */ && tNode.child || tNode.next;
-                        }
-                    }
-                    else {
-                        nextTNode = tNode.next;
-                    }
-                }
-            }
-            tNode = nextTNode;
-        }
-    }
     /**
      * NOTE: for performance reasons, the possible actions are inlined within the function instead of
      * being passed as an argument.
      */
-    function executeNodeAction(action, renderer, parent, node, tNode, beforeNode) {
+    function executeActionOnElementOrContainer(action, renderer, parent, lNodeToHandle, beforeNode) {
+        ngDevMode && assertDefined(lNodeToHandle, '\'lNodeToHandle\' is undefined');
+        var lContainer;
+        var isComponent = false;
+        // We are expecting an RNode, but in the case of a component or LContainer the `RNode` is wrapped
+        // in an array which needs to be unwrapped. We need to know if it is a component and if
+        // it has LContainer so that we can process all of those cases appropriately.
+        if (isLContainer(lNodeToHandle)) {
+            lContainer = lNodeToHandle;
+        }
+        else if (isLView(lNodeToHandle)) {
+            isComponent = true;
+            ngDevMode && assertDefined(lNodeToHandle[HOST], 'HOST must be defined for a component LView');
+            lNodeToHandle = lNodeToHandle[HOST];
+        }
+        var rNode = unwrapRNode(lNodeToHandle);
+        ngDevMode && assertDomNode(rNode);
         if (action === 0 /* Insert */) {
-            nativeInsertBefore(renderer, parent, node, beforeNode || null);
+            nativeInsertBefore(renderer, parent, rNode, beforeNode || null);
         }
         else if (action === 1 /* Detach */) {
-            nativeRemoveNode(renderer, node, isComponent(tNode));
+            nativeRemoveNode(renderer, rNode, isComponent);
         }
         else if (action === 2 /* Destroy */) {
             ngDevMode && ngDevMode.rendererDestroyNode++;
-            renderer.destroyNode(node);
+            renderer.destroyNode(rNode);
+        }
+        if (lContainer != null) {
+            executeActionOnContainer(renderer, action, lContainer, parent, beforeNode);
         }
     }
     /**
@@ -37384,7 +37221,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
      * @param lView the `LView` to be detached.
      */
     function renderDetachView(lView) {
-        walkTNodeTree(lView, 1 /* Detach */, lView[RENDERER], null);
+        executeActionOnView(lView[RENDERER], 1 /* Detach */, lView, null, null);
     }
     /**
      * Traverses down and up the tree of views and containers to remove listeners and
@@ -37435,15 +37272,15 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
      * A standalone function which destroys an LView,
      * conducting cleanup (e.g. removing listeners, calling onDestroys).
      *
-     * @param view The view to be destroyed.
+     * @param lView The view to be destroyed.
      */
-    function destroyLView(view) {
-        if (!(view[FLAGS] & 256 /* Destroyed */)) {
-            var renderer = view[RENDERER];
+    function destroyLView(lView) {
+        if (!(lView[FLAGS] & 256 /* Destroyed */)) {
+            var renderer = lView[RENDERER];
             if (isProceduralRenderer(renderer) && renderer.destroyNode) {
-                walkTNodeTree(view, 2 /* Destroy */, renderer, null);
+                executeActionOnView(renderer, 2 /* Destroy */, lView, null, null);
             }
-            destroyViewTree(view);
+            destroyViewTree(lView);
         }
     }
     /**
@@ -37506,7 +37343,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
     /** Removes listeners and unsubscribes from output subscriptions */
     function removeListeners(lView) {
         var tCleanup = lView[TVIEW].cleanup;
-        if (tCleanup != null) {
+        if (tCleanup !== null) {
             var lCleanup = lView[CLEANUP];
             for (var i = 0; i < tCleanup.length - 1; i += 2) {
                 if (typeof tCleanup[i] === 'string') {
@@ -37600,6 +37437,137 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             nativeRemoveChild(renderer, nativeParent, rNode, isHostElement);
         }
     }
+    /**
+     * `executeActionOnView` performs an operation on the view as specified in `action` (insert, detach,
+     * destroy)
+     *
+     * Inserting a view without projection or containers at top level is simple. Just iterate over the
+     * root nodes of the View, and for each node perform the `action`.
+     *
+     * Things get more complicated with containers and projections. That is because coming across:
+     * - Container: implies that we have to insert/remove/destroy the views of that container as well
+     *              which in turn can have their own Containers at the View roots.
+     * - Projection: implies that we have to insert/remove/destroy the nodes of the projection. The
+     *               complication is that the nodes we are projecting can themselves have Containers
+     *               or other Projections.
+     *
+     * As you can see this is a very recursive problem. While the recursive implementation is not the
+     * most efficient one, trying to unroll the nodes non-recursively results in very complex code that
+     * is very hard (to maintain). We are sacrificing a bit of performance for readability using a
+     * recursive implementation.
+     *
+     * @param renderer Renderer to use
+     * @param action action to perform (insert, detach, destroy)
+     * @param lView The LView which needs to be inserted, detached, destroyed.
+     * @param renderParent parent DOM element for insertion/removal.
+     * @param beforeNode Before which node the insertions should happen.
+     */
+    function executeActionOnView(renderer, action, lView, renderParent, beforeNode) {
+        var tView = lView[TVIEW];
+        ngDevMode && assertNodeType(tView.node, 2 /* View */);
+        var viewRootTNode = tView.node.child;
+        while (viewRootTNode !== null) {
+            executeActionOnNode(renderer, action, lView, viewRootTNode, renderParent, beforeNode);
+            viewRootTNode = viewRootTNode.next;
+        }
+    }
+    /**
+     * `executeActionOnProjection` performs an operation on the projection specified by `action`
+     * (insert, detach, destroy).
+     *
+     * Inserting a projection requires us to locate the projected nodes from the parent component. The
+     * complication is that those nodes themselves could be re-projected from their parent component.
+     *
+     * @param renderer Renderer to use
+     * @param action action to perform (insert, detach, destroy)
+     * @param lView The LView which needs to be inserted, detached, destroyed.
+     * @param renderParent parent DOM element for insertion/removal.
+     * @param beforeNode Before which node the insertions should happen.
+     */
+    function executeActionOnProjection(renderer, action, lView, tProjectionNode, renderParent, beforeNode) {
+        var componentLView = findComponentView(lView);
+        var componentNode = componentLView[T_HOST];
+        var nodeToProject = componentNode.projection[tProjectionNode.projection];
+        if (Array.isArray(nodeToProject)) {
+            for (var i = 0; i < nodeToProject.length; i++) {
+                var rNode = nodeToProject[i];
+                ngDevMode && assertDomNode(rNode);
+                executeActionOnElementOrContainer(action, renderer, renderParent, rNode, beforeNode);
+            }
+        }
+        else {
+            var projectionTNode = nodeToProject;
+            var projectedComponentLView = componentLView[PARENT];
+            while (projectionTNode !== null) {
+                executeActionOnNode(renderer, action, projectedComponentLView, projectionTNode, renderParent, beforeNode);
+                projectionTNode = projectionTNode.projectionNext;
+            }
+        }
+    }
+    /**
+     * `executeActionOnContainer` performs an operation on the container and its views as specified by
+     * `action` (insert, detach, destroy)
+     *
+     * Inserting a Container is complicated by the fact that the container may have Views which
+     * themselves have containers or projections.
+     *
+     * @param renderer Renderer to use
+     * @param action action to perform (insert, detach, destroy)
+     * @param lContainer The LContainer which needs to be inserted, detached, destroyed.
+     * @param renderParent parent DOM element for insertion/removal.
+     * @param beforeNode Before which node the insertions should happen.
+     */
+    function executeActionOnContainer(renderer, action, lContainer, renderParent, beforeNode) {
+        ngDevMode && assertLContainer(lContainer);
+        var anchor = lContainer[NATIVE]; // LContainer has its own before node.
+        var native = unwrapRNode(lContainer);
+        // An LContainer can be created dynamically on any node by injecting ViewContainerRef.
+        // Asking for a ViewContainerRef on an element will result in a creation of a separate anchor node
+        // (comment in the DOM) that will be different from the LContainer's host node. In this particular
+        // case we need to execute action on 2 nodes:
+        // - container's host node (this is done in the executeNodeAction)
+        // - container's host node (this is done here)
+        if (anchor !== native) {
+            executeActionOnElementOrContainer(action, renderer, renderParent, anchor, beforeNode);
+        }
+        for (var i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+            var lView = lContainer[i];
+            executeActionOnView(renderer, action, lView, renderParent, anchor);
+        }
+    }
+    /**
+     * `executeActionOnElementContainer` performs an operation on the ng-container node and its child
+     * nodes as specified by the `action` (insert, detach, destroy).
+     *
+     * @param renderer Renderer to use
+     * @param action action to perform (insert, detach, destroy)
+     * @param lView The LView which needs to be inserted, detached, destroyed.
+     * @param tElementContainerNode The TNode associated with the ElementContainer.
+     * @param renderParent parent DOM element for insertion/removal.
+     * @param beforeNode Before which node the insertions should happen.
+     */
+    function executeActionOnElementContainer(renderer, action, lView, tElementContainerNode, renderParent, beforeNode) {
+        var node = lView[tElementContainerNode.index];
+        executeActionOnElementOrContainer(action, renderer, renderParent, node, beforeNode);
+        var childTNode = tElementContainerNode.child;
+        while (childTNode) {
+            executeActionOnNode(renderer, action, lView, childTNode, renderParent, beforeNode);
+            childTNode = childTNode.next;
+        }
+    }
+    function executeActionOnNode(renderer, action, lView, tNode, renderParent, beforeNode) {
+        var elementContainerRootTNodeType = tNode.type;
+        if (elementContainerRootTNodeType === 4 /* ElementContainer */) {
+            executeActionOnElementContainer(renderer, action, lView, tNode, renderParent, beforeNode);
+        }
+        else if (elementContainerRootTNodeType === 1 /* Projection */) {
+            executeActionOnProjection(renderer, action, lView, tNode, renderParent, beforeNode);
+        }
+        else {
+            ngDevMode && assertNodeOfPossibleTypes(tNode, 3 /* Element */, 0 /* Container */);
+            executeActionOnElementOrContainer(action, renderer, renderParent, lView[tNode.index], beforeNode);
+        }
+    }
 
     /**
      * @license
@@ -38143,6 +38111,12 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         return ComponentRef;
     }());
     /**
+     * Base class for a factory that can create a component dynamically.
+     * Instantiate a factory for a given type of component with `resolveComponentFactory()`.
+     * Use the resulting `ComponentFactory.create()` method to create a component of that type.
+     *
+     * @see [Dynamic Components](guide/dynamic-component-loader)
+     *
      * @publicApi
      */
     var ComponentFactory = /** @class */ (function () {
@@ -38173,6 +38147,12 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         return _NullComponentFactoryResolver;
     }());
     /**
+     * A simple registry that maps `Components` to generated `ComponentFactory` classes
+     * that can be used to create instances of components.
+     * Use to obtain the factory for a given component type,
+     * then use the factory's `create()` method to create a component of that type.
+     *
+     * @see [Dynamic Components](guide/dynamic-component-loader)
      * @publicApi
      */
     var ComponentFactoryResolver = /** @class */ (function () {
@@ -38696,7 +38676,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
     /**
      * @publicApi
      */
-    var VERSION$2 = new Version$1('8.1.0-next.3');
+    var VERSION$2 = new Version$1('8.1.2');
 
     /**
      * @license
@@ -41655,6 +41635,8 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             var oldLView = enterView(rootLView, null);
             var component;
             var tElementNode;
+            // Will become true if the `try` block executes with no errors.
+            var safeToRunHooks = false;
             try {
                 var componentView = createRootComponentView(hostRNode, this.componentDef, rootLView, rendererFactory, renderer);
                 tElementNode = getTNode(0, rootLView);
@@ -41671,9 +41653,10 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 component = createRootComponent(componentView, this.componentDef, rootLView, rootContext, [LifecycleHooksFeature]);
                 addToViewTree(rootLView, componentView);
                 refreshDescendantViews(rootLView);
+                safeToRunHooks = true;
             }
             finally {
-                leaveView(oldLView);
+                leaveView(oldLView, safeToRunHooks);
             }
             var componentRef = new ComponentRef$1(this.componentType, component, createElementRef(ElementRef, tElementNode, rootLView), rootLView, tElementNode);
             if (isInternalRootView) {
@@ -43652,7 +43635,7 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
      * that create event emitters. When the title is clicked, the emitter
      * emits an open or close event to toggle the current visibility state.
      *
-     * ```
+     * ```html
      * @Component({
      *   selector: 'zippy',
      *   template: `
@@ -43681,17 +43664,10 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
      * Access the event object with the `$event` argument passed to the output event
      * handler:
      *
-     * ```
+     * ```html
      * <zippy (open)="onOpen($event)" (close)="onClose($event)"></zippy>
      * ```
      *
-     * ### Notes
-     *
-     * Uses Rx.Observable but provides an adapter to make it work as specified here:
-     * https://github.com/jhusain/observable-spec
-     *
-     * Once a reference implementation of the spec is available, switch to it.
-     *
      * @publicApi
      */
     var EventEmitter = /** @class */ (function (_super) {
@@ -44008,9 +43984,10 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
     var HostBinding = makePropDecorator('HostBinding', ɵ8);
     var ɵ9 = function (eventName, args) { return ({ eventName: eventName, args: args }); };
     /**
-     * Binds a CSS event to a host listener and supplies configuration metadata.
+     * Decorator that binds a DOM event to a host listener and supplies configuration metadata.
      * Angular invokes the supplied handler method when the host element emits the specified event,
      * and updates the bound element with the result.
+     *
      * If the handler method returns false, applies `preventDefault` on the bound element.
      *
      * @usageNotes
@@ -44018,7 +43995,7 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
      * The following example declares a directive
      * that attaches a click listener to a button and counts clicks.
      *
-     * ```
+     * ```ts
      * @Directive({selector: 'button[counting]'})
      * class CountClicks {
      *   numberOfClicks = 0;
@@ -48662,7 +48639,6 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
     function createLanguageServiceFromTypescript(host, service) {
         var ngHost = new TypeScriptServiceHost(host, service);
         var ngServer = createLanguageService(ngHost);
-        ngHost.setSite(ngServer);
         return ngServer;
     }
     /**
@@ -48707,7 +48683,6 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
             this.modulesOutOfDate = true;
             this.fileVersions = new Map();
         }
-        TypeScriptServiceHost.prototype.setSite = function (service) { this.service = service; };
         Object.defineProperty(TypeScriptServiceHost.prototype, "resolver", {
             /**
              * Angular LanguageServiceHost implementation
@@ -48965,7 +48940,11 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
                     },
                     get query() {
                         if (!queryCache) {
-                            var pipes_1 = t.service.getPipesAt(fileName, node.getStart());
+                            var pipes_1 = [];
+                            var templateInfo = t.getTemplateAstAtPosition(fileName, node.getStart());
+                            if (templateInfo) {
+                                pipes_1 = templateInfo.pipes;
+                            }
                             queryCache = getSymbolQuery(t.program, t.checker, sourceFile, function () { return getPipesTable(sourceFile, t.program, t.checker, pipes_1); });
                         }
                         return queryCache;
@@ -49220,9 +49199,98 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
             }
             return find(sourceFile);
         };
+        TypeScriptServiceHost.prototype.getTemplateAstAtPosition = function (fileName, position) {
+            var template = this.getTemplateAt(fileName, position);
+            if (template) {
+                var astResult = this.getTemplateAst(template, fileName);
+                if (astResult && astResult.htmlAst && astResult.templateAst && astResult.directive &&
+                    astResult.directives && astResult.pipes && astResult.expressionParser)
+                    return {
+                        position: position,
+                        fileName: fileName,
+                        template: template,
+                        htmlAst: astResult.htmlAst,
+                        directive: astResult.directive,
+                        directives: astResult.directives,
+                        pipes: astResult.pipes,
+                        templateAst: astResult.templateAst,
+                        expressionParser: astResult.expressionParser
+                    };
+            }
+            return undefined;
+        };
+        TypeScriptServiceHost.prototype.getTemplateAst = function (template, contextFile) {
+            var _this = this;
+            var result = undefined;
+            try {
+                var resolvedMetadata = this.resolver.getNonNormalizedDirectiveMetadata(template.type);
+                var metadata = resolvedMetadata && resolvedMetadata.metadata;
+                if (metadata) {
+                    var rawHtmlParser = new HtmlParser();
+                    var htmlParser = new I18NHtmlParser(rawHtmlParser);
+                    var expressionParser = new Parser$1(new Lexer());
+                    var config = new CompilerConfig();
+                    var parser = new TemplateParser(config, this.resolver.getReflector(), expressionParser, new DomElementSchemaRegistry(), htmlParser, null, []);
+                    var htmlResult = htmlParser.parse(template.source, '', { tokenizeExpansionForms: true });
+                    var analyzedModules = this.getAnalyzedModules();
+                    var errors = undefined;
+                    var ngModule = analyzedModules.ngModuleByPipeOrDirective.get(template.type);
+                    if (!ngModule) {
+                        // Reported by the the declaration diagnostics.
+                        ngModule = findSuitableDefaultModule(analyzedModules);
+                    }
+                    if (ngModule) {
+                        var directives = ngModule.transitiveModule.directives
+                            .map(function (d) { return _this.resolver.getNonNormalizedDirectiveMetadata(d.reference); })
+                            .filter(function (d) { return d; })
+                            .map(function (d) { return d.metadata.toSummary(); });
+                        var pipes = ngModule.transitiveModule.pipes.map(function (p) { return _this.resolver.getOrLoadPipeMetadata(p.reference).toSummary(); });
+                        var schemas = ngModule.schemas;
+                        var parseResult = parser.tryParseHtml(htmlResult, metadata, directives, pipes, schemas);
+                        result = {
+                            htmlAst: htmlResult.rootNodes,
+                            templateAst: parseResult.templateAst,
+                            directive: metadata, directives: directives, pipes: pipes,
+                            parseErrors: parseResult.errors, expressionParser: expressionParser, errors: errors
+                        };
+                    }
+                }
+            }
+            catch (e) {
+                var span = template.span;
+                if (e.fileName == contextFile) {
+                    span = template.query.getSpanAt(e.line, e.column) || span;
+                }
+                result = { errors: [{ kind: DiagnosticKind$1.Error, message: e.message, span: span }] };
+            }
+            return result || {};
+        };
         TypeScriptServiceHost.missingTemplate = [undefined, undefined];
         return TypeScriptServiceHost;
     }());
+    function findSuitableDefaultModule(modules) {
+        var e_5, _a;
+        var result = undefined;
+        var resultSize = 0;
+        try {
+            for (var _b = __values(modules.ngModules), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var module_2 = _c.value;
+                var moduleSize = module_2.transitiveModule.directives.length;
+                if (moduleSize > resultSize) {
+                    result = module_2;
+                    resultSize = moduleSize;
+                }
+            }
+        }
+        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;
+    }
     function findTsConfig(fileName) {
         var dir = path.dirname(fileName);
         while (fs.existsSync(dir)) {
@@ -49331,7 +49399,6 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
         }
         var serviceHost = new TypeScriptServiceHost(info.languageServiceHost, oldLS);
         var ls = createLanguageService(serviceHost);
-        serviceHost.setSite(ls);
         projectHostMap.set(info.project, serviceHost);
         proxy.getCompletionsAtPosition = function (fileName, position, options) {
             var base = oldLS.getCompletionsAtPosition(fileName, position, options) || {
@@ -49470,7 +49537,7 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
      * 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$3 = new Version$1('8.1.0-next.3');
+    var VERSION$3 = new Version$1('8.1.2');
 
     /**
      * @license