@angular/language-service 9.0.3 → 9.0.7

package/bundles/language-service.umd.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v9.0.3
+ * @license Angular v9.0.7
  * Copyright Google Inc. All Rights Reserved.
  * License: MIT
  */
@@ -7263,120 +7263,98 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         return ASTWithSource;
     }(AST));
     var TemplateBinding = /** @class */ (function () {
-        function TemplateBinding(span, sourceSpan, key, keyIsVar, name, expression) {
+        function TemplateBinding(span, sourceSpan, key, keyIsVar, name, value) {
             this.span = span;
             this.key = key;
             this.keyIsVar = keyIsVar;
             this.name = name;
-            this.expression = expression;
+            this.value = value;
         }
         return TemplateBinding;
     }());
-    var NullAstVisitor = /** @class */ (function () {
-        function NullAstVisitor() {
-        }
-        NullAstVisitor.prototype.visitBinary = function (ast, context) { };
-        NullAstVisitor.prototype.visitChain = function (ast, context) { };
-        NullAstVisitor.prototype.visitConditional = function (ast, context) { };
-        NullAstVisitor.prototype.visitFunctionCall = function (ast, context) { };
-        NullAstVisitor.prototype.visitImplicitReceiver = function (ast, context) { };
-        NullAstVisitor.prototype.visitInterpolation = function (ast, context) { };
-        NullAstVisitor.prototype.visitKeyedRead = function (ast, context) { };
-        NullAstVisitor.prototype.visitKeyedWrite = function (ast, context) { };
-        NullAstVisitor.prototype.visitLiteralArray = function (ast, context) { };
-        NullAstVisitor.prototype.visitLiteralMap = function (ast, context) { };
-        NullAstVisitor.prototype.visitLiteralPrimitive = function (ast, context) { };
-        NullAstVisitor.prototype.visitMethodCall = function (ast, context) { };
-        NullAstVisitor.prototype.visitPipe = function (ast, context) { };
-        NullAstVisitor.prototype.visitPrefixNot = function (ast, context) { };
-        NullAstVisitor.prototype.visitNonNullAssert = function (ast, context) { };
-        NullAstVisitor.prototype.visitPropertyRead = function (ast, context) { };
-        NullAstVisitor.prototype.visitPropertyWrite = function (ast, context) { };
-        NullAstVisitor.prototype.visitQuote = function (ast, context) { };
-        NullAstVisitor.prototype.visitSafeMethodCall = function (ast, context) { };
-        NullAstVisitor.prototype.visitSafePropertyRead = function (ast, context) { };
-        return NullAstVisitor;
-    }());
     var RecursiveAstVisitor$1 = /** @class */ (function () {
         function RecursiveAstVisitor() {
         }
+        RecursiveAstVisitor.prototype.visit = function (ast, context) {
+            // The default implementation just visits every node.
+            // Classes that extend RecursiveAstVisitor should override this function
+            // to selectively visit the specified node.
+            ast.visit(this, context);
+        };
         RecursiveAstVisitor.prototype.visitBinary = function (ast, context) {
-            ast.left.visit(this, context);
-            ast.right.visit(this, context);
-            return null;
+            this.visit(ast.left, context);
+            this.visit(ast.right, context);
         };
-        RecursiveAstVisitor.prototype.visitChain = function (ast, context) { return this.visitAll(ast.expressions, context); };
+        RecursiveAstVisitor.prototype.visitChain = function (ast, context) { this.visitAll(ast.expressions, context); };
         RecursiveAstVisitor.prototype.visitConditional = function (ast, context) {
-            ast.condition.visit(this, context);
-            ast.trueExp.visit(this, context);
-            ast.falseExp.visit(this, context);
-            return null;
+            this.visit(ast.condition, context);
+            this.visit(ast.trueExp, context);
+            this.visit(ast.falseExp, context);
         };
         RecursiveAstVisitor.prototype.visitPipe = function (ast, context) {
-            ast.exp.visit(this, context);
+            this.visit(ast.exp, context);
             this.visitAll(ast.args, context);
-            return null;
         };
         RecursiveAstVisitor.prototype.visitFunctionCall = function (ast, context) {
-            ast.target.visit(this, context);
+            if (ast.target) {
+                this.visit(ast.target, context);
+            }
             this.visitAll(ast.args, context);
-            return null;
         };
-        RecursiveAstVisitor.prototype.visitImplicitReceiver = function (ast, context) { return null; };
+        RecursiveAstVisitor.prototype.visitImplicitReceiver = function (ast, context) { };
         RecursiveAstVisitor.prototype.visitInterpolation = function (ast, context) {
-            return this.visitAll(ast.expressions, context);
+            this.visitAll(ast.expressions, context);
         };
         RecursiveAstVisitor.prototype.visitKeyedRead = function (ast, context) {
-            ast.obj.visit(this, context);
-            ast.key.visit(this, context);
-            return null;
+            this.visit(ast.obj, context);
+            this.visit(ast.key, context);
         };
         RecursiveAstVisitor.prototype.visitKeyedWrite = function (ast, context) {
-            ast.obj.visit(this, context);
-            ast.key.visit(this, context);
-            ast.value.visit(this, context);
-            return null;
+            this.visit(ast.obj, context);
+            this.visit(ast.key, context);
+            this.visit(ast.value, context);
         };
         RecursiveAstVisitor.prototype.visitLiteralArray = function (ast, context) {
-            return this.visitAll(ast.expressions, context);
+            this.visitAll(ast.expressions, context);
         };
-        RecursiveAstVisitor.prototype.visitLiteralMap = function (ast, context) { return this.visitAll(ast.values, context); };
-        RecursiveAstVisitor.prototype.visitLiteralPrimitive = function (ast, context) { return null; };
+        RecursiveAstVisitor.prototype.visitLiteralMap = function (ast, context) { this.visitAll(ast.values, context); };
+        RecursiveAstVisitor.prototype.visitLiteralPrimitive = function (ast, context) { };
         RecursiveAstVisitor.prototype.visitMethodCall = function (ast, context) {
-            ast.receiver.visit(this, context);
-            return this.visitAll(ast.args, context);
-        };
-        RecursiveAstVisitor.prototype.visitPrefixNot = function (ast, context) {
-            ast.expression.visit(this, context);
-            return null;
-        };
-        RecursiveAstVisitor.prototype.visitNonNullAssert = function (ast, context) {
-            ast.expression.visit(this, context);
-            return null;
-        };
-        RecursiveAstVisitor.prototype.visitPropertyRead = function (ast, context) {
-            ast.receiver.visit(this, context);
-            return null;
+            this.visit(ast.receiver, context);
+            this.visitAll(ast.args, context);
         };
+        RecursiveAstVisitor.prototype.visitPrefixNot = function (ast, context) { this.visit(ast.expression, context); };
+        RecursiveAstVisitor.prototype.visitNonNullAssert = function (ast, context) { this.visit(ast.expression, context); };
+        RecursiveAstVisitor.prototype.visitPropertyRead = function (ast, context) { this.visit(ast.receiver, context); };
         RecursiveAstVisitor.prototype.visitPropertyWrite = function (ast, context) {
-            ast.receiver.visit(this, context);
-            ast.value.visit(this, context);
-            return null;
+            this.visit(ast.receiver, context);
+            this.visit(ast.value, context);
         };
         RecursiveAstVisitor.prototype.visitSafePropertyRead = function (ast, context) {
-            ast.receiver.visit(this, context);
-            return null;
+            this.visit(ast.receiver, context);
         };
         RecursiveAstVisitor.prototype.visitSafeMethodCall = function (ast, context) {
-            ast.receiver.visit(this, context);
-            return this.visitAll(ast.args, context);
+            this.visit(ast.receiver, context);
+            this.visitAll(ast.args, context);
         };
+        RecursiveAstVisitor.prototype.visitQuote = function (ast, context) { };
+        // This is not part of the AstVisitor interface, just a helper method
         RecursiveAstVisitor.prototype.visitAll = function (asts, context) {
-            var _this = this;
-            asts.forEach(function (ast) { return ast.visit(_this, context); });
-            return null;
+            var e_1, _a;
+            try {
+                for (var asts_1 = __values(asts), asts_1_1 = asts_1.next(); !asts_1_1.done; asts_1_1 = asts_1.next()) {
+                    var ast = asts_1_1.value;
+                    this.visit(ast, context);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (asts_1_1 && !asts_1_1.done && (_a = asts_1.return)) _a.call(asts_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
         };
-        RecursiveAstVisitor.prototype.visitQuote = function (ast, context) { return null; };
         return RecursiveAstVisitor;
     }());
     var AstTransformer$1 = /** @class */ (function () {
@@ -7599,65 +7577,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         AstMemoryEfficientTransformer.prototype.visitQuote = function (ast, context) { return ast; };
         return AstMemoryEfficientTransformer;
     }());
-    function visitAstChildren(ast, visitor, context) {
-        function visit(ast) {
-            visitor.visit && visitor.visit(ast, context) || ast.visit(visitor, context);
-        }
-        function visitAll(asts) { asts.forEach(visit); }
-        ast.visit({
-            visitBinary: function (ast) {
-                visit(ast.left);
-                visit(ast.right);
-            },
-            visitChain: function (ast) { visitAll(ast.expressions); },
-            visitConditional: function (ast) {
-                visit(ast.condition);
-                visit(ast.trueExp);
-                visit(ast.falseExp);
-            },
-            visitFunctionCall: function (ast) {
-                if (ast.target) {
-                    visit(ast.target);
-                }
-                visitAll(ast.args);
-            },
-            visitImplicitReceiver: function (ast) { },
-            visitInterpolation: function (ast) { visitAll(ast.expressions); },
-            visitKeyedRead: function (ast) {
-                visit(ast.obj);
-                visit(ast.key);
-            },
-            visitKeyedWrite: function (ast) {
-                visit(ast.obj);
-                visit(ast.key);
-                visit(ast.obj);
-            },
-            visitLiteralArray: function (ast) { visitAll(ast.expressions); },
-            visitLiteralMap: function (ast) { },
-            visitLiteralPrimitive: function (ast) { },
-            visitMethodCall: function (ast) {
-                visit(ast.receiver);
-                visitAll(ast.args);
-            },
-            visitPipe: function (ast) {
-                visit(ast.exp);
-                visitAll(ast.args);
-            },
-            visitPrefixNot: function (ast) { visit(ast.expression); },
-            visitNonNullAssert: function (ast) { visit(ast.expression); },
-            visitPropertyRead: function (ast) { visit(ast.receiver); },
-            visitPropertyWrite: function (ast) {
-                visit(ast.receiver);
-                visit(ast.value);
-            },
-            visitQuote: function (ast) { },
-            visitSafeMethodCall: function (ast) {
-                visit(ast.receiver);
-                visitAll(ast.args);
-            },
-            visitSafePropertyRead: function (ast) { visit(ast.receiver); },
-        });
-    }
     // Bindings
     var ParsedProperty = /** @class */ (function () {
         function ParsedProperty(name, expression, type, sourceSpan, valueSpan) {
@@ -11560,8 +11479,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 if (binding.keyIsVar) {
                     targetVars.push(new ParsedVariable(binding.key, binding.name, sourceSpan));
                 }
-                else if (binding.expression) {
-                    this._parsePropertyAst(binding.key, binding.expression, sourceSpan, undefined, targetMatchableAttrs, targetProps);
+                else if (binding.value) {
+                    this._parsePropertyAst(binding.key, binding.value, sourceSpan, undefined, targetMatchableAttrs, targetProps);
                 }
                 else {
                     targetMatchableAttrs.push([binding.key, '']);
@@ -11584,8 +11503,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 var bindingsResult = this._exprParser.parseTemplateBindings(tplKey, tplValue, sourceInfo, absoluteValueOffset);
                 this._reportExpressionParserErrors(bindingsResult.errors, sourceSpan);
                 bindingsResult.templateBindings.forEach(function (binding) {
-                    if (binding.expression) {
-                        _this._checkPipes(binding.expression, sourceSpan);
+                    if (binding.value) {
+                        _this._checkPipes(binding.value, sourceSpan);
                     }
                 });
                 bindingsResult.warnings.forEach(function (warning) { _this._reportError(warning, sourceSpan, ParseErrorLevel.WARNING); });
@@ -12902,8 +12821,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var binding = null;
             var prefix = name.substring(0, 6);
             var isStyle = name === 'style' || prefix === 'style.' || prefix === 'style!';
-            var isClass = !isStyle &&
-                (name === 'class' || name === 'className' || prefix === 'class.' || prefix === 'class!');
+            var isClass = !isStyle && (name === 'class' || prefix === 'class.' || prefix === 'class!');
             if (isStyle || isClass) {
                 var isMapBased = name.charAt(5) !== '.'; // style.prop or class.prop makes this a no
                 var property = name.substr(isMapBased ? 5 : 6); // the dot explains why there's a +1
@@ -13744,10 +13662,34 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var span = new ParseSpan(0, input.length);
             return new Quote(span, span.toAbsolute(absoluteOffset), prefix, uninterpretedExpression, location);
         };
-        Parser.prototype.parseTemplateBindings = function (tplKey, tplValue, location, absoluteOffset) {
-            var tokens = this._lexer.tokenize(tplValue);
-            return new _ParseAST(tplValue, location, absoluteOffset, tokens, tplValue.length, false, this.errors, 0)
-                .parseTemplateBindings(tplKey);
+        /**
+         * Parse microsyntax template expression and return a list of bindings or
+         * parsing errors in case the given expression is invalid.
+         *
+         * For example,
+         * ```
+         *   <div *ngFor="let item of items">
+         *                ^ `absoluteOffset` for `tplValue`
+         * ```
+         * contains three bindings:
+         * 1. ngFor -> null
+         * 2. item -> NgForOfContext.$implicit
+         * 3. ngForOf -> items
+         *
+         * This is apparent from the de-sugared template:
+         * ```
+         *   <ng-template ngFor let-item [ngForOf]="items">
+         * ```
+         *
+         * @param templateKey name of directive, without the * prefix. For example: ngIf, ngFor
+         * @param templateValue RHS of the microsyntax attribute
+         * @param templateUrl template filename if it's external, component filename if it's inline
+         * @param absoluteOffset absolute offset of the `tplValue`
+         */
+        Parser.prototype.parseTemplateBindings = function (templateKey, templateValue, templateUrl, absoluteOffset) {
+            var tokens = this._lexer.tokenize(templateValue);
+            return new _ParseAST(templateValue, templateUrl, absoluteOffset, tokens, templateValue.length, false /* parseAction */, this.errors, 0 /* relative offset */)
+                .parseTemplateBindings(templateKey);
         };
         Parser.prototype.parseInterpolation = function (input, location, absoluteOffset, interpolationConfig) {
             if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }
@@ -13895,7 +13837,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return this.sourceSpanCache.get(serial);
         };
         _ParseAST.prototype.advance = function () { this.index++; };
-        _ParseAST.prototype.optionalCharacter = function (code) {
+        _ParseAST.prototype.consumeOptionalCharacter = function (code) {
             if (this.next.isCharacter(code)) {
                 this.advance();
                 return true;
@@ -13907,11 +13849,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         _ParseAST.prototype.peekKeywordLet = function () { return this.next.isKeywordLet(); };
         _ParseAST.prototype.peekKeywordAs = function () { return this.next.isKeywordAs(); };
         _ParseAST.prototype.expectCharacter = function (code) {
-            if (this.optionalCharacter(code))
+            if (this.consumeOptionalCharacter(code))
                 return;
             this.error("Missing expected " + String.fromCharCode(code));
         };
-        _ParseAST.prototype.optionalOperator = function (op) {
+        _ParseAST.prototype.consumeOptionalOperator = function (op) {
             if (this.next.isOperator(op)) {
                 this.advance();
                 return true;
@@ -13921,7 +13863,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
         };
         _ParseAST.prototype.expectOperator = function (operator) {
-            if (this.optionalOperator(operator))
+            if (this.consumeOptionalOperator(operator))
                 return;
             this.error("Missing expected operator " + operator);
         };
@@ -13949,11 +13891,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             while (this.index < this.tokens.length) {
                 var expr = this.parsePipe();
                 exprs.push(expr);
-                if (this.optionalCharacter($SEMICOLON)) {
+                if (this.consumeOptionalCharacter($SEMICOLON)) {
                     if (!this.parseAction) {
                         this.error('Binding expression cannot contain chained expression');
                     }
-                    while (this.optionalCharacter($SEMICOLON)) {
+                    while (this.consumeOptionalCharacter($SEMICOLON)) {
                     } // read all semicolons
                 }
                 else if (this.index < this.tokens.length) {
@@ -13968,7 +13910,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         };
         _ParseAST.prototype.parsePipe = function () {
             var result = this.parseExpression();
-            if (this.optionalOperator('|')) {
+            if (this.consumeOptionalOperator('|')) {
                 if (this.parseAction) {
                     this.error('Cannot have a pipe in an action expression');
                 }
@@ -13977,13 +13919,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     var name_1 = this.expectIdentifierOrKeyword();
                     var nameSpan = this.sourceSpan(nameStart);
                     var args = [];
-                    while (this.optionalCharacter($COLON)) {
+                    while (this.consumeOptionalCharacter($COLON)) {
                         args.push(this.parseExpression());
                     }
                     var start = result.span.start;
                     result =
                         new BindingPipe(this.span(start), this.sourceSpan(start), result, name_1, args, nameSpan);
-                } while (this.optionalOperator('|'));
+                } while (this.consumeOptionalOperator('|'));
             }
             return result;
         };
@@ -13991,10 +13933,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         _ParseAST.prototype.parseConditional = function () {
             var start = this.inputIndex;
             var result = this.parseLogicalOr();
-            if (this.optionalOperator('?')) {
+            if (this.consumeOptionalOperator('?')) {
                 var yes = this.parsePipe();
                 var no = void 0;
-                if (!this.optionalCharacter($COLON)) {
+                if (!this.consumeOptionalCharacter($COLON)) {
                     var end = this.inputIndex;
                     var expression = this.input.substring(start, end);
                     this.error("Conditional expression " + expression + " requires all 3 expressions");
@@ -14012,7 +13954,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         _ParseAST.prototype.parseLogicalOr = function () {
             // '||'
             var result = this.parseLogicalAnd();
-            while (this.optionalOperator('||')) {
+            while (this.consumeOptionalOperator('||')) {
                 var right = this.parseLogicalAnd();
                 var start = result.span.start;
                 result = new Binary(this.span(start), this.sourceSpan(start), '||', result, right);
@@ -14022,7 +13964,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         _ParseAST.prototype.parseLogicalAnd = function () {
             // '&&'
             var result = this.parseEquality();
-            while (this.optionalOperator('&&')) {
+            while (this.consumeOptionalOperator('&&')) {
                 var right = this.parseEquality();
                 var start = result.span.start;
                 result = new Binary(this.span(start), this.sourceSpan(start), '&&', result, right);
@@ -14134,18 +14076,18 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var result = this.parsePrimary();
             var resultStart = result.span.start;
             while (true) {
-                if (this.optionalCharacter($PERIOD)) {
+                if (this.consumeOptionalCharacter($PERIOD)) {
                     result = this.parseAccessMemberOrMethodCall(result, false);
                 }
-                else if (this.optionalOperator('?.')) {
+                else if (this.consumeOptionalOperator('?.')) {
                     result = this.parseAccessMemberOrMethodCall(result, true);
                 }
-                else if (this.optionalCharacter($LBRACKET)) {
+                else if (this.consumeOptionalCharacter($LBRACKET)) {
                     this.rbracketsExpected++;
                     var key = this.parsePipe();
                     this.rbracketsExpected--;
                     this.expectCharacter($RBRACKET);
-                    if (this.optionalOperator('=')) {
+                    if (this.consumeOptionalOperator('=')) {
                         var value = this.parseConditional();
                         result = new KeyedWrite(this.span(resultStart), this.sourceSpan(resultStart), result, key, value);
                     }
@@ -14153,7 +14095,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                         result = new KeyedRead(this.span(resultStart), this.sourceSpan(resultStart), result, key);
                     }
                 }
-                else if (this.optionalCharacter($LPAREN)) {
+                else if (this.consumeOptionalCharacter($LPAREN)) {
                     this.rparensExpected++;
                     var args = this.parseCallArguments();
                     this.rparensExpected--;
@@ -14161,7 +14103,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     result =
                         new FunctionCall(this.span(resultStart), this.sourceSpan(resultStart), result, args);
                 }
-                else if (this.optionalOperator('!')) {
+                else if (this.consumeOptionalOperator('!')) {
                     result = new NonNullAssert(this.span(resultStart), this.sourceSpan(resultStart), result);
                 }
                 else {
@@ -14171,7 +14113,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         };
         _ParseAST.prototype.parsePrimary = function () {
             var start = this.inputIndex;
-            if (this.optionalCharacter($LPAREN)) {
+            if (this.consumeOptionalCharacter($LPAREN)) {
                 this.rparensExpected++;
                 var result = this.parsePipe();
                 this.rparensExpected--;
@@ -14198,7 +14140,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 this.advance();
                 return new ImplicitReceiver(this.span(start), this.sourceSpan(start));
             }
-            else if (this.optionalCharacter($LBRACKET)) {
+            else if (this.consumeOptionalCharacter($LBRACKET)) {
                 this.rbracketsExpected++;
                 var elements = this.parseExpressionList($RBRACKET);
                 this.rbracketsExpected--;
@@ -14235,7 +14177,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             if (!this.next.isCharacter(terminator)) {
                 do {
                     result.push(this.parsePipe());
-                } while (this.optionalCharacter($COMMA));
+                } while (this.consumeOptionalCharacter($COMMA));
             }
             return result;
         };
@@ -14244,7 +14186,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var values = [];
             var start = this.inputIndex;
             this.expectCharacter($LBRACE);
-            if (!this.optionalCharacter($RBRACE)) {
+            if (!this.consumeOptionalCharacter($RBRACE)) {
                 this.rbracesExpected++;
                 do {
                     var quoted = this.next.isString();
@@ -14252,7 +14194,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     keys.push({ key: key, quoted: quoted });
                     this.expectCharacter($COLON);
                     values.push(this.parsePipe());
-                } while (this.optionalCharacter($COMMA));
+                } while (this.consumeOptionalCharacter($COMMA));
                 this.rbracesExpected--;
                 this.expectCharacter($RBRACE);
             }
@@ -14262,7 +14204,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             if (isSafe === void 0) { isSafe = false; }
             var start = receiver.span.start;
             var id = this.expectIdentifierOrKeyword();
-            if (this.optionalCharacter($LPAREN)) {
+            if (this.consumeOptionalCharacter($LPAREN)) {
                 this.rparensExpected++;
                 var args = this.parseCallArguments();
                 this.expectCharacter($RPAREN);
@@ -14274,7 +14216,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             else {
                 if (isSafe) {
-                    if (this.optionalOperator('=')) {
+                    if (this.consumeOptionalOperator('=')) {
                         this.error('The \'?.\' operator cannot be used in the assignment');
                         return new EmptyExpr(this.span(start), this.sourceSpan(start));
                     }
@@ -14283,7 +14225,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     }
                 }
                 else {
-                    if (this.optionalOperator('=')) {
+                    if (this.consumeOptionalOperator('=')) {
                         if (!this.parseAction) {
                             this.error('Bindings cannot contain assignments');
                             return new EmptyExpr(this.span(start), this.sourceSpan(start));
@@ -14304,81 +14246,193 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var positionals = [];
             do {
                 positionals.push(this.parsePipe());
-            } while (this.optionalCharacter($COMMA));
+            } while (this.consumeOptionalCharacter($COMMA));
             return positionals;
         };
         /**
-         * An identifier, a keyword, a string with an optional `-` in between.
+         * Parses an identifier, a keyword, a string with an optional `-` in between.
          */
         _ParseAST.prototype.expectTemplateBindingKey = function () {
             var result = '';
             var operatorFound = false;
+            var start = this.inputIndex;
             do {
                 result += this.expectIdentifierOrKeywordOrString();
-                operatorFound = this.optionalOperator('-');
+                operatorFound = this.consumeOptionalOperator('-');
                 if (operatorFound) {
                     result += '-';
                 }
             } while (operatorFound);
-            return result.toString();
+            return {
+                key: result,
+                keySpan: new ParseSpan(start, start + result.length),
+            };
         };
-        // Parses the AST for `<some-tag *tplKey=AST>`
-        _ParseAST.prototype.parseTemplateBindings = function (tplKey) {
-            var firstBinding = true;
+        /**
+         * Parse microsyntax template expression and return a list of bindings or
+         * parsing errors in case the given expression is invalid.
+         *
+         * For example,
+         * ```
+         *   <div *ngFor="let item of items; index as i; trackBy: func">
+         * ```
+         * contains five bindings:
+         * 1. ngFor -> null
+         * 2. item -> NgForOfContext.$implicit
+         * 3. ngForOf -> items
+         * 4. i -> NgForOfContext.index
+         * 5. ngForTrackBy -> func
+         *
+         * For a full description of the microsyntax grammar, see
+         * https://gist.github.com/mhevery/d3530294cff2e4a1b3fe15ff75d08855
+         *
+         * @param templateKey name of the microsyntax directive, like ngIf, ngFor, without the *
+         */
+        _ParseAST.prototype.parseTemplateBindings = function (templateKey) {
             var bindings = [];
-            var warnings = [];
-            do {
-                var start = this.inputIndex;
-                var rawKey = void 0;
-                var key = void 0;
-                var isVar = false;
-                if (firstBinding) {
-                    rawKey = key = tplKey;
-                    firstBinding = false;
+            // The first binding is for the template key itself
+            // In *ngFor="let item of items", key = "ngFor", value = null
+            // In *ngIf="cond | pipe", key = "ngIf", value = "cond | pipe"
+            bindings.push.apply(bindings, __spread(this.parseDirectiveKeywordBindings(templateKey, new ParseSpan(0, templateKey.length), this.absoluteOffset)));
+            while (this.index < this.tokens.length) {
+                // If it starts with 'let', then this must be variable declaration
+                var letBinding = this.parseLetBinding();
+                if (letBinding) {
+                    bindings.push(letBinding);
                 }
                 else {
-                    isVar = this.peekKeywordLet();
-                    if (isVar)
-                        this.advance();
-                    rawKey = this.expectTemplateBindingKey();
-                    key = isVar ? rawKey : tplKey + rawKey[0].toUpperCase() + rawKey.substring(1);
-                    this.optionalCharacter($COLON);
-                }
-                var name_2 = null;
-                var expression = null;
-                if (isVar) {
-                    if (this.optionalOperator('=')) {
-                        name_2 = this.expectTemplateBindingKey();
+                    // Two possible cases here, either `value "as" key` or
+                    // "directive-keyword expression". We don't know which case, but both
+                    // "value" and "directive-keyword" are template binding key, so consume
+                    // the key first.
+                    var _a = this.expectTemplateBindingKey(), key = _a.key, keySpan = _a.keySpan;
+                    // Peek at the next token, if it is "as" then this must be variable
+                    // declaration.
+                    var binding = this.parseAsBinding(key, keySpan, this.absoluteOffset);
+                    if (binding) {
+                        bindings.push(binding);
                     }
                     else {
-                        name_2 = '\$implicit';
+                        // Otherwise the key must be a directive keyword, like "of". Transform
+                        // the key to actual key. Eg. of -> ngForOf, trackBy -> ngForTrackBy
+                        var actualKey = templateKey + key[0].toUpperCase() + key.substring(1);
+                        bindings.push.apply(bindings, __spread(this.parseDirectiveKeywordBindings(actualKey, keySpan, this.absoluteOffset)));
                     }
                 }
-                else if (this.peekKeywordAs()) {
-                    this.advance(); // consume `as`
-                    name_2 = rawKey;
-                    key = this.expectTemplateBindingKey(); // read local var name
-                    isVar = true;
-                }
-                else if (this.next !== EOF && !this.peekKeywordLet()) {
-                    var start_1 = this.inputIndex;
-                    var ast = this.parsePipe();
-                    var source = this.input.substring(start_1 - this.offset, this.inputIndex - this.offset);
-                    expression =
-                        new ASTWithSource(ast, source, this.location, this.absoluteOffset + start_1, this.errors);
-                }
-                bindings.push(new TemplateBinding(this.span(start), this.sourceSpan(start), key, isVar, name_2, expression));
-                if (this.peekKeywordAs() && !isVar) {
-                    var letStart = this.inputIndex;
-                    this.advance(); // consume `as`
-                    var letName = this.expectTemplateBindingKey(); // read local var name
-                    bindings.push(new TemplateBinding(this.span(letStart), this.sourceSpan(letStart), letName, true, key, null));
-                }
-                if (!this.optionalCharacter($SEMICOLON)) {
-                    this.optionalCharacter($COMMA);
-                }
-            } while (this.index < this.tokens.length);
-            return new TemplateBindingParseResult(bindings, warnings, this.errors);
+                this.consumeStatementTerminator();
+            }
+            return new TemplateBindingParseResult(bindings, [] /* warnings */, this.errors);
+        };
+        /**
+         * Parse a directive keyword, followed by a mandatory expression.
+         * For example, "of items", "trackBy: func".
+         * The bindings are: ngForOf -> items, ngForTrackBy -> func
+         * There could be an optional "as" binding that follows the expression.
+         * For example,
+         * ```
+         * *ngFor="let item of items | slice:0:1 as collection".`
+         *                  ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^
+         *             keyword    bound target   optional 'as' binding
+         * ```
+         *
+         * @param key binding key, for example, ngFor, ngIf, ngForOf
+         * @param keySpan span of the key in the expression. keySpan might be different
+         * from `key.length`. For example, the span for key "ngForOf" is "of".
+         * @param absoluteOffset absolute offset of the attribute value
+         */
+        _ParseAST.prototype.parseDirectiveKeywordBindings = function (key, keySpan, absoluteOffset) {
+            var _a;
+            var bindings = [];
+            this.consumeOptionalCharacter($COLON); // trackBy: trackByFunction
+            var valueExpr = this.getDirectiveBoundTarget();
+            var span = new ParseSpan(keySpan.start, this.inputIndex);
+            bindings.push(new TemplateBinding(span, span.toAbsolute(absoluteOffset), key, false /* keyIsVar */, ((_a = valueExpr) === null || _a === void 0 ? void 0 : _a.source) || '', valueExpr));
+            // The binding could optionally be followed by "as". For example,
+            // *ngIf="cond | pipe as x". In this case, the key in the "as" binding
+            // is "x" and the value is the template key itself ("ngIf"). Note that the
+            // 'key' in the current context now becomes the "value" in the next binding.
+            var asBinding = this.parseAsBinding(key, keySpan, absoluteOffset);
+            if (asBinding) {
+                bindings.push(asBinding);
+            }
+            this.consumeStatementTerminator();
+            return bindings;
+        };
+        /**
+         * Return the expression AST for the bound target of a directive keyword
+         * binding. For example,
+         * ```
+         * *ngIf="condition | pipe".
+         *        ^^^^^^^^^^^^^^^^ bound target for "ngIf"
+         * *ngFor="let item of items"
+         *                     ^^^^^ bound target for "ngForOf"
+         * ```
+         */
+        _ParseAST.prototype.getDirectiveBoundTarget = function () {
+            if (this.next === EOF || this.peekKeywordAs() || this.peekKeywordLet()) {
+                return null;
+            }
+            var ast = this.parsePipe(); // example: "condition | async"
+            var _a = ast.span, start = _a.start, end = _a.end;
+            var value = this.input.substring(start, end);
+            return new ASTWithSource(ast, value, this.location, this.absoluteOffset + start, this.errors);
+        };
+        /**
+         * Return the binding for a variable declared using `as`. Note that the order
+         * of the key-value pair in this declaration is reversed. For example,
+         * ```
+         * *ngFor="let item of items; index as i"
+         *                            ^^^^^    ^
+         *                            value    key
+         * ```
+         *
+         * @param value name of the value in the declaration, "ngIf" in the example above
+         * @param valueSpan span of the value in the declaration
+         * @param absoluteOffset absolute offset of `value`
+         */
+        _ParseAST.prototype.parseAsBinding = function (value, valueSpan, absoluteOffset) {
+            if (!this.peekKeywordAs()) {
+                return null;
+            }
+            this.advance(); // consume the 'as' keyword
+            var key = this.expectTemplateBindingKey().key;
+            var valueAst = new AST(valueSpan, valueSpan.toAbsolute(absoluteOffset));
+            var valueExpr = new ASTWithSource(valueAst, value, this.location, absoluteOffset + valueSpan.start, this.errors);
+            var span = new ParseSpan(valueSpan.start, this.inputIndex);
+            return new TemplateBinding(span, span.toAbsolute(absoluteOffset), key, true /* keyIsVar */, value, valueExpr);
+        };
+        /**
+         * Return the binding for a variable declared using `let`. For example,
+         * ```
+         * *ngFor="let item of items; let i=index;"
+         *         ^^^^^^^^           ^^^^^^^^^^^
+         * ```
+         * In the first binding, `item` is bound to `NgForOfContext.$implicit`.
+         * In the second binding, `i` is bound to `NgForOfContext.index`.
+         */
+        _ParseAST.prototype.parseLetBinding = function () {
+            var _a;
+            if (!this.peekKeywordLet()) {
+                return null;
+            }
+            var spanStart = this.inputIndex;
+            this.advance(); // consume the 'let' keyword
+            var key = this.expectTemplateBindingKey().key;
+            var valueExpr = null;
+            if (this.consumeOptionalOperator('=')) {
+                var _b = this.expectTemplateBindingKey(), value = _b.key, valueSpan = _b.keySpan;
+                var ast = new AST(valueSpan, valueSpan.toAbsolute(this.absoluteOffset));
+                valueExpr = new ASTWithSource(ast, value, this.location, this.absoluteOffset + valueSpan.start, this.errors);
+            }
+            var spanEnd = this.inputIndex;
+            var span = new ParseSpan(spanStart, spanEnd);
+            return new TemplateBinding(span, span.toAbsolute(this.absoluteOffset), key, true /* keyIsVar */, ((_a = valueExpr) === null || _a === void 0 ? void 0 : _a.source) || '$implicit', valueExpr);
+        };
+        /**
+         * Consume the optional statement terminator: semicolon or comma.
+         */
+        _ParseAST.prototype.consumeStatementTerminator = function () {
+            this.consumeOptionalCharacter($SEMICOLON) || this.consumeOptionalCharacter($COMMA);
         };
         _ParseAST.prototype.error = function (message, index) {
             if (index === void 0) { index = null; }
@@ -16611,6 +16665,45 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             this.i18n = null; // reset local i18n context
         };
+        TemplateDefinitionBuilder.prototype.i18nAttributesInstruction = function (nodeIndex, attrs, sourceSpan) {
+            var _this = this;
+            var hasBindings = false;
+            var i18nAttrArgs = [];
+            var bindings = [];
+            attrs.forEach(function (attr) {
+                var message = attr.i18n;
+                if (attr instanceof TextAttribute) {
+                    i18nAttrArgs.push(literal(attr.name), _this.i18nTranslate(message));
+                }
+                else {
+                    var converted = attr.value.visit(_this._valueConverter);
+                    _this.allocateBindingSlots(converted);
+                    if (converted instanceof Interpolation) {
+                        var placeholders = assembleBoundTextPlaceholders(message);
+                        var params = placeholdersToParams(placeholders);
+                        i18nAttrArgs.push(literal(attr.name), _this.i18nTranslate(message, params));
+                        converted.expressions.forEach(function (expression) {
+                            hasBindings = true;
+                            bindings.push({
+                                sourceSpan: sourceSpan,
+                                value: function () { return _this.convertPropertyBinding(expression); },
+                            });
+                        });
+                    }
+                }
+            });
+            if (bindings.length > 0) {
+                this.updateInstructionChainWithAdvance(nodeIndex, Identifiers$1.i18nExp, bindings);
+            }
+            if (i18nAttrArgs.length > 0) {
+                var index = literal(this.allocateDataSlot());
+                var args = this.constantPool.getConstLiteral(literalArr(i18nAttrArgs), true);
+                this.creationInstruction(sourceSpan, Identifiers$1.i18nAttributes, [index, args]);
+                if (hasBindings) {
+                    this.updateInstruction(sourceSpan, Identifiers$1.i18nApply, [index]);
+                }
+            }
+        };
         TemplateDefinitionBuilder.prototype.getNamespaceInstruction = function (namespaceKey) {
             switch (namespaceKey) {
                 case 'math':
@@ -16677,16 +16770,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                         stylingBuilder.registerClassAttr(value);
                     }
                     else {
-                        if (attr.i18n) {
-                            // Place attributes into a separate array for i18n processing, but also keep such
-                            // attributes in the main list to make them available for directive matching at runtime.
-                            // TODO(FW-1248): prevent attributes duplication in `i18nAttributes` and `elementStart`
-                            // arguments
-                            i18nAttrs.push(attr);
-                        }
-                        else {
-                            outputAttrs.push(attr);
-                        }
+                        (attr.i18n ? i18nAttrs : outputAttrs).push(attr);
                     }
                 }
             }
@@ -16710,10 +16794,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 var stylingInputWasSet = stylingBuilder.registerBoundInput(input);
                 if (!stylingInputWasSet) {
                     if (input.type === 0 /* Property */ && input.i18n) {
-                        // Place attributes into a separate array for i18n processing, but also keep such
-                        // attributes in the main list to make them available for directive matching at runtime.
-                        // TODO(FW-1248): prevent attributes duplication in `i18nAttributes` and `elementStart`
-                        // arguments
                         i18nAttrs.push(input);
                     }
                     else {
@@ -16752,44 +16832,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 if (isNonBindableMode) {
                     this.creationInstruction(element.sourceSpan, Identifiers$1.disableBindings);
                 }
-                // process i18n element attributes
-                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) {
-                            i18nAttrArgs_1.push(literal(attr.name), _this.i18nTranslate(message));
-                        }
-                        else {
-                            var converted = attr.value.visit(_this._valueConverter);
-                            _this.allocateBindingSlots(converted);
-                            if (converted instanceof Interpolation) {
-                                var placeholders = assembleBoundTextPlaceholders(message);
-                                var params = placeholdersToParams(placeholders);
-                                i18nAttrArgs_1.push(literal(attr.name), _this.i18nTranslate(message, params));
-                                converted.expressions.forEach(function (expression) {
-                                    hasBindings_1 = true;
-                                    bindings_1.push({
-                                        sourceSpan: element.sourceSpan,
-                                        value: function () { return _this.convertPropertyBinding(expression); }
-                                    });
-                                });
-                            }
-                        }
-                    });
-                    if (bindings_1.length) {
-                        this.updateInstructionChainWithAdvance(elementIndex, Identifiers$1.i18nExp, bindings_1);
-                    }
-                    if (i18nAttrArgs_1.length) {
-                        var index = literal(this.allocateDataSlot());
-                        var args = this.constantPool.getConstLiteral(literalArr(i18nAttrArgs_1), true);
-                        this.creationInstruction(element.sourceSpan, Identifiers$1.i18nAttributes, [index, args]);
-                        if (hasBindings_1) {
-                            this.updateInstruction(element.sourceSpan, Identifiers$1.i18nApply, [index]);
-                        }
-                    }
+                if (i18nAttrs.length > 0) {
+                    this.i18nAttributesInstruction(elementIndex, i18nAttrs, element.sourceSpan);
                 }
                 // Generate Listeners (outputs)
                 if (element.outputs.length > 0) {
@@ -16953,6 +16997,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             // find directives matching on a given <ng-template> node
             this.matchDirectives(NG_TEMPLATE_TAG_NAME, template);
             // prepare attributes parameter (including attributes used for directive matching)
+            // TODO (FW-1942): exclude i18n attributes from the main attribute list and pass them
+            // as an `i18nAttrs` argument of the `getAttributeExpressions` function below.
             var attrsExprs = this.getAttributeExpressions(template.attributes, template.inputs, template.outputs, undefined, template.templateAttrs, undefined);
             parameters.push(this.addAttrsToConsts(attrsExprs));
             // local refs (ex.: <ng-template #foo>)
@@ -16982,10 +17028,22 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             });
             // handle property bindings e.g. ɵɵproperty('ngForOf', ctx.items), et al;
             this.templatePropertyBindings(templateIndex, template.templateAttrs);
-            // Only add normal input/output binding instructions on explicit ng-template elements.
+            // Only add normal input/output binding instructions on explicit <ng-template> elements.
             if (template.tagName === NG_TEMPLATE_TAG_NAME) {
+                var inputs_1 = [];
+                var i18nAttrs_1 = template.attributes.filter(function (attr) { return !!attr.i18n; });
+                template.inputs.forEach(function (input) { return (input.i18n ? i18nAttrs_1 : inputs_1).push(input); });
+                // Add i18n attributes that may act as inputs to directives. If such attributes are present,
+                // generate `i18nAttributes` instruction. Note: we generate it only for explicit <ng-template>
+                // elements, in case of inline templates, corresponding instructions will be generated in the
+                // nested template function.
+                if (i18nAttrs_1.length > 0) {
+                    this.i18nAttributesInstruction(templateIndex, i18nAttrs_1, template.sourceSpan);
+                }
                 // Add the input bindings
-                this.templatePropertyBindings(templateIndex, template.inputs);
+                if (inputs_1.length > 0) {
+                    this.templatePropertyBindings(templateIndex, inputs_1);
+                }
                 // Generate listeners for directive output
                 if (template.outputs.length > 0) {
                     var listeners = template.outputs.map(function (outputAst) { return ({
@@ -17086,11 +17144,22 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     var value_4 = input.value.visit(_this._valueConverter);
                     if (value_4 !== undefined) {
                         _this.allocateBindingSlots(value_4);
-                        propertyBindings.push({
-                            name: input.name,
-                            sourceSpan: input.sourceSpan,
-                            value: function () { return _this.convertPropertyBinding(value_4); }
-                        });
+                        if (value_4 instanceof Interpolation) {
+                            // Params typically contain attribute namespace and value sanitizer, which is applicable
+                            // for regular HTML elements, but not applicable for <ng-template> (since props act as
+                            // inputs to directives), so keep params array empty.
+                            var params = [];
+                            // prop="{{value}}" case
+                            _this.interpolatedUpdateInstruction(getPropertyInterpolationExpression(value_4), templateIndex, input.name, input, value_4, params);
+                        }
+                        else {
+                            // [prop]="value" case
+                            propertyBindings.push({
+                                name: input.name,
+                                sourceSpan: input.sourceSpan,
+                                value: function () { return _this.convertPropertyBinding(value_4); }
+                            });
+                        }
                     }
                 }
             });
@@ -17940,7 +18009,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
-    var EMPTY_ARRAY = [];
     // This regex matches any binding names that contain the "attr." prefix, e.g. "attr.required"
     // If there is a match, the first matching group will contain the attribute name to bind.
     var ATTR_REGEX = /attr\.([^\]]+)/;
@@ -17975,7 +18043,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * Add features to the definition map.
      */
     function addFeatures(definitionMap, meta) {
-        // e.g. `features: [NgOnChangesFeature()]`
+        // e.g. `features: [NgOnChangesFeature]`
         var features = [];
         var providers = meta.providers;
         var viewProviders = meta.viewProviders;
@@ -17993,7 +18061,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             features.push(importExpr(Identifiers$1.CopyDefinitionFeature));
         }
         if (meta.lifecycle.usesOnChanges) {
-            features.push(importExpr(Identifiers$1.NgOnChangesFeature).callFn(EMPTY_ARRAY));
+            features.push(importExpr(Identifiers$1.NgOnChangesFeature));
         }
         if (features.length) {
             definitionMap.set('features', literalArr(features));
@@ -18828,7 +18896,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
-    var VERSION$1 = new Version('9.0.3');
+    var VERSION$1 = new Version('9.0.7');
 
     /**
      * @license
@@ -22394,9 +22462,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                         });
                     }
                     else {
-                        // handle the symbols via export * directives.
+                        // Handle the symbols loaded by 'export *' directives.
                         var resolvedModule = this_1.resolveModule(moduleExport.from, filePath);
-                        if (resolvedModule) {
+                        if (resolvedModule && resolvedModule !== filePath) {
                             var nestedExports = this_1.getSymbolsOf(resolvedModule);
                             nestedExports.forEach(function (targetSymbol) {
                                 var sourceSymbol = _this.getStaticSymbol(filePath, targetSymbol.name);
@@ -24528,6 +24596,17 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             _this.visitNode = function (node) { return node.visit(_this); };
             return _this;
         }
+        // This method is defined to reconcile the type of TemplateBinder since both
+        // RecursiveAstVisitor and Visitor define the visit() method in their
+        // interfaces.
+        TemplateBinder.prototype.visit = function (node, context) {
+            if (node instanceof AST) {
+                node.visit(this, context);
+            }
+            else {
+                node.visit(this);
+            }
+        };
         /**
          * Process a template and extract metadata about expressions and symbols within.
          *
@@ -24657,6 +24736,126 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     // the late binding of the Compiler to the @angular/core for jit compilation.
     publishFacade(_global);
 
+    /**
+     * @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 Diagnostic = {
+        directive_not_in_module: {
+            message: "%1 '%2' is not included in a module and will not be available inside a template. Consider adding it to a NgModule declaration.",
+            kind: 'Suggestion',
+        },
+        missing_template_and_templateurl: {
+            message: "Component '%1' must have a template or templateUrl",
+            kind: 'Error',
+        },
+        both_template_and_templateurl: {
+            message: "Component '%1' must not have both template and templateUrl",
+            kind: 'Error',
+        },
+        invalid_templateurl: {
+            message: "URL does not point to a valid file",
+            kind: 'Error',
+        },
+        template_context_missing_member: {
+            message: "The template context of '%1' does not define %2.\n" +
+                "If the context type is a base type or 'any', consider refining it to a more specific type.",
+            kind: 'Suggestion',
+        },
+        callable_expression_expected_method_call: {
+            message: 'Unexpected callable expression. Expected a method call',
+            kind: 'Warning',
+        },
+        call_target_not_callable: {
+            message: 'Call target is not callable',
+            kind: 'Error',
+        },
+        expression_might_be_null: {
+            message: 'The expression might be null',
+            kind: 'Error',
+        },
+        expected_a_number_type: {
+            message: 'Expected a number type',
+            kind: 'Error',
+        },
+        expected_a_string_or_number_type: {
+            message: 'Expected operands to be a string or number type',
+            kind: 'Error',
+        },
+        expected_operands_of_similar_type_or_any: {
+            message: 'Expected operands to be of similar type or any',
+            kind: 'Error',
+        },
+        unrecognized_operator: {
+            message: 'Unrecognized operator %1',
+            kind: 'Error',
+        },
+        unrecognized_primitive: {
+            message: 'Unrecognized primitive %1',
+            kind: 'Error',
+        },
+        no_pipe_found: {
+            message: 'No pipe of name %1 found',
+            kind: 'Error',
+        },
+        // TODO: Consider a better error message here.
+        unable_to_resolve_compatible_call_signature: {
+            message: 'Unable to resolve compatible call signature',
+            kind: 'Error',
+        },
+        unable_to_resolve_signature: {
+            message: 'Unable to resolve signature for call of %1',
+            kind: 'Error',
+        },
+        could_not_resolve_type: {
+            message: "Could not resolve the type of '%1'",
+            kind: 'Error',
+        },
+        identifier_not_callable: {
+            message: "'%1' is not callable",
+            kind: 'Error',
+        },
+        identifier_possibly_undefined: {
+            message: "'%1' is possibly undefined. Consider using the safe navigation operator (%2) or non-null assertion operator (%3).",
+            kind: 'Suggestion',
+        },
+        identifier_not_defined_in_app_context: {
+            message: "Identifier '%1' is not defined. The component declaration, template variable declarations, and element references do not contain such a member",
+            kind: 'Error',
+        },
+        identifier_not_defined_on_receiver: {
+            message: "Identifier '%1' is not defined. '%2' does not contain such a member",
+            kind: 'Error',
+        },
+        identifier_is_private: {
+            message: "Identifier '%1' refers to a private member of %2",
+            kind: 'Warning',
+        },
+    };
+    /**
+     * Creates a language service diagnostic.
+     * @param span location the diagnostic for
+     * @param dm diagnostic message
+     * @param formatArgs run-time arguments to format the diagnostic message with (see the messages in
+     *        the `Diagnostic` object for an example).
+     * @returns a created diagnostic
+     */
+    function createDiagnostic(span, dm) {
+        var formatArgs = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            formatArgs[_i - 2] = arguments[_i];
+        }
+        // Formats "%1 %2" with formatArgs ['a', 'b'] as "a b"
+        var formattedMessage = dm.message.replace(/%(\d+)/g, function (_, index) { return formatArgs[+index - 1]; });
+        return {
+            kind: ts.DiagnosticCategory[dm.kind],
+            message: formattedMessage, span: span,
+        };
+    }
+
     /**
      * @license
      * Copyright Google Inc. All Rights Reserved.
@@ -24724,7 +24923,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         AstType.prototype.getDiagnostics = function (ast) {
             var type = ast.visit(this);
             if (this.context.event && type.callable) {
-                this.reportDiagnostic('Unexpected callable expression. Expected a method call', ast, ts.DiagnosticCategory.Warning);
+                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.callable_expression_expected_method_call));
             }
             return this.diagnostics;
         };
@@ -24752,7 +24951,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                             // Nullable allowed.
                             break;
                         default:
-                            _this_1.reportDiagnostic("The expression might be null", ast);
+                            _this_1.diagnostics.push(createDiagnostic(ast.span, Diagnostic.expression_might_be_null));
                             break;
                     }
                     return _this_1.query.getNonNullableType(type);
@@ -24794,7 +24993,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                                     errorAst = ast.right;
                                     break;
                             }
-                            this.reportDiagnostic('Expected a numeric type', errorAst);
+                            this.diagnostics.push(createDiagnostic(errorAst.span, Diagnostic.expected_a_number_type));
                             return this.anyType;
                     }
                 case '+':
@@ -24821,14 +25020,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                             return this.query.getBuiltinType(BuiltinType$1.Number);
                         case BuiltinType$1.Boolean << 8 | BuiltinType$1.Number:
                         case BuiltinType$1.Other << 8 | BuiltinType$1.Number:
-                            this.reportDiagnostic('Expected a number type', ast.left);
+                            this.diagnostics.push(createDiagnostic(ast.left.span, Diagnostic.expected_a_number_type));
                             return this.anyType;
                         case BuiltinType$1.Number << 8 | BuiltinType$1.Boolean:
                         case BuiltinType$1.Number << 8 | BuiltinType$1.Other:
-                            this.reportDiagnostic('Expected a number type', ast.right);
+                            this.diagnostics.push(createDiagnostic(ast.right.span, Diagnostic.expected_a_number_type));
                             return this.anyType;
                         default:
-                            this.reportDiagnostic('Expected operands to be a string or number type', ast);
+                            this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.expected_a_string_or_number_type));
                             return this.anyType;
                     }
                 case '>':
@@ -24855,7 +25054,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                         case BuiltinType$1.Other << 8 | BuiltinType$1.Other:
                             return this.query.getBuiltinType(BuiltinType$1.Boolean);
                         default:
-                            this.reportDiagnostic('Expected the operants to be of similar type or any', ast);
+                            this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.expected_operands_of_similar_type_or_any));
                             return this.anyType;
                     }
                 case '&&':
@@ -24863,18 +25062,33 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 case '||':
                     return this.query.getTypeUnion(leftType, rightType);
             }
-            this.reportDiagnostic("Unrecognized operator " + ast.operation, ast);
+            this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.unrecognized_operator, ast.operation));
             return this.anyType;
         };
         AstType.prototype.visitChain = function (ast) {
-            // If we are producing diagnostics, visit the children
-            visitAstChildren(ast, this);
+            var e_1, _a;
+            try {
+                // If we are producing diagnostics, visit the children
+                for (var _b = __values(ast.expressions), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var expr = _c.value;
+                    expr.visit(this);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
             // The type of a chain is always undefined.
             return this.query.getBuiltinType(BuiltinType$1.Undefined);
         };
         AstType.prototype.visitConditional = function (ast) {
             // The type of a conditional is the union of the true and false conditions.
-            visitAstChildren(ast, this);
+            ast.condition.visit(this);
+            ast.trueExp.visit(this);
+            ast.falseExp.visit(this);
             return this.query.getTypeUnion(this.getType(ast.trueExp), this.getType(ast.falseExp));
         };
         AstType.prototype.visitFunctionCall = function (ast) {
@@ -24886,7 +25100,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var args = ast.args.map(function (arg) { return _this_1.getType(arg); });
             var target = this.getType(ast.target);
             if (!target || !target.callable) {
-                this.reportDiagnostic('Call target is not callable', ast);
+                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.call_target_not_callable));
                 return this.anyType;
             }
             var signature = target.selectSignature(args);
@@ -24894,7 +25108,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 return signature.result;
             }
             // TODO: Consider a better error message here.
-            this.reportDiagnostic('Unable no compatible signature found for call', ast);
+            this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.unable_to_resolve_compatible_call_signature));
             return this.anyType;
         };
         AstType.prototype.visitImplicitReceiver = function (ast) {
@@ -24921,8 +25135,21 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             };
         };
         AstType.prototype.visitInterpolation = function (ast) {
-            // If we are producing diagnostics, visit the children.
-            visitAstChildren(ast, this);
+            var e_2, _a;
+            try {
+                // If we are producing diagnostics, visit the children.
+                for (var _b = __values(ast.expressions), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var expr = _c.value;
+                    expr.visit(this);
+                }
+            }
+            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 this.undefinedType;
         };
         AstType.prototype.visitKeyedRead = function (ast) {
@@ -24942,8 +25169,21 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             return this.query.getArrayType((_a = this.query).getTypeUnion.apply(_a, __spread(ast.expressions.map(function (element) { return _this_1.getType(element); }))));
         };
         AstType.prototype.visitLiteralMap = function (ast) {
-            // If we are producing diagnostics, visit the children
-            visitAstChildren(ast, this);
+            var e_3, _a;
+            try {
+                // If we are producing diagnostics, visit the children
+                for (var _b = __values(ast.values), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var value = _c.value;
+                    value.visit(this);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
             // TODO: Return a composite type.
             return this.anyType;
         };
@@ -24964,7 +25204,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                         case 'number':
                             return this.query.getBuiltinType(BuiltinType$1.Number);
                         default:
-                            this.reportDiagnostic('Unrecognized primitive', ast);
+                            this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.unrecognized_primitive, typeof ast.value));
                             return this.anyType;
                     }
             }
@@ -24978,20 +25218,20 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             // by getPipes() is expected to contain symbols with the corresponding transform method type.
             var pipe = this.query.getPipes().get(ast.name);
             if (!pipe) {
-                this.reportDiagnostic("No pipe by the name " + ast.name + " found", ast);
+                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.no_pipe_found, ast.name));
                 return this.anyType;
             }
             var expType = this.getType(ast.exp);
             var signature = pipe.selectSignature([expType].concat(ast.args.map(function (arg) { return _this_1.getType(arg); })));
             if (!signature) {
-                this.reportDiagnostic('Unable to resolve signature for pipe invocation', ast);
+                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.unable_to_resolve_signature, ast.name));
                 return this.anyType;
             }
             return signature.result;
         };
         AstType.prototype.visitPrefixNot = function (ast) {
             // If we are producing diagnostics, visit the children
-            visitAstChildren(ast, this);
+            ast.expression.visit(this);
             // The type of a prefix ! is always boolean.
             return this.query.getBuiltinType(BuiltinType$1.Boolean);
         };
@@ -25045,19 +25285,19 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             }
             var methodType = this.resolvePropertyRead(receiverType, ast);
             if (!methodType) {
-                this.reportDiagnostic("Could not find a type for '" + ast.name + "'", ast);
+                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.could_not_resolve_type, ast.name));
                 return this.anyType;
             }
             if (this.isAny(methodType)) {
                 return this.anyType;
             }
             if (!methodType.callable) {
-                this.reportDiagnostic("Member '" + ast.name + "' is not callable", ast);
+                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.identifier_not_callable, ast.name));
                 return this.anyType;
             }
             var signature = methodType.selectSignature(ast.args.map(function (arg) { return _this_1.getType(arg); }));
             if (!signature) {
-                this.reportDiagnostic("Unable to resolve signature for call of method " + ast.name, ast);
+                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.unable_to_resolve_signature, ast.name));
                 return this.anyType;
             }
             return signature.result;
@@ -25070,28 +25310,23 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var member = receiverType.members().get(ast.name);
             if (!member) {
                 if (receiverType.name === '$implicit') {
-                    this.reportDiagnostic("Identifier '" + ast.name + "' is not defined. " +
-                        "The component declaration, template variable declarations, and element references do not contain such a member", ast);
+                    this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.identifier_not_defined_in_app_context, ast.name));
                 }
                 else if (receiverType.nullable && ast.receiver instanceof PropertyRead) {
                     var receiver = ast.receiver.name;
-                    this.reportDiagnostic("'" + receiver + "' is possibly undefined. Consider using the safe navigation operator (" + receiver + "?." + ast.name + ") " +
-                        ("or non-null assertion operator (" + receiver + "!." + ast.name + ")."), ast, ts.DiagnosticCategory.Suggestion);
+                    this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.identifier_possibly_undefined, receiver, receiver + "?." + ast.name, receiver + "!." + ast.name));
                 }
                 else {
-                    this.reportDiagnostic("Identifier '" + ast.name + "' is not defined. '" + receiverType.name + "' does not contain such a member", ast);
+                    this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.identifier_not_defined_on_receiver, ast.name, receiverType.name));
                 }
                 return this.anyType;
             }
             if (!member.public) {
-                this.reportDiagnostic("Identifier '" + ast.name + "' refers to a private member of " + (receiverType.name === '$implicit' ? 'the component' : "\n      '" + receiverType.name + "'\n          "), ast, ts.DiagnosticCategory.Warning);
+                var container = receiverType.name === '$implicit' ? 'the component' : "'" + receiverType.name + "'";
+                this.diagnostics.push(createDiagnostic(ast.span, Diagnostic.identifier_is_private, ast.name, container));
             }
             return member.type;
         };
-        AstType.prototype.reportDiagnostic = function (message, ast, kind) {
-            if (kind === void 0) { kind = ts.DiagnosticCategory.Error; }
-            this.diagnostics.push({ kind: kind, span: ast.span, message: message });
-        };
         AstType.prototype.isAny = function (symbol) {
             return !symbol || this.query.getTypeKind(symbol) === BuiltinType$1.Any ||
                 (!!symbol.type && this.isAny(symbol.type));
@@ -25497,10 +25732,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 continue;
             }
             var _loop_2 = function (variable) {
-                var symbol = info.members.get(variable.value);
-                if (!symbol) {
-                    symbol = getVariableTypeFromDirectiveContext(variable.value, info.query, current);
-                }
+                var symbol = getVariableTypeFromDirectiveContext(variable.value, info.query, current);
                 var kind = info.query.getTypeKind(symbol);
                 if (kind === BuiltinType$1.Any || kind === BuiltinType$1.Unbound) {
                     // For special cases such as ngFor and ngIf, the any type is not very useful.
@@ -25576,7 +25808,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      */
     function refinedVariableType(value, mergedTable, query, templateElement) {
         if (value === '$implicit') {
-            // Special case the ngFor directive
+            // Special case: ngFor directive
             var ngForDirective = templateElement.directives.find(function (d) {
                 var name = identifierName(d.directive.type);
                 return name == 'NgFor' || name == 'NgForOf';
@@ -25595,12 +25827,19 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 }
             }
         }
-        // Special case the ngIf directive ( *ngIf="data$ | async as variable" )
-        if (value === 'ngIf') {
+        if (value === 'ngIf' || value === '$implicit') {
             var ngIfDirective = templateElement.directives.find(function (d) { return identifierName(d.directive.type) === 'NgIf'; });
             if (ngIfDirective) {
+                // Special case: ngIf directive. The NgIf structural directive owns a template context with
+                // "$implicit" and "ngIf" members. These properties are typed as generics. Until the language
+                // service uses an Ivy and TypecheckBlock backend, we cannot bind these values to a concrete
+                // type without manual inference. To get the concrete type, look up the type of the "ngIf"
+                // import on the NgIf directive bound to the template.
+                //
+                // See @angular/common/ng_if.ts for more information.
                 var ngIfBinding = ngIfDirective.inputs.find(function (i) { return i.directiveName === 'ngIf'; });
                 if (ngIfBinding) {
+                    // Check if there is a known type bound to the ngIf input.
                     var bindingType = new AstType(mergedTable, query, {}).getType(ngIfBinding.value);
                     if (bindingType) {
                         return bindingType;
@@ -25696,8 +25935,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 var context = this.info.query.getTemplateContext(directive.type.reference);
                 if (context && !context.has(ast.value)) {
                     var missingMember = ast.value === '$implicit' ? 'an implicit value' : "a member called '" + ast.value + "'";
-                    this.reportDiagnostic("The template context of '" + directive.type.reference.name + "' does not define " + missingMember + ".\n" +
-                        "If the context type is a base type or 'any', consider refining it to a more specific type.", spanOf$1(ast.sourceSpan), ts.DiagnosticCategory.Suggestion);
+                    var span = this.absSpan(spanOf$1(ast.sourceSpan));
+                    this.diagnostics.push(createDiagnostic(span, Diagnostic.template_context_missing_member, directive.type.reference.name, missingMember));
                 }
             }
         };
@@ -25731,10 +25970,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var analyzer = new AstType(scope, this.info.query, { event: event });
             try {
                 for (var _b = __values(analyzer.getDiagnostics(ast)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var _d = _c.value, message = _d.message, span = _d.span, kind = _d.kind;
-                    span.start += offset;
-                    span.end += offset;
-                    this.reportDiagnostic(message, span, kind);
+                    var diagnostic = _c.value;
+                    diagnostic.span = this.absSpan(diagnostic.span, offset);
+                    this.diagnostics.push(diagnostic);
                 }
             }
             catch (e_4_1) { e_4 = { error: e_4_1 }; }
@@ -25747,11 +25985,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         };
         ExpressionDiagnosticsVisitor.prototype.push = function (ast) { this.path.push(ast); };
         ExpressionDiagnosticsVisitor.prototype.pop = function () { this.path.pop(); };
-        ExpressionDiagnosticsVisitor.prototype.reportDiagnostic = function (message, span, kind) {
-            if (kind === void 0) { kind = ts.DiagnosticCategory.Error; }
-            span.start += this.info.offset;
-            span.end += this.info.offset;
-            this.diagnostics.push({ kind: kind, span: span, message: message });
+        ExpressionDiagnosticsVisitor.prototype.absSpan = function (span, additionalOffset) {
+            if (additionalOffset === void 0) { additionalOffset = 0; }
+            return {
+                start: span.start + this.info.offset + additionalOffset,
+                end: span.end + this.info.offset + additionalOffset,
+            };
         };
         return ExpressionDiagnosticsVisitor;
     }(RecursiveTemplateAstVisitor));
@@ -25836,11 +26075,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 if ((!excludeEmpty || ast.sourceSpan.start < ast.sourceSpan.end) &&
                     inSpan(position, ast.sourceSpan)) {
                     path.push(ast);
-                    visitAstChildren(ast, this);
+                    ast.visit(this);
                 }
             };
             return class_1;
-        }(NullAstVisitor));
+        }(RecursiveAstVisitor$1));
         // We never care about the ASTWithSource node and its visit() method calls its ast's visit so
         // the visit() method above would never see it.
         if (ast instanceof ASTWithSource) {
@@ -28135,8 +28374,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     }
                 }
             }
-            if (binding.expression && inSpan(valueRelativePosition, binding.expression.ast.span)) {
-                this.processExpressionCompletions(binding.expression.ast);
+            if (binding.value && inSpan(valueRelativePosition, binding.value.ast.span)) {
+                this.processExpressionCompletions(binding.value.ast);
                 return;
             }
             // If the expression is incomplete, for example *ngFor="let x of |"
@@ -28439,10 +28678,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         // Find the symbol that contains the position.
         templateBindings.filter(function (tb) { return !tb.keyIsVar; }).forEach(function (tb) {
             var _a;
-            if (inSpan(valueRelativePosition, (_a = tb.expression) === null || _a === void 0 ? void 0 : _a.ast.span)) {
+            if (inSpan(valueRelativePosition, (_a = tb.value) === null || _a === void 0 ? void 0 : _a.ast.span)) {
                 var dinfo = diagnosticInfoFromTemplateInfo(info);
                 var scope = getExpressionScope(dinfo, path);
-                result = getExpressionSymbol(scope, tb.expression, path.position, info.template.query);
+                result = getExpressionSymbol(scope, tb.value, path.position, info.template.query);
             }
             else if (inSpan(valueRelativePosition, tb.span)) {
                 var template = path.first(EmbeddedTemplateAst);
@@ -28772,17 +29011,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             members: template.members,
         });
     }
-    /**
-     * Generate an error message that indicates a directive is not part of any
-     * NgModule.
-     * @param name class name
-     * @param isComponent true if directive is an Angular Component
-     */
-    function missingDirective(name, isComponent) {
-        var type = isComponent ? 'Component' : 'Directive';
-        return type + " '" + name + "' is not included in a module and will not be " +
-            'available inside a template. Consider adding it to a NgModule declaration.';
-    }
     /**
      * Performs a variety diagnostics on directive declarations.
      *
@@ -28853,29 +29081,17 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     }
                     finally { if (e_4) throw e_4.error; }
                 }
+                if (!modules.ngModuleByPipeOrDirective.has(declaration.type)) {
+                    results.push(createDiagnostic(declarationSpan, Diagnostic.directive_not_in_module, metadata.isComponent ? 'Component' : 'Directive', type.name));
+                }
                 if (metadata.isComponent) {
-                    if (!modules.ngModuleByPipeOrDirective.has(declaration.type)) {
-                        results.push({
-                            kind: ts.DiagnosticCategory.Suggestion,
-                            message: missingDirective(type.name, metadata.isComponent),
-                            span: declarationSpan,
-                        });
-                    }
                     var _j = metadata.template, template = _j.template, templateUrl = _j.templateUrl, styleUrls = _j.styleUrls;
                     if (template === null && !templateUrl) {
-                        results.push({
-                            kind: ts.DiagnosticCategory.Error,
-                            message: "Component '" + type.name + "' must have a template or templateUrl",
-                            span: declarationSpan,
-                        });
+                        results.push(createDiagnostic(declarationSpan, Diagnostic.missing_template_and_templateurl, type.name));
                     }
                     else if (templateUrl) {
                         if (template) {
-                            results.push({
-                                kind: ts.DiagnosticCategory.Error,
-                                message: "Component '" + type.name + "' must not have both template and templateUrl",
-                                span: declarationSpan,
-                            });
+                            results.push(createDiagnostic(declarationSpan, Diagnostic.both_template_and_templateurl, type.name));
                         }
                         // Find templateUrl value from the directive call expression, which is the parent of the
                         // directive identifier.
@@ -28900,13 +29116,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                         results.push.apply(results, __spread(validateUrls(styleUrlsNode.elements, host.tsLsHost)));
                     }
                 }
-                else if (!directives.has(declaration.type)) {
-                    results.push({
-                        kind: ts.DiagnosticCategory.Suggestion,
-                        message: missingDirective(type.name, metadata.isComponent),
-                        span: declarationSpan,
-                    });
-                }
             }
         }
         catch (e_3_1) { e_3 = { error: e_3_1 }; }
@@ -28945,12 +29154,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var url = path.join(path.dirname(curPath), urlNode.text);
             if (tsLsHost.fileExists(url))
                 continue;
-            allErrors.push({
-                kind: ts.DiagnosticCategory.Error,
-                message: "URL does not point to a valid file",
-                // Exclude opening and closing quotes in the url span.
-                span: { start: urlNode.getStart() + 1, end: urlNode.end - 1 },
-            });
+            // Exclude opening and closing quotes in the url span.
+            var urlSpan = { start: urlNode.getStart() + 1, end: urlNode.end - 1 };
+            allErrors.push(createDiagnostic(urlSpan, Diagnostic.invalid_templateurl));
         }
         return allErrors;
     }
@@ -29183,6 +29389,26 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         return LanguageServiceImpl;
     }());
 
+    /**
+     * @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
+     */
+    /**
+     * Convince closure compiler that the wrapped function has no side-effects.
+     *
+     * Closure compiler always assumes that `toString` has no side-effects. We use this quirk to
+     * allow us to execute a function but have closure compiler mark the call as no-side-effects.
+     * It is important that the return value for the `noSideEffects` function be assigned
+     * to something which is retained otherwise the call to `noSideEffects` will be removed by closure
+     * compiler.
+     */
+    function noSideEffects(fn) {
+        return { toString: fn }.toString();
+    }
+
     /**
      * @license
      * Copyright Google Inc. All Rights Reserved.
@@ -29197,38 +29423,40 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * @suppress {globalThis}
      */
     function makeDecorator(name, props, parentClass, additionalProcessing, typeFn) {
-        var metaCtor = makeMetadataCtor(props);
-        function DecoratorFactory() {
-            var _a;
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
+        return noSideEffects(function () {
+            var metaCtor = makeMetadataCtor(props);
+            function DecoratorFactory() {
+                var _a;
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                if (this instanceof DecoratorFactory) {
+                    metaCtor.call.apply(metaCtor, __spread([this], args));
+                    return this;
+                }
+                var annotationInstance = new ((_a = DecoratorFactory).bind.apply(_a, __spread([void 0], args)))();
+                return function TypeDecorator(cls) {
+                    if (typeFn)
+                        typeFn.apply(void 0, __spread([cls], args));
+                    // Use of Object.defineProperty is important since it creates non-enumerable property which
+                    // prevents the property is copied during subclassing.
+                    var annotations = cls.hasOwnProperty(ANNOTATIONS) ?
+                        cls[ANNOTATIONS] :
+                        Object.defineProperty(cls, ANNOTATIONS, { value: [] })[ANNOTATIONS];
+                    annotations.push(annotationInstance);
+                    if (additionalProcessing)
+                        additionalProcessing(cls);
+                    return cls;
+                };
             }
-            if (this instanceof DecoratorFactory) {
-                metaCtor.call.apply(metaCtor, __spread([this], args));
-                return this;
+            if (parentClass) {
+                DecoratorFactory.prototype = Object.create(parentClass.prototype);
             }
-            var annotationInstance = new ((_a = DecoratorFactory).bind.apply(_a, __spread([void 0], args)))();
-            return function TypeDecorator(cls) {
-                if (typeFn)
-                    typeFn.apply(void 0, __spread([cls], args));
-                // Use of Object.defineProperty is important since it creates non-enumerable property which
-                // prevents the property is copied during subclassing.
-                var annotations = cls.hasOwnProperty(ANNOTATIONS) ?
-                    cls[ANNOTATIONS] :
-                    Object.defineProperty(cls, ANNOTATIONS, { value: [] })[ANNOTATIONS];
-                annotations.push(annotationInstance);
-                if (additionalProcessing)
-                    additionalProcessing(cls);
-                return cls;
-            };
-        }
-        if (parentClass) {
-            DecoratorFactory.prototype = Object.create(parentClass.prototype);
-        }
-        DecoratorFactory.prototype.ngMetadataName = name;
-        DecoratorFactory.annotationCls = DecoratorFactory;
-        return DecoratorFactory;
+            DecoratorFactory.prototype.ngMetadataName = name;
+            DecoratorFactory.annotationCls = DecoratorFactory;
+            return DecoratorFactory;
+        });
     }
     function makeMetadataCtor(props) {
         return function ctor() {
@@ -29245,75 +29473,79 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         };
     }
     function makeParamDecorator(name, props, parentClass) {
-        var metaCtor = makeMetadataCtor(props);
-        function ParamDecoratorFactory() {
-            var _a;
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            if (this instanceof ParamDecoratorFactory) {
-                metaCtor.apply(this, args);
-                return this;
-            }
-            var annotationInstance = new ((_a = ParamDecoratorFactory).bind.apply(_a, __spread([void 0], args)))();
-            ParamDecorator.annotation = annotationInstance;
-            return ParamDecorator;
-            function ParamDecorator(cls, unusedKey, index) {
-                // Use of Object.defineProperty is important since it creates non-enumerable property which
-                // prevents the property is copied during subclassing.
-                var parameters = cls.hasOwnProperty(PARAMETERS) ?
-                    cls[PARAMETERS] :
-                    Object.defineProperty(cls, PARAMETERS, { value: [] })[PARAMETERS];
-                // there might be gaps if some in between parameters do not have annotations.
-                // we pad with nulls.
-                while (parameters.length <= index) {
-                    parameters.push(null);
+        return noSideEffects(function () {
+            var metaCtor = makeMetadataCtor(props);
+            function ParamDecoratorFactory() {
+                var _a;
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
                 }
-                (parameters[index] = parameters[index] || []).push(annotationInstance);
-                return cls;
-            }
-        }
-        if (parentClass) {
-            ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);
-        }
-        ParamDecoratorFactory.prototype.ngMetadataName = name;
-        ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;
-        return ParamDecoratorFactory;
+                if (this instanceof ParamDecoratorFactory) {
+                    metaCtor.apply(this, args);
+                    return this;
+                }
+                var annotationInstance = new ((_a = ParamDecoratorFactory).bind.apply(_a, __spread([void 0], args)))();
+                ParamDecorator.annotation = annotationInstance;
+                return ParamDecorator;
+                function ParamDecorator(cls, unusedKey, index) {
+                    // Use of Object.defineProperty is important since it creates non-enumerable property which
+                    // prevents the property is copied during subclassing.
+                    var parameters = cls.hasOwnProperty(PARAMETERS) ?
+                        cls[PARAMETERS] :
+                        Object.defineProperty(cls, PARAMETERS, { value: [] })[PARAMETERS];
+                    // there might be gaps if some in between parameters do not have annotations.
+                    // we pad with nulls.
+                    while (parameters.length <= index) {
+                        parameters.push(null);
+                    }
+                    (parameters[index] = parameters[index] || []).push(annotationInstance);
+                    return cls;
+                }
+            }
+            if (parentClass) {
+                ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);
+            }
+            ParamDecoratorFactory.prototype.ngMetadataName = name;
+            ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;
+            return ParamDecoratorFactory;
+        });
     }
     function makePropDecorator(name, props, parentClass, additionalProcessing) {
-        var metaCtor = makeMetadataCtor(props);
-        function PropDecoratorFactory() {
-            var _a;
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            if (this instanceof PropDecoratorFactory) {
-                metaCtor.apply(this, args);
-                return this;
-            }
-            var decoratorInstance = new ((_a = PropDecoratorFactory).bind.apply(_a, __spread([void 0], args)))();
-            function PropDecorator(target, name) {
-                var constructor = target.constructor;
-                // Use of Object.defineProperty is important since it creates non-enumerable property which
-                // prevents the property is copied during subclassing.
-                var meta = constructor.hasOwnProperty(PROP_METADATA) ?
-                    constructor[PROP_METADATA] :
-                    Object.defineProperty(constructor, PROP_METADATA, { value: {} })[PROP_METADATA];
-                meta[name] = meta.hasOwnProperty(name) && meta[name] || [];
-                meta[name].unshift(decoratorInstance);
-                if (additionalProcessing)
-                    additionalProcessing.apply(void 0, __spread([target, name], args));
-            }
-            return PropDecorator;
-        }
-        if (parentClass) {
-            PropDecoratorFactory.prototype = Object.create(parentClass.prototype);
-        }
-        PropDecoratorFactory.prototype.ngMetadataName = name;
-        PropDecoratorFactory.annotationCls = PropDecoratorFactory;
-        return PropDecoratorFactory;
+        return noSideEffects(function () {
+            var metaCtor = makeMetadataCtor(props);
+            function PropDecoratorFactory() {
+                var _a;
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                if (this instanceof PropDecoratorFactory) {
+                    metaCtor.apply(this, args);
+                    return this;
+                }
+                var decoratorInstance = new ((_a = PropDecoratorFactory).bind.apply(_a, __spread([void 0], args)))();
+                function PropDecorator(target, name) {
+                    var constructor = target.constructor;
+                    // Use of Object.defineProperty is important since it creates non-enumerable property which
+                    // prevents the property is copied during subclassing.
+                    var meta = constructor.hasOwnProperty(PROP_METADATA) ?
+                        constructor[PROP_METADATA] :
+                        Object.defineProperty(constructor, PROP_METADATA, { value: {} })[PROP_METADATA];
+                    meta[name] = meta.hasOwnProperty(name) && meta[name] || [];
+                    meta[name].unshift(decoratorInstance);
+                    if (additionalProcessing)
+                        additionalProcessing.apply(void 0, __spread([target, name], args));
+                }
+                return PropDecorator;
+            }
+            if (parentClass) {
+                PropDecoratorFactory.prototype = Object.create(parentClass.prototype);
+            }
+            PropDecoratorFactory.prototype.ngMetadataName = name;
+            PropDecoratorFactory.annotationCls = PropDecoratorFactory;
+            return PropDecoratorFactory;
+        });
     }
 
     /**
@@ -30109,8 +30341,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
     }
     function throwError(msg, actual, expected, comparison) {
-        // tslint:disable-next-line
-        debugger; // Left intentionally for better debugger experience.
         throw new Error("ASSERTION ERROR: " + msg +
             (comparison == null ? '' : " [Expected=> " + expected + " " + comparison + " " + actual + " <=Actual]"));
     }
@@ -30317,7 +30547,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * code.
      */
     var EMPTY_OBJ = {};
-    var EMPTY_ARRAY$1 = [];
+    var EMPTY_ARRAY = [];
     // freezing the values prevents any code from accidentally inserting new values in
     if ((typeof ngDevMode === 'undefined' || ngDevMode) && initNgDevMode()) {
         // These property accesses can be ignored because ngDevMode will be set to false
@@ -30325,7 +30555,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         // tslint:disable-next-line:no-toplevel-property-access
         Object.freeze(EMPTY_OBJ);
         // tslint:disable-next-line:no-toplevel-property-access
-        Object.freeze(EMPTY_ARRAY$1);
+        Object.freeze(EMPTY_ARRAY);
     }
 
     /**
@@ -30464,6 +30694,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
+    // [Assert functions do not constraint type when they are guarded by a truthy
+    // expression.](https://github.com/microsoft/TypeScript/issues/37295)
     function assertTNodeForLView(tNode, lView) {
         tNode.hasOwnProperty('tView_') && assertEqual(tNode.tView_, lView[TVIEW], 'This TNode does not belong to this LView.');
     }
@@ -30507,6 +30739,202 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     var SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
     var MATH_ML_NAMESPACE = 'http://www.w3.org/1998/MathML/';
 
+    /**
+     * @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
+     */
+    /**
+     * This property will be monkey-patched on elements, components and directives
+     */
+    var MONKEY_PATCH_KEY_NAME = '__ngContext__';
+
+    /**
+     * @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
+     */
+    /**
+     * Most of the use of `document` in Angular is from within the DI system so it is possible to simply
+     * inject the `DOCUMENT` token and are done.
+     *
+     * Ivy is special because it does not rely upon the DI and must get hold of the document some other
+     * way.
+     *
+     * The solution is to define `getDocument()` and `setDocument()` top-level functions for ivy.
+     * Wherever ivy needs the global document, it calls `getDocument()` instead.
+     *
+     * When running ivy outside of a browser environment, it is necessary to call `setDocument()` to
+     * tell ivy what the global `document` is.
+     *
+     * Angular does this for us in each of the standard platforms (`Browser`, `Server`, and `WebWorker`)
+     * by calling `setDocument()` when providing the `DOCUMENT` token.
+     */
+    var DOCUMENT = undefined;
+    /**
+     * Access the object that represents the `document` for this platform.
+     *
+     * Ivy calls this whenever it needs to access the `document` object.
+     * For example to create the renderer or to do sanitization.
+     */
+    function getDocument() {
+        if (DOCUMENT !== undefined) {
+            return DOCUMENT;
+        }
+        else if (typeof document !== 'undefined') {
+            return document;
+        }
+        // No "document" can be found. This should only happen if we are running ivy outside Angular and
+        // the current platform is not a browser. Since this is not a supported scenario at the moment
+        // this should not happen in Angular apps.
+        // Once we support running ivy outside of Angular we will need to publish `setDocument()` as a
+        // public API. Meanwhile we just return `undefined` and let the application fail.
+        return undefined;
+    }
+
+    /**
+     * @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
+     */
+    // TODO: cleanup once the code is merged in angular/angular
+    var RendererStyleFlags3;
+    (function (RendererStyleFlags3) {
+        RendererStyleFlags3[RendererStyleFlags3["Important"] = 1] = "Important";
+        RendererStyleFlags3[RendererStyleFlags3["DashCase"] = 2] = "DashCase";
+    })(RendererStyleFlags3 || (RendererStyleFlags3 = {}));
+    /** Returns whether the `renderer` is a `ProceduralRenderer3` */
+    function isProceduralRenderer(renderer) {
+        return !!(renderer.listen);
+    }
+    var ɵ0$2 = function (hostElement, rendererType) { return getDocument(); };
+    var domRendererFactory3 = {
+        createRenderer: ɵ0$2
+    };
+
+    /**
+     * @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
+     */
+    /**
+     * For efficiency reasons we often put several different data types (`RNode`, `LView`, `LContainer`)
+     * in same location in `LView`. This is because we don't want to pre-allocate space for it
+     * because the storage is sparse. This file contains utilities for dealing with such data types.
+     *
+     * How do we know what is stored at a given location in `LView`.
+     * - `Array.isArray(value) === false` => `RNode` (The normal storage value)
+     * - `Array.isArray(value) === true` => then the `value[0]` represents the wrapped value.
+     *   - `typeof value[TYPE] === 'object'` => `LView`
+     *      - This happens when we have a component at a given location
+     *   - `typeof value[TYPE] === true` => `LContainer`
+     *      - This happens when we have `LContainer` binding at a given location.
+     *
+     *
+     * NOTE: it is assumed that `Array.isArray` and `typeof` operations are very efficient.
+     */
+    /**
+     * Returns `RNode`.
+     * @param value wrapped value of `RNode`, `LView`, `LContainer`
+     */
+    function unwrapRNode(value) {
+        while (Array.isArray(value)) {
+            value = value[HOST];
+        }
+        return value;
+    }
+    /**
+     * Retrieve an `RNode` for a given `TNode` and `LView`.
+     *
+     * This function guarantees in dev mode to retrieve a non-null `RNode`.
+     *
+     * @param tNode
+     * @param lView
+     */
+    function getNativeByTNode(tNode, lView) {
+        ngDevMode && assertTNodeForLView(tNode, lView);
+        ngDevMode && assertDataInRange(lView, tNode.index);
+        var node = unwrapRNode(lView[tNode.index]);
+        ngDevMode && !isProceduralRenderer(lView[RENDERER]) && assertDomNode(node);
+        return node;
+    }
+    /**
+     * Retrieve an `RNode` or `null` for a given `TNode` and `LView`.
+     *
+     * Some `TNode`s don't have associated `RNode`s. For example `Projection`
+     *
+     * @param tNode
+     * @param lView
+     */
+    function getNativeByTNodeOrNull(tNode, lView) {
+        var index = tNode.index;
+        if (index !== -1) {
+            ngDevMode && assertTNodeForLView(tNode, lView);
+            var node = unwrapRNode(lView[index]);
+            ngDevMode && node !== null && !isProceduralRenderer(lView[RENDERER]) && assertDomNode(node);
+            return node;
+        }
+        return null;
+    }
+    function getTNode(tView, index) {
+        ngDevMode && assertGreaterThan(index, -1, 'wrong index for TNode');
+        ngDevMode && assertLessThan(index, tView.data.length, 'wrong index for TNode');
+        return tView.data[index + HEADER_OFFSET];
+    }
+    function getComponentLViewByIndex(nodeIndex, hostView) {
+        // Could be an LView or an LContainer. If LContainer, unwrap to find LView.
+        ngDevMode && assertDataInRange(hostView, nodeIndex);
+        var slotValue = hostView[nodeIndex];
+        var lView = isLView(slotValue) ? slotValue : slotValue[HOST];
+        return lView;
+    }
+    /**
+     * Returns the monkey-patch value data present on the target (which could be
+     * a component, directive or a DOM node).
+     */
+    function readPatchedData(target) {
+        ngDevMode && assertDefined(target, 'Target expected');
+        return target[MONKEY_PATCH_KEY_NAME] || null;
+    }
+    function readPatchedLView(target) {
+        var value = readPatchedData(target);
+        if (value) {
+            return Array.isArray(value) ? value : value.lView;
+        }
+        return null;
+    }
+    /** Checks whether a given view is in creation mode */
+    function isCreationMode(view) {
+        return (view[FLAGS] & 4 /* CreationMode */) === 4 /* CreationMode */;
+    }
+    /**
+     * Returns a boolean for whether the view is attached to the change detection tree.
+     *
+     * Note: This determines whether a view should be checked, not whether it's inserted
+     * into a container. For that, you'll want `viewAttachedToContainer` below.
+     */
+    function viewAttachedToChangeDetector(view) {
+        return (view[FLAGS] & 128 /* Attached */) === 128 /* Attached */;
+    }
+    /**
+     * Resets the pre-order hook flags of the view.
+     * @param lView the LView on which the flags are reset
+     */
+    function resetPreOrderHookFlags(lView) {
+        lView[PREORDER_HOOK_FLAGS] = 0;
+    }
+    function getLContainerActiveIndex(lContainer) {
+        return lContainer[ACTIVE_INDEX] >> 1 /* SHIFT */;
+    }
+
     /**
      * @license
      * Copyright Google Inc. All Rights Reserved.
@@ -31088,73 +31516,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         return '<unknown>';
     }
 
-    /**
-     * @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
-     */
-    /**
-     * Most of the use of `document` in Angular is from within the DI system so it is possible to simply
-     * inject the `DOCUMENT` token and are done.
-     *
-     * Ivy is special because it does not rely upon the DI and must get hold of the document some other
-     * way.
-     *
-     * The solution is to define `getDocument()` and `setDocument()` top-level functions for ivy.
-     * Wherever ivy needs the global document, it calls `getDocument()` instead.
-     *
-     * When running ivy outside of a browser environment, it is necessary to call `setDocument()` to
-     * tell ivy what the global `document` is.
-     *
-     * Angular does this for us in each of the standard platforms (`Browser`, `Server`, and `WebWorker`)
-     * by calling `setDocument()` when providing the `DOCUMENT` token.
-     */
-    var DOCUMENT = undefined;
-    /**
-     * Access the object that represents the `document` for this platform.
-     *
-     * Ivy calls this whenever it needs to access the `document` object.
-     * For example to create the renderer or to do sanitization.
-     */
-    function getDocument() {
-        if (DOCUMENT !== undefined) {
-            return DOCUMENT;
-        }
-        else if (typeof document !== 'undefined') {
-            return document;
-        }
-        // No "document" can be found. This should only happen if we are running ivy outside Angular and
-        // the current platform is not a browser. Since this is not a supported scenario at the moment
-        // this should not happen in Angular apps.
-        // Once we support running ivy outside of Angular we will need to publish `setDocument()` as a
-        // public API. Meanwhile we just return `undefined` and let the application fail.
-        return undefined;
-    }
-
-    /**
-     * @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
-     */
-    // TODO: cleanup once the code is merged in angular/angular
-    var RendererStyleFlags3;
-    (function (RendererStyleFlags3) {
-        RendererStyleFlags3[RendererStyleFlags3["Important"] = 1] = "Important";
-        RendererStyleFlags3[RendererStyleFlags3["DashCase"] = 2] = "DashCase";
-    })(RendererStyleFlags3 || (RendererStyleFlags3 = {}));
-    /** Returns whether the `renderer` is a `ProceduralRenderer3` */
-    function isProceduralRenderer(renderer) {
-        return !!(renderer.listen);
-    }
-    var ɵ0$2 = function (hostElement, rendererType) { return getDocument(); };
-    var domRendererFactory3 = {
-        createRenderer: ɵ0$2
-    };
-
     /**
      * Assigns all attribute values to the provided element via the inferred renderer.
      *
@@ -32217,135 +32578,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
     }
 
-    /**
-     * @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
-     */
-    /**
-     * This property will be monkey-patched on elements, components and directives
-     */
-    var MONKEY_PATCH_KEY_NAME = '__ngContext__';
-
-    /**
-     * @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
-     */
-    /**
-     * For efficiency reasons we often put several different data types (`RNode`, `LView`, `LContainer`)
-     * in same location in `LView`. This is because we don't want to pre-allocate space for it
-     * because the storage is sparse. This file contains utilities for dealing with such data types.
-     *
-     * How do we know what is stored at a given location in `LView`.
-     * - `Array.isArray(value) === false` => `RNode` (The normal storage value)
-     * - `Array.isArray(value) === true` => then the `value[0]` represents the wrapped value.
-     *   - `typeof value[TYPE] === 'object'` => `LView`
-     *      - This happens when we have a component at a given location
-     *   - `typeof value[TYPE] === true` => `LContainer`
-     *      - This happens when we have `LContainer` binding at a given location.
-     *
-     *
-     * NOTE: it is assumed that `Array.isArray` and `typeof` operations are very efficient.
-     */
-    /**
-     * Returns `RNode`.
-     * @param value wrapped value of `RNode`, `LView`, `LContainer`
-     */
-    function unwrapRNode(value) {
-        while (Array.isArray(value)) {
-            value = value[HOST];
-        }
-        return value;
-    }
-    /**
-     * Retrieve an `RNode` for a given `TNode` and `LView`.
-     *
-     * This function guarantees in dev mode to retrieve a non-null `RNode`.
-     *
-     * @param tNode
-     * @param lView
-     */
-    function getNativeByTNode(tNode, lView) {
-        ngDevMode && assertTNodeForLView(tNode, lView);
-        ngDevMode && assertDataInRange(lView, tNode.index);
-        var node = unwrapRNode(lView[tNode.index]);
-        ngDevMode && !isProceduralRenderer(lView[RENDERER]) && assertDomNode(node);
-        return node;
-    }
-    /**
-     * Retrieve an `RNode` or `null` for a given `TNode` and `LView`.
-     *
-     * Some `TNode`s don't have associated `RNode`s. For example `Projection`
-     *
-     * @param tNode
-     * @param lView
-     */
-    function getNativeByTNodeOrNull(tNode, lView) {
-        var index = tNode.index;
-        if (index !== -1) {
-            ngDevMode && assertTNodeForLView(tNode, lView);
-            var node = unwrapRNode(lView[index]);
-            ngDevMode && node !== null && !isProceduralRenderer(lView[RENDERER]) && assertDomNode(node);
-            return node;
-        }
-        return null;
-    }
-    function getTNode(tView, index) {
-        ngDevMode && assertGreaterThan(index, -1, 'wrong index for TNode');
-        ngDevMode && assertLessThan(index, tView.data.length, 'wrong index for TNode');
-        return tView.data[index + HEADER_OFFSET];
-    }
-    function getComponentLViewByIndex(nodeIndex, hostView) {
-        // Could be an LView or an LContainer. If LContainer, unwrap to find LView.
-        ngDevMode && assertDataInRange(hostView, nodeIndex);
-        var slotValue = hostView[nodeIndex];
-        var lView = isLView(slotValue) ? slotValue : slotValue[HOST];
-        return lView;
-    }
-    /**
-     * Returns the monkey-patch value data present on the target (which could be
-     * a component, directive or a DOM node).
-     */
-    function readPatchedData(target) {
-        ngDevMode && assertDefined(target, 'Target expected');
-        return target[MONKEY_PATCH_KEY_NAME] || null;
-    }
-    function readPatchedLView(target) {
-        var value = readPatchedData(target);
-        if (value) {
-            return Array.isArray(value) ? value : value.lView;
-        }
-        return null;
-    }
-    /** Checks whether a given view is in creation mode */
-    function isCreationMode(view) {
-        return (view[FLAGS] & 4 /* CreationMode */) === 4 /* CreationMode */;
-    }
-    /**
-     * Returns a boolean for whether the view is attached to the change detection tree.
-     *
-     * Note: This determines whether a view should be checked, not whether it's inserted
-     * into a container. For that, you'll want `viewAttachedToContainer` below.
-     */
-    function viewAttachedToChangeDetector(view) {
-        return (view[FLAGS] & 128 /* Attached */) === 128 /* Attached */;
-    }
-    /**
-     * Resets the pre-order hook flags of the view.
-     * @param lView the LView on which the flags are reset
-     */
-    function resetPreOrderHookFlags(lView) {
-        lView[PREORDER_HOOK_FLAGS] = 0;
-    }
-    function getLContainerActiveIndex(lContainer) {
-        return lContainer[ACTIVE_INDEX] >> 1 /* SHIFT */;
-    }
-
     /**
      * @license
      * Copyright Google Inc. All Rights Reserved.
@@ -32580,7 +32812,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         var tNode = lView[TVIEW].data[nodeIndex];
         var directiveStartIndex = tNode.directiveStart;
         if (directiveStartIndex == 0)
-            return EMPTY_ARRAY$1;
+            return EMPTY_ARRAY;
         var directiveEndIndex = tNode.directiveEnd;
         if (!includeComponents && tNode.flags & 2 /* isComponentHost */)
             directiveStartIndex++;
@@ -35894,7 +36126,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      */
     var ɵ0$6 = getClosureSafeProperty;
     var USE_VALUE$4 = getClosureSafeProperty({ provide: String, useValue: ɵ0$6 });
-    var EMPTY_ARRAY$2 = [];
+    var EMPTY_ARRAY$1 = [];
     function convertInjectableProviderToFactory(type, provider) {
         if (!provider) {
             var reflectionCapabilities = new ReflectionCapabilities();
@@ -35912,7 +36144,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
         else if (provider.useFactory) {
             var factoryProvider_1 = provider;
-            return function () { return factoryProvider_1.useFactory.apply(factoryProvider_1, __spread(injectArgs(factoryProvider_1.deps || EMPTY_ARRAY$2))); };
+            return function () { return factoryProvider_1.useFactory.apply(factoryProvider_1, __spread(injectArgs(factoryProvider_1.deps || EMPTY_ARRAY$1))); };
         }
         else if (provider.useClass) {
             var classProvider_1 = provider;
@@ -35999,7 +36231,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * a circular dependency among the providers.
      */
     var CIRCULAR = {};
-    var EMPTY_ARRAY$3 = [];
+    var EMPTY_ARRAY$2 = [];
     /**
      * A lazily initialized NullInjector.
      */
@@ -36011,15 +36243,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         return NULL_INJECTOR;
     }
     /**
-     * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
-     *
-     * @publicApi
+     * Creates a new injector without eagerly resolving its injector types. Can be used in places
+     * where resolving the injector types immediately can lead to an infinite loop. The injector types
+     * should be resolved at a later point by calling `_resolveInjectorDefTypes`.
      */
-    function createInjector(defType, parent, additionalProviders, name) {
+    function createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name) {
         if (parent === void 0) { parent = null; }
         if (additionalProviders === void 0) { additionalProviders = null; }
-        parent = parent || getNullInjector();
-        return new R3Injector(defType, additionalProviders, parent, name);
+        return new R3Injector(defType, additionalProviders, parent || getNullInjector(), name);
     }
     var R3Injector = /** @class */ (function () {
         function R3Injector(def, additionalProviders, parent, source) {
@@ -36053,8 +36284,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             // any injectable scoped to APP_ROOT_SCOPE.
             var record = this.records.get(INJECTOR_SCOPE);
             this.scope = record != null ? record.value : null;
-            // Eagerly instantiate the InjectorType classes themselves.
-            this.injectorDefTypes.forEach(function (defType) { return _this.get(defType); });
             // Source name, used for debugging
             this.source = source || (typeof def === 'object' ? null : stringify$1(def));
         }
@@ -36149,6 +36378,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 setCurrentInjector(previousInjector);
             }
         };
+        /** @internal */
+        R3Injector.prototype._resolveInjectorDefTypes = function () {
+            var _this = this;
+            this.injectorDefTypes.forEach(function (defType) { return _this.get(defType); });
+        };
         R3Injector.prototype.toString = function () {
             var tokens = [], records = this.records;
             records.forEach(function (v, token) { return tokens.push(stringify$1(token)); });
@@ -36230,7 +36464,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                 if (importTypesWithProviders_1 !== undefined) {
                     var _loop_1 = function (i) {
                         var _a = importTypesWithProviders_1[i], ngModule_1 = _a.ngModule, providers = _a.providers;
-                        deepForEach(providers, function (provider) { return _this.processProvider(provider, ngModule_1, providers || EMPTY_ARRAY$3); });
+                        deepForEach(providers, function (provider) { return _this.processProvider(provider, ngModule_1, providers || EMPTY_ARRAY$2); });
                     };
                     for (var i = 0; i < importTypesWithProviders_1.length; i++) {
                         _loop_1(i);
@@ -37934,7 +38168,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * code.
      */
     var EMPTY_OBJ$1 = {};
-    var EMPTY_ARRAY$4 = [];
+    var EMPTY_ARRAY$3 = [];
     // freezing the values prevents any code from accidentally inserting new values in
     if ((typeof ngDevMode === 'undefined' || ngDevMode) && initNgDevMode()) {
         // These property accesses can be ignored because ngDevMode will be set to false
@@ -37942,7 +38176,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         // tslint:disable-next-line:no-toplevel-property-access
         Object.freeze(EMPTY_OBJ$1);
         // tslint:disable-next-line:no-toplevel-property-access
-        Object.freeze(EMPTY_ARRAY$4);
+        Object.freeze(EMPTY_ARRAY$3);
     }
 
     /**
@@ -38571,7 +38805,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     /**
      * @publicApi
      */
-    var VERSION$2 = new Version$1('9.0.3');
+    var VERSION$2 = new Version$1('9.0.7');
 
     /**
      * @license
@@ -40716,7 +40950,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         });
         return TemplateRef_;
     }(TemplateRef));
-    function createInjector$1(view, elDef) {
+    function createInjector(view, elDef) {
         return new Injector_(view, elDef);
     }
     var Injector_ = /** @class */ (function () {
@@ -41025,7 +41259,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
                     }
                     case InjectorRefTokenKey$1:
                     case INJECTORRefTokenKey$1:
-                        return createInjector$1(searchView, elDef);
+                        return createInjector(searchView, elDef);
                     default:
                         var providerDef_1 = (allowPrivateServices ? elDef.element.allProviders :
                             elDef.element.publicProviders)[tokenKey];
@@ -41580,10 +41814,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             var ngLocaleIdDef = getNgLocaleIdDef(ngModuleType);
             ngLocaleIdDef && setLocaleId(ngLocaleIdDef);
             _this._bootstrapComponents = maybeUnwrapFn(ngModuleDef.bootstrap);
-            _this._r3Injector = createInjector(ngModuleType, _parent, [
+            _this._r3Injector = createInjectorWithoutInjectorInstances(ngModuleType, _parent, [
                 { provide: NgModuleRef, useValue: _this },
                 { provide: ComponentFactoryResolver, useValue: _this.componentFactoryResolver }
             ], stringify$1(ngModuleType));
+            // We need to resolve the injector types separately from the injector creation, because
+            // the module might be trying to use this ref in its contructor for DI which will cause a
+            // circular error that will eventually error out, because the injector isn't created yet.
+            _this._r3Injector._resolveInjectorDefTypes();
             _this.instance = _this.get(ngModuleType);
             return _this;
         }
@@ -47608,7 +47846,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
             configurable: true
         });
         Object.defineProperty(DebugContext_.prototype, "injector", {
-            get: function () { return createInjector$1(this.elView, this.elDef); },
+            get: function () { return createInjector(this.elView, this.elDef); },
             enumerable: true,
             configurable: true
         });
@@ -50577,7 +50815,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
-    var VERSION$3 = new Version$1('9.0.3');
+    var VERSION$3 = new Version$1('9.0.7');
 
     exports.TypeScriptServiceHost = TypeScriptServiceHost;
     exports.VERSION = VERSION$3;