@angular/language-service 12.1.0-next.4 → 12.1.1

package/bundles/ivy.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v12.1.0-next.4
+ * @license Angular v12.1.1
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -5092,8 +5092,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             // There is a base factory variable so wrap its declaration along with the factory function into
             // an IIFE.
             factoryFn = fn([], [
-                new DeclareVarStmt(baseFactoryVar.name),
-                new ReturnStatement(factoryFn)
+                new DeclareVarStmt(baseFactoryVar.name), new ReturnStatement(factoryFn)
             ]).callFn([], /* sourceSpan */ undefined, /* pure */ true);
         }
         return {
@@ -6530,19 +6529,29 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
     }
     class KeyedRead extends AST {
-        constructor(span, sourceSpan, obj, key) {
+        constructor(span, sourceSpan, receiver, key) {
             super(span, sourceSpan);
-            this.obj = obj;
+            this.receiver = receiver;
             this.key = key;
         }
         visit(visitor, context = null) {
             return visitor.visitKeyedRead(this, context);
         }
     }
+    class SafeKeyedRead extends AST {
+        constructor(span, sourceSpan, receiver, key) {
+            super(span, sourceSpan);
+            this.receiver = receiver;
+            this.key = key;
+        }
+        visit(visitor, context = null) {
+            return visitor.visitSafeKeyedRead(this, context);
+        }
+    }
     class KeyedWrite extends AST {
-        constructor(span, sourceSpan, obj, key, value) {
+        constructor(span, sourceSpan, receiver, key, value) {
             super(span, sourceSpan);
-            this.obj = obj;
+            this.receiver = receiver;
             this.key = key;
             this.value = value;
         }
@@ -6791,11 +6800,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this.visitAll(ast.expressions, context);
         }
         visitKeyedRead(ast, context) {
-            this.visit(ast.obj, context);
+            this.visit(ast.receiver, context);
             this.visit(ast.key, context);
         }
         visitKeyedWrite(ast, context) {
-            this.visit(ast.obj, context);
+            this.visit(ast.receiver, context);
             this.visit(ast.key, context);
             this.visit(ast.value, context);
         }
@@ -6830,6 +6839,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this.visit(ast.receiver, context);
             this.visitAll(ast.args, context);
         }
+        visitSafeKeyedRead(ast, context) {
+            this.visit(ast.receiver, context);
+            this.visit(ast.key, context);
+        }
         visitQuote(ast, context) { }
         // This is not part of the AstVisitor interface, just a helper method
         visitAll(asts, context) {
@@ -6901,10 +6914,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return new BindingPipe(ast.span, ast.sourceSpan, ast.exp.visit(this), ast.name, this.visitAll(ast.args), ast.nameSpan);
         }
         visitKeyedRead(ast, context) {
-            return new KeyedRead(ast.span, ast.sourceSpan, ast.obj.visit(this), ast.key.visit(this));
+            return new KeyedRead(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this));
         }
         visitKeyedWrite(ast, context) {
-            return new KeyedWrite(ast.span, ast.sourceSpan, ast.obj.visit(this), ast.key.visit(this), ast.value.visit(this));
+            return new KeyedWrite(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this), ast.value.visit(this));
         }
         visitAll(asts) {
             const res = [];
@@ -6919,6 +6932,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         visitQuote(ast, context) {
             return new Quote(ast.span, ast.sourceSpan, ast.prefix, ast.uninterpretedExpression, ast.location);
         }
+        visitSafeKeyedRead(ast, context) {
+            return new SafeKeyedRead(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this));
+        }
     }
     // A transformer that only creates new nodes if the transformer makes a change or
     // a change is made a child node.
@@ -7052,18 +7068,18 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return ast;
         }
         visitKeyedRead(ast, context) {
-            const obj = ast.obj.visit(this);
+            const obj = ast.receiver.visit(this);
             const key = ast.key.visit(this);
-            if (obj !== ast.obj || key !== ast.key) {
+            if (obj !== ast.receiver || key !== ast.key) {
                 return new KeyedRead(ast.span, ast.sourceSpan, obj, key);
             }
             return ast;
         }
         visitKeyedWrite(ast, context) {
-            const obj = ast.obj.visit(this);
+            const obj = ast.receiver.visit(this);
             const key = ast.key.visit(this);
             const value = ast.value.visit(this);
-            if (obj !== ast.obj || key !== ast.key || value !== ast.value) {
+            if (obj !== ast.receiver || key !== ast.key || value !== ast.value) {
                 return new KeyedWrite(ast.span, ast.sourceSpan, obj, key, value);
             }
             return ast;
@@ -7089,6 +7105,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         visitQuote(ast, context) {
             return ast;
         }
+        visitSafeKeyedRead(ast, context) {
+            const obj = ast.receiver.visit(this);
+            const key = ast.key.visit(this);
+            if (obj !== ast.receiver || key !== ast.key) {
+                return new SafeKeyedRead(ast.span, ast.sourceSpan, obj, key);
+            }
+            return ast;
+        }
     }
     // Bindings
     class ParsedProperty {
@@ -7647,13 +7671,16 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 return this.convertSafeAccess(ast, leftMostSafe, mode);
             }
             else {
-                return convertToStatementIfNeeded(mode, this._visit(ast.obj, _Mode.Expression).key(this._visit(ast.key, _Mode.Expression)));
+                return convertToStatementIfNeeded(mode, this._visit(ast.receiver, _Mode.Expression).key(this._visit(ast.key, _Mode.Expression)));
             }
         }
         visitKeyedWrite(ast, mode) {
-            const obj = this._visit(ast.obj, _Mode.Expression);
+            const obj = this._visit(ast.receiver, _Mode.Expression);
             const key = this._visit(ast.key, _Mode.Expression);
             const value = this._visit(ast.value, _Mode.Expression);
+            if (obj === this._implicitReceiver) {
+                this._localResolver.maybeRestoreView(0, false);
+            }
             return convertToStatementIfNeeded(mode, obj.key(key).set(value));
         }
         visitLiteralArray(ast, mode) {
@@ -7779,6 +7806,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         visitSafeMethodCall(ast, mode) {
             return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
         }
+        visitSafeKeyedRead(ast, mode) {
+            return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
+        }
         visitAll(asts, mode) {
             return asts.map(ast => this._visit(ast, mode));
         }
@@ -7845,6 +7875,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             if (leftMostSafe instanceof SafeMethodCall) {
                 this._nodeMap.set(leftMostSafe, new MethodCall(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan, leftMostSafe.receiver, leftMostSafe.name, leftMostSafe.args, leftMostSafe.argumentSpan));
             }
+            else if (leftMostSafe instanceof SafeKeyedRead) {
+                this._nodeMap.set(leftMostSafe, new KeyedRead(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.receiver, leftMostSafe.key));
+            }
             else {
                 this._nodeMap.set(leftMostSafe, new PropertyRead(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan, leftMostSafe.receiver, leftMostSafe.name));
             }
@@ -7911,7 +7944,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     return null;
                 },
                 visitKeyedRead(ast) {
-                    return visit(this, ast.obj);
+                    return visit(this, ast.receiver);
                 },
                 visitKeyedWrite(ast) {
                     return null;
@@ -7951,6 +7984,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 },
                 visitSafePropertyRead(ast) {
                     return visit(this, ast.receiver) || ast;
+                },
+                visitSafeKeyedRead(ast) {
+                    return visit(this, ast.receiver) || ast;
                 }
             });
         }
@@ -8030,6 +8066,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 },
                 visitSafePropertyRead(ast) {
                     return false;
+                },
+                visitSafeKeyedRead(ast) {
+                    return false;
                 }
             });
         }
@@ -8086,6 +8125,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this.globals = globals;
         }
         notifyImplicitReceiverUse() { }
+        maybeRestoreView() { }
         getLocal(name) {
             if (name === EventHandlerVars.event.name) {
                 return EventHandlerVars.event;
@@ -9544,10 +9584,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     parts.push(this._readChar(true));
                 }
             } while (!this._isTextEnd());
+            // It is possible that an interpolation was started but not ended inside this text token.
+            // Make sure that we reset the state of the lexer correctly.
+            this._inInterpolation = false;
             this._endToken([this._processCarriageReturns(parts.join(''))]);
         }
         _isTextEnd() {
-            if (this._cursor.peek() === $LT || this._cursor.peek() === $EOF) {
+            if (this._isTagStart() || this._cursor.peek() === $EOF) {
                 return true;
             }
             if (this._tokenizeIcu && !this._inInterpolation) {
@@ -9562,6 +9605,24 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             return false;
         }
+        /**
+         * Returns true if the current cursor is pointing to the start of a tag
+         * (opening/closing/comments/cdata/etc).
+         */
+        _isTagStart() {
+            if (this._cursor.peek() === $LT) {
+                // We assume that `<` followed by whitespace is not the start of an HTML element.
+                const tmp = this._cursor.clone();
+                tmp.advance();
+                // If the next character is alphabetic, ! nor / then it is a tag start
+                const code = tmp.peek();
+                if (($a <= code && code <= $z) || ($A <= code && code <= $Z) ||
+                    code === $SLASH || code === $BANG) {
+                    return true;
+                }
+            }
+            return false;
+        }
         _readUntil(char) {
             const start = this._cursor.clone();
             this._attemptUntilChar(char);
@@ -10134,6 +10195,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
          * opening tag is recovered).
          */
         _popElement(fullName, endSourceSpan) {
+            let unexpectedCloseTagDetected = false;
             for (let stackIndex = this._elementStack.length - 1; stackIndex >= 0; stackIndex--) {
                 const el = this._elementStack[stackIndex];
                 if (el.name == fullName) {
@@ -10143,10 +10205,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     el.endSourceSpan = endSourceSpan;
                     el.sourceSpan.end = endSourceSpan !== null ? endSourceSpan.end : el.sourceSpan.end;
                     this._elementStack.splice(stackIndex, this._elementStack.length - stackIndex);
-                    return true;
+                    return !unexpectedCloseTagDetected;
                 }
                 if (!this.getTagDefinition(el.name).closedByParent) {
-                    return false;
+                    // Note that we encountered an unexpected close tag but continue processing the element
+                    // stack so we can assign an `endSourceSpan` if there is a corresponding start tag for this
+                    // end tag in the stack.
+                    unexpectedCloseTagDetected = true;
                 }
             }
             return false;
@@ -12658,25 +12723,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     result = this.parseAccessMemberOrMethodCall(result, start, false);
                 }
                 else if (this.consumeOptionalOperator('?.')) {
-                    result = this.parseAccessMemberOrMethodCall(result, start, true);
+                    result = this.consumeOptionalCharacter($LBRACKET) ?
+                        this.parseKeyedReadOrWrite(result, start, true) :
+                        this.parseAccessMemberOrMethodCall(result, start, true);
                 }
                 else if (this.consumeOptionalCharacter($LBRACKET)) {
-                    this.withContext(ParseContextFlags.Writable, () => {
-                        this.rbracketsExpected++;
-                        const key = this.parsePipe();
-                        if (key instanceof EmptyExpr) {
-                            this.error(`Key access cannot be empty`);
-                        }
-                        this.rbracketsExpected--;
-                        this.expectCharacter($RBRACKET);
-                        if (this.consumeOptionalOperator('=')) {
-                            const value = this.parseConditional();
-                            result = new KeyedWrite(this.span(start), this.sourceSpan(start), result, key, value);
-                        }
-                        else {
-                            result = new KeyedRead(this.span(start), this.sourceSpan(start), result, key);
-                        }
-                    });
+                    result = this.parseKeyedReadOrWrite(result, start, false);
                 }
                 else if (this.consumeOptionalCharacter($LPAREN)) {
                     this.rparensExpected++;
@@ -12778,18 +12830,30 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             if (!this.consumeOptionalCharacter($RBRACE)) {
                 this.rbracesExpected++;
                 do {
+                    const keyStart = this.inputIndex;
                     const quoted = this.next.isString();
                     const key = this.expectIdentifierOrKeywordOrString();
                     keys.push({ key, quoted });
-                    this.expectCharacter($COLON);
-                    values.push(this.parsePipe());
+                    // Properties with quoted keys can't use the shorthand syntax.
+                    if (quoted) {
+                        this.expectCharacter($COLON);
+                        values.push(this.parsePipe());
+                    }
+                    else if (this.consumeOptionalCharacter($COLON)) {
+                        values.push(this.parsePipe());
+                    }
+                    else {
+                        const span = this.span(keyStart);
+                        const sourceSpan = this.sourceSpan(keyStart);
+                        values.push(new PropertyRead(span, sourceSpan, sourceSpan, new ImplicitReceiver(span, sourceSpan), key));
+                    }
                 } while (this.consumeOptionalCharacter($COMMA));
                 this.rbracesExpected--;
                 this.expectCharacter($RBRACE);
             }
             return new LiteralMap(this.span(start), this.sourceSpan(start), keys, values);
         }
-        parseAccessMemberOrMethodCall(receiver, start, isSafe = false) {
+        parseAccessMemberOrMethodCall(receiver, start, isSafe) {
             const nameStart = this.inputIndex;
             const id = this.withContext(ParseContextFlags.Writable, () => {
                 var _a;
@@ -12924,6 +12988,31 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             return new TemplateBindingParseResult(bindings, [] /* warnings */, this.errors);
         }
+        parseKeyedReadOrWrite(receiver, start, isSafe) {
+            return this.withContext(ParseContextFlags.Writable, () => {
+                this.rbracketsExpected++;
+                const key = this.parsePipe();
+                if (key instanceof EmptyExpr) {
+                    this.error(`Key access cannot be empty`);
+                }
+                this.rbracketsExpected--;
+                this.expectCharacter($RBRACKET);
+                if (this.consumeOptionalOperator('=')) {
+                    if (isSafe) {
+                        this.error('The \'?.\' operator cannot be used in the assignment');
+                    }
+                    else {
+                        const value = this.parseConditional();
+                        return new KeyedWrite(this.span(start), this.sourceSpan(start), receiver, key, value);
+                    }
+                }
+                else {
+                    return isSafe ? new SafeKeyedRead(this.span(start), this.sourceSpan(start), receiver, key) :
+                        new KeyedRead(this.span(start), this.sourceSpan(start), receiver, key);
+                }
+                return new EmptyExpr(this.span(start), this.sourceSpan(start));
+            });
+        }
         /**
          * Parse a directive keyword, followed by a mandatory expression.
          * For example, "of items", "trackBy: func".
@@ -13131,6 +13220,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         visitChain(ast, context) { }
         visitQuote(ast, context) { }
+        visitSafeKeyedRead(ast, context) { }
     }
     /**
      * This class implements SimpleExpressionChecker used in View Engine and performs more strict checks
@@ -15319,6 +15409,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         notifyImplicitReceiverUse() {
             this._bindingScope.notifyImplicitReceiverUse();
         }
+        // LocalResolver
+        maybeRestoreView(retrievalLevel, localRefLookup) {
+            this._bindingScope.maybeRestoreView(retrievalLevel, localRefLookup);
+        }
         i18nTranslate(message, params = {}, ref, transformFn) {
             const _ref = ref || this.i18nGenerateMainBlockVar();
             // Closure Compiler requires const names to start with `MSG_` but disallows any other const to
@@ -17959,7 +18053,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
-    const VERSION$1 = new Version('12.1.0-next.4');
+    const VERSION$1 = new Version('12.1.1');
 
     /**
      * @license
@@ -18598,7 +18692,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function compileDeclareClassMetadata(metadata) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-        definitionMap.set('version', literal('12.1.0-next.4'));
+        definitionMap.set('version', literal('12.1.1'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', metadata.type);
         definitionMap.set('decorators', metadata.decorators);
@@ -18638,7 +18732,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createDirectiveDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-        definitionMap.set('version', literal('12.1.0-next.4'));
+        definitionMap.set('version', literal('12.1.1'));
         // e.g. `type: MyDirective`
         definitionMap.set('type', meta.internalType);
         // e.g. `selector: 'some-dir'`
@@ -18855,7 +18949,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function compileDeclareFactoryFunction(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-        definitionMap.set('version', literal('12.1.0-next.4'));
+        definitionMap.set('version', literal('12.1.1'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         definitionMap.set('deps', compileDependencies(meta.deps));
@@ -18897,7 +18991,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createInjectableDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-        definitionMap.set('version', literal('12.1.0-next.4'));
+        definitionMap.set('version', literal('12.1.1'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         // Only generate providedIn property if it has a non-null value
@@ -18976,7 +19070,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createInjectorDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-        definitionMap.set('version', literal('12.1.0-next.4'));
+        definitionMap.set('version', literal('12.1.1'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         definitionMap.set('providers', meta.providers);
@@ -19013,7 +19107,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createNgModuleDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-        definitionMap.set('version', literal('12.1.0-next.4'));
+        definitionMap.set('version', literal('12.1.1'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         // We only generate the keys in the metadata if the arrays contain values.
@@ -19071,7 +19165,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createPipeDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$6));
-        definitionMap.set('version', literal('12.1.0-next.4'));
+        definitionMap.set('version', literal('12.1.1'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         // e.g. `type: MyPipe`
         definitionMap.set('type', meta.internalType);
@@ -19103,7 +19197,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
-    const VERSION$2 = new Version('12.1.0-next.4');
+    const VERSION$2 = new Version('12.1.1');
 
     /**
      * @license
@@ -19204,6 +19298,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
          * sheet.
          */
         ErrorCode[ErrorCode["COMPONENT_RESOURCE_NOT_FOUND"] = 2008] = "COMPONENT_RESOURCE_NOT_FOUND";
+        /**
+         * Raised when a component uses `ShadowDom` view encapsulation, but its selector
+         * does not match the shadow DOM tag name requirements.
+         */
+        ErrorCode[ErrorCode["COMPONENT_INVALID_SHADOW_DOM_SELECTOR"] = 2009] = "COMPONENT_INVALID_SHADOW_DOM_SELECTOR";
         ErrorCode[ErrorCode["SYMBOL_NOT_EXPORTED"] = 3001] = "SYMBOL_NOT_EXPORTED";
         ErrorCode[ErrorCode["SYMBOL_EXPORTED_UNDER_DIFFERENT_NAME"] = 3002] = "SYMBOL_EXPORTED_UNDER_DIFFERENT_NAME";
         /**
@@ -19344,6 +19443,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         ErrorCode.SCHEMA_INVALID_ELEMENT,
         ErrorCode.SCHEMA_INVALID_ATTRIBUTE,
         ErrorCode.MISSING_REFERENCE_TARGET,
+        ErrorCode.COMPONENT_INVALID_SHADOW_DOM_SELECTOR,
     ]);
     /**
      * @internal
@@ -19406,6 +19506,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * found in the LICENSE file at https://angular.io/license
      */
     const D_TS = /\.d\.ts$/i;
+    function isSymbolWithValueDeclaration(symbol) {
+        // If there is a value declaration set, then the `declarations` property is never undefined. We
+        // still check for the property to exist as this matches with the type that `symbol` is narrowed
+        // to.
+        return symbol != null && symbol.valueDeclaration !== undefined &&
+            symbol.declarations !== undefined;
+    }
     function isDtsPath(filePath) {
         return D_TS.test(filePath);
     }
@@ -21272,7 +21379,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 return null;
             }
             const namespaceSymbol = this.checker.getSymbolAtLocation(namespaceIdentifier);
-            if (!namespaceSymbol) {
+            if (!namespaceSymbol || namespaceSymbol.declarations === undefined) {
                 return null;
             }
             const declaration = namespaceSymbol.declarations.length === 1 ? namespaceSymbol.declarations[0] : null;
@@ -22360,8 +22467,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         static fromComplexFunctionCall(node, fn) {
             return new DynamicValue(node, fn, 6 /* COMPLEX_FUNCTION_CALL */);
         }
+        static fromDynamicType(node) {
+            return new DynamicValue(node, undefined, 7 /* DYNAMIC_TYPE */);
+        }
         static fromUnknown(node) {
-            return new DynamicValue(node, undefined, 7 /* UNKNOWN */);
+            return new DynamicValue(node, undefined, 8 /* UNKNOWN */);
         }
         isFromDynamicInput() {
             return this.code === 0 /* DYNAMIC_INPUT */;
@@ -22384,8 +22494,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         isFromComplexFunctionCall() {
             return this.code === 6 /* COMPLEX_FUNCTION_CALL */;
         }
+        isFromDynamicType() {
+            return this.code === 7 /* DYNAMIC_TYPE */;
+        }
         isFromUnknown() {
-            return this.code === 7 /* UNKNOWN */;
+            return this.code === 8 /* UNKNOWN */;
         }
         accept(visitor) {
             switch (this.code) {
@@ -22403,7 +22516,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     return visitor.visitInvalidExpressionType(this);
                 case 6 /* COMPLEX_FUNCTION_CALL */:
                     return visitor.visitComplexFunctionCall(this);
-                case 7 /* UNKNOWN */:
+                case 7 /* DYNAMIC_TYPE */:
+                    return visitor.visitDynamicType(this);
+                case 8 /* UNKNOWN */:
                     return visitor.visitUnknown(this);
             }
         }
@@ -22571,6 +22686,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         visitUnknownIdentifier(value) {
             return [makeRelatedInformation(value.node, 'Unknown reference.')];
         }
+        visitDynamicType(value) {
+            return [makeRelatedInformation(value.node, 'Dynamic type.')];
+        }
         visitUnsupportedSyntax(value) {
             return [makeRelatedInformation(value.node, 'This syntax is not supported.')];
         }
@@ -23060,6 +23178,23 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 return this.visitExpression(value, context);
             }
             else if (isVariableDeclarationDeclared(node)) {
+                // If the declaration has a literal type that can be statically reduced to a value, resolve to
+                // that value. If not, the historical behavior for variable declarations is to return a
+                // `Reference` to the variable, as the consumer could use it in a context where knowing its
+                // static value is not necessary.
+                //
+                // Arguably, since the value cannot be statically determined, we should return a
+                // `DynamicValue`. This returns a `Reference` because it's the same behavior as before
+                // `visitType` was introduced.
+                //
+                // TODO(zarend): investigate switching to a `DynamicValue` and verify this won't break any
+                // use cases, especially in ngcc
+                if (node.type !== undefined) {
+                    const evaluatedType = this.visitType(node.type, context);
+                    if (!(evaluatedType instanceof DynamicValue)) {
+                        return evaluatedType;
+                    }
+                }
                 return this.getReference(node, context);
             }
             else {
@@ -23417,6 +23552,25 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         getReference(node, context) {
             return new Reference$1(node, owningModule(context));
         }
+        visitType(node, context) {
+            if (ts$1.isLiteralTypeNode(node)) {
+                return this.visitExpression(node.literal, context);
+            }
+            else if (ts$1.isTupleTypeNode(node)) {
+                return this.visitTupleType(node, context);
+            }
+            else if (ts$1.isNamedTupleMember(node)) {
+                return this.visitType(node.type, context);
+            }
+            return DynamicValue.fromDynamicType(node);
+        }
+        visitTupleType(node, context) {
+            const res = [];
+            for (const elem of node.elements) {
+                res.push(this.visitType(elem, context));
+            }
+            return res;
+        }
     }
     function isFunctionOrMethodReference(ref) {
         return ts$1.isFunctionDeclaration(ref.node) || ts$1.isMethodDeclaration(ref.node) ||
@@ -24200,6 +24354,17 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             return records;
         }
+        getAnalyzedRecords() {
+            const result = new Map();
+            for (const [sf, classes] of this.fileToClasses) {
+                const records = [];
+                for (const clazz of classes) {
+                    records.push(this.classes.get(clazz));
+                }
+                result.set(sf, records);
+            }
+            return result;
+        }
         /**
          * Import a `ClassRecord` from a previous compilation.
          *
@@ -24481,6 +24646,24 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 }
             }
         }
+        xi18n(bundle) {
+            for (const clazz of this.classes.keys()) {
+                const record = this.classes.get(clazz);
+                for (const trait of record.traits) {
+                    if (trait.state !== TraitState.Analyzed && trait.state !== TraitState.Resolved) {
+                        // Skip traits that haven't been analyzed successfully.
+                        continue;
+                    }
+                    else if (trait.handler.xi18n === undefined) {
+                        // Skip traits that don't support xi18n.
+                        continue;
+                    }
+                    if (trait.analysis !== null) {
+                        trait.handler.xi18n(bundle, clazz, trait.analysis);
+                    }
+                }
+            }
+        }
         updateResources(clazz) {
             if (!this.reflector.isClass(clazz) || !this.classes.has(clazz)) {
                 return;
@@ -25460,7 +25643,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     class DtsTransformRegistry {
         constructor() {
             this.ivyDeclarationTransforms = new Map();
-            this.returnTypeTransforms = new Map();
         }
         getIvyDeclarationTransform(sf) {
             if (!this.ivyDeclarationTransforms.has(sf)) {
@@ -25468,12 +25650,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             return this.ivyDeclarationTransforms.get(sf);
         }
-        getReturnTypeTransform(sf) {
-            if (!this.returnTypeTransforms.has(sf)) {
-                this.returnTypeTransforms.set(sf, new ReturnTypeTransform());
-            }
-            return this.returnTypeTransforms.get(sf);
-        }
         /**
          * Gets the dts transforms to be applied for the given source file, or `null` if no transform is
          * necessary.
@@ -25492,10 +25668,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 transforms = [];
                 transforms.push(this.ivyDeclarationTransforms.get(originalSf));
             }
-            if (this.returnTypeTransforms.has(originalSf)) {
-                transforms = transforms || [];
-                transforms.push(this.returnTypeTransforms.get(originalSf));
-            }
             return transforms;
         }
     }
@@ -25635,44 +25807,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         ts$1.setEmitFlags(node, ts$1.EmitFlags.SingleLine);
         ts$1.forEachChild(node, markForEmitAsSingleLine);
     }
-    class ReturnTypeTransform {
-        constructor() {
-            this.typeReplacements = new Map();
-        }
-        addTypeReplacement(declaration, type) {
-            this.typeReplacements.set(declaration, type);
-        }
-        transformClassElement(element, imports) {
-            if (ts$1.isMethodDeclaration(element)) {
-                const original = ts$1.getOriginalNode(element, ts$1.isMethodDeclaration);
-                if (!this.typeReplacements.has(original)) {
-                    return element;
-                }
-                const returnType = this.typeReplacements.get(original);
-                const tsReturnType = translateType(returnType, imports);
-                return ts$1.updateMethod(element, element.decorators, element.modifiers, element.asteriskToken, element.name, element.questionToken, element.typeParameters, element.parameters, tsReturnType, element.body);
-            }
-            return element;
-        }
-        transformFunctionDeclaration(element, imports) {
-            const original = ts$1.getOriginalNode(element);
-            if (!this.typeReplacements.has(original)) {
-                return element;
-            }
-            const returnType = this.typeReplacements.get(original);
-            const tsReturnType = translateType(returnType, imports);
-            return ts$1.updateFunctionDeclaration(
-            /* node */ element, 
-            /* decorators */ element.decorators, 
-            /* modifiers */ element.modifiers, 
-            /* asteriskToken */ element.asteriskToken, 
-            /* name */ element.name, 
-            /* typeParameters */ element.typeParameters, 
-            /* parameters */ element.parameters, 
-            /* type */ tsReturnType, 
-            /* body */ element.body);
-        }
-    }
 
     /**
      * @license
@@ -28283,7 +28417,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                 .then(() => undefined);
         }
         analyze(node, decorator, flags = HandlerFlags.NONE) {
-            var _a;
+            var _a, _b;
             this.perf.eventCount(PerfEvent.AnalyzeComponent);
             const containingFile = node.getSourceFile().fileName;
             this.literalCache.delete(decorator);
@@ -28300,6 +28434,12 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             // Next, read the `@Component`-specific fields.
             const { decorator: component, metadata, inputs, outputs } = directiveResult;
+            const encapsulation = (_a = this._resolveEnumValue(component, 'encapsulation', 'ViewEncapsulation')) !== null && _a !== void 0 ? _a : ViewEncapsulation.Emulated;
+            const changeDetection = this._resolveEnumValue(component, 'changeDetection', 'ChangeDetectionStrategy');
+            let animations = null;
+            if (component.has('animations')) {
+                animations = new WrappedNodeExpr(component.get('animations'));
+            }
             // Go through the root directories for this project, and select the one with the smallest
             // relative path representation.
             const relativeContextFilePath = this.rootDirs.reduce((previous, rootDir) => {
@@ -28364,7 +28504,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                         this.depTracker.addResourceDependency(node.getSourceFile(), absoluteFrom(resourceUrl));
                     }
                 }
-                catch (_b) {
+                catch (_c) {
                     if (diagnostics === undefined) {
                         diagnostics = [];
                     }
@@ -28375,6 +28515,15 @@ Either add the @Injectable() decorator to '${provider.node.name
                         .toDiagnostic());
                 }
             }
+            if (encapsulation === ViewEncapsulation.ShadowDom && metadata.selector !== null) {
+                const selectorError = checkCustomElementSelectorForErrors(metadata.selector);
+                if (selectorError !== null) {
+                    if (diagnostics === undefined) {
+                        diagnostics = [];
+                    }
+                    diagnostics.push(makeDiagnostic(ErrorCode.COMPONENT_INVALID_SHADOW_DOM_SELECTOR, component.get('selector'), selectorError));
+                }
+            }
             // If inline styles were preprocessed use those
             let inlineStyles = null;
             if (this.preanalyzeStylesCache.has(node)) {
@@ -28403,12 +28552,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             if (template.styles.length > 0) {
                 styles.push(...template.styles);
             }
-            const encapsulation = this._resolveEnumValue(component, 'encapsulation', 'ViewEncapsulation') || 0;
-            const changeDetection = this._resolveEnumValue(component, 'changeDetection', 'ChangeDetectionStrategy');
-            let animations = null;
-            if (component.has('animations')) {
-                animations = new WrappedNodeExpr(component.get('animations'));
-            }
             const output = {
                 analysis: {
                     baseClass: readBaseClass$1(node, this.reflector, this.evaluator),
@@ -28417,7 +28560,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                     meta: Object.assign(Object.assign({}, metadata), { template: {
                             nodes: template.nodes,
                             ngContentSelectors: template.ngContentSelectors,
-                        }, encapsulation, interpolation: (_a = template.interpolationConfig) !== null && _a !== void 0 ? _a : DEFAULT_INTERPOLATION_CONFIG, styles,
+                        }, encapsulation, interpolation: (_b = template.interpolationConfig) !== null && _b !== void 0 ? _b : DEFAULT_INTERPOLATION_CONFIG, styles,
                         // These will be replaced during the compilation step, after all `NgModule`s have been
                         // analyzed and the full compilation scope for the component can be realized.
                         animations, viewProviders: wrappedViewProviders, i18nUseExternalIds: this.i18nUseExternalIds, relativeContextFilePath }),
@@ -28651,6 +28794,10 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             return { data };
         }
+        xi18n(ctx, node, analysis) {
+            var _a;
+            ctx.updateFromTemplate(analysis.template.content, analysis.template.declaration.resolvedTemplateUrl, (_a = analysis.template.interpolationConfig) !== null && _a !== void 0 ? _a : DEFAULT_INTERPOLATION_CONFIG);
+        }
         updateResources(node, analysis) {
             const containingFile = node.getSourceFile().fileName;
             // If the template is external, re-parse it.
@@ -29101,6 +29248,28 @@ Either add the @Injectable() decorator to '${provider.node.name
         const message = `The ${type} '${name}' is used in the template but importing it would create a cycle: `;
         return makeRelatedInformation(ref.node, message + path);
     }
+    /**
+     * Checks whether a selector is a valid custom element tag name.
+     * Based loosely on https://github.com/sindresorhus/validate-element-name.
+     */
+    function checkCustomElementSelectorForErrors(selector) {
+        // Avoid flagging components with an attribute or class selector. This isn't bulletproof since it
+        // won't catch cases like `foo[]bar`, but we don't need it to be. This is mainly to avoid flagging
+        // something like `foo-bar[baz]` incorrectly.
+        if (selector.includes('.') || (selector.includes('[') && selector.includes(']'))) {
+            return null;
+        }
+        if (!(/^[a-z]/.test(selector))) {
+            return 'Selector of a ShadowDom-encapsulated component must start with a lower case letter.';
+        }
+        if (/[A-Z]/.test(selector)) {
+            return 'Selector of a ShadowDom-encapsulated component must all be in lower case.';
+        }
+        if (!selector.includes('-')) {
+            return 'Selector of a component that uses ViewEncapsulation.ShadowDom must contain a hyphen.';
+        }
+        return null;
+    }
 
     /**
      * @license
@@ -29667,6 +29836,12 @@ Either add the @Injectable() decorator to '${provider.node.name
                         stmt.moduleSpecifier === undefined) {
                         continue;
                     }
+                    if (ts$1.isImportDeclaration(stmt) && stmt.importClause !== undefined &&
+                        stmt.importClause.isTypeOnly) {
+                        // Exclude type-only imports as they are always elided, so they don't contribute to
+                        // cycles.
+                        continue;
+                    }
                     const symbol = this.checker.getSymbolAtLocation(stmt.moduleSpecifier);
                     if (symbol === undefined || symbol.valueDeclaration === undefined) {
                         // No symbol could be found to skip over this import/export.
@@ -30210,7 +30385,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                 versions: this.versions,
                 depGraph: this.depGraph,
                 semanticDepGraph: newGraph,
-                traitCompiler,
+                priorAnalysis: traitCompiler.getAnalyzedRecords(),
                 typeCheckResults: null,
                 emitted,
             };
@@ -30245,7 +30420,11 @@ Either add the @Injectable() decorator to '${provider.node.name
             if (this.step.logicallyChangedTsFiles.has(sfPath)) {
                 return null;
             }
-            return this.step.priorState.traitCompiler.recordsFor(sf);
+            const priorAnalysis = this.step.priorState.priorAnalysis;
+            if (!priorAnalysis.has(sf)) {
+                return null;
+            }
+            return priorAnalysis.get(sf);
         }
         priorTypeCheckingResultsFor(sf) {
             if (this.phase.kind !== PhaseKind.TypeCheckAndEmit) {
@@ -30733,145 +30912,6 @@ Either add the @Injectable() decorator to '${provider.node.name
         return analysis;
     }
 
-    /**
-     * @license
-     * Copyright Google LLC All Rights Reserved.
-     *
-     * Use of this source code is governed by an MIT-style license that can be
-     * found in the LICENSE file at https://angular.io/license
-     */
-    class ModuleWithProvidersScanner {
-        constructor(host, evaluator, emitter) {
-            this.host = host;
-            this.evaluator = evaluator;
-            this.emitter = emitter;
-        }
-        scan(sf, dts) {
-            for (const stmt of sf.statements) {
-                this.visitStatement(dts, stmt);
-            }
-        }
-        visitStatement(dts, stmt) {
-            // Detect whether a statement is exported, which is used as one of the hints whether to look
-            // more closely at possible MWP functions within. This is a syntactic check, not a semantic
-            // check, so it won't detect cases like:
-            //
-            // var X = ...;
-            // export {X}
-            //
-            // This is intentional, because the alternative is slow and this will catch 99% of the cases we
-            // need to handle.
-            const isExported = stmt.modifiers !== undefined &&
-                stmt.modifiers.some(mod => mod.kind === ts$1.SyntaxKind.ExportKeyword);
-            if (!isExported) {
-                return;
-            }
-            if (ts$1.isClassDeclaration(stmt)) {
-                for (const member of stmt.members) {
-                    if (!ts$1.isMethodDeclaration(member) || !isStatic(member)) {
-                        continue;
-                    }
-                    this.visitFunctionOrMethodDeclaration(dts, member);
-                }
-            }
-            else if (ts$1.isFunctionDeclaration(stmt)) {
-                this.visitFunctionOrMethodDeclaration(dts, stmt);
-            }
-        }
-        visitFunctionOrMethodDeclaration(dts, decl) {
-            // First, some sanity. This should have a method body with a single return statement.
-            if (decl.body === undefined || decl.body.statements.length !== 1) {
-                return;
-            }
-            const retStmt = decl.body.statements[0];
-            if (!ts$1.isReturnStatement(retStmt) || retStmt.expression === undefined) {
-                return;
-            }
-            const retValue = retStmt.expression;
-            // Now, look at the return type of the method. Maybe bail if the type is already marked, or if
-            // it's incompatible with a MWP function.
-            const returnType = this.returnTypeOf(decl);
-            if (returnType === ReturnType.OTHER || returnType === ReturnType.MWP_WITH_TYPE) {
-                // Don't process this declaration, it either already declares the right return type, or an
-                // incompatible one.
-                return;
-            }
-            const value = this.evaluator.evaluate(retValue);
-            if (!(value instanceof Map) || !value.has('ngModule')) {
-                // The return value does not provide sufficient information to be able to add a generic type.
-                return;
-            }
-            if (returnType === ReturnType.INFERRED && !isModuleWithProvidersType(value)) {
-                // The return type is inferred but the returned object is not of the correct shape, so we
-                // shouldn's modify the return type to become `ModuleWithProviders`.
-                return;
-            }
-            // The return type has been verified to represent the `ModuleWithProviders` type, but either the
-            // return type is inferred or the generic type argument is missing. In both cases, a new return
-            // type is created where the `ngModule` type is included as generic type argument.
-            const ngModule = value.get('ngModule');
-            if (!(ngModule instanceof Reference$1) || !ts$1.isClassDeclaration(ngModule.node)) {
-                return;
-            }
-            const ngModuleExpr = this.emitter.emit(ngModule, decl.getSourceFile(), ImportFlags.ForceNewImport);
-            const ngModuleType = new ExpressionType(ngModuleExpr.expression);
-            const mwpNgType = new ExpressionType(new ExternalExpr(Identifiers.ModuleWithProviders), [ /* modifiers */], [ngModuleType]);
-            dts.addTypeReplacement(decl, mwpNgType);
-        }
-        returnTypeOf(decl) {
-            if (decl.type === undefined) {
-                return ReturnType.INFERRED;
-            }
-            else if (!ts$1.isTypeReferenceNode(decl.type)) {
-                return ReturnType.OTHER;
-            }
-            // Try to figure out if the type is of a familiar form, something that looks like it was
-            // imported.
-            let typeId;
-            if (ts$1.isIdentifier(decl.type.typeName)) {
-                // def: ModuleWithProviders
-                typeId = decl.type.typeName;
-            }
-            else if (ts$1.isQualifiedName(decl.type.typeName) && ts$1.isIdentifier(decl.type.typeName.left)) {
-                // def: i0.ModuleWithProviders
-                typeId = decl.type.typeName.right;
-            }
-            else {
-                return ReturnType.OTHER;
-            }
-            const importDecl = this.host.getImportOfIdentifier(typeId);
-            if (importDecl === null || importDecl.from !== '@angular/core' ||
-                importDecl.name !== 'ModuleWithProviders') {
-                return ReturnType.OTHER;
-            }
-            if (decl.type.typeArguments === undefined || decl.type.typeArguments.length === 0) {
-                // The return type is indeed ModuleWithProviders, but no generic type parameter was found.
-                return ReturnType.MWP_NO_TYPE;
-            }
-            else {
-                // The return type is ModuleWithProviders, and the user has already specified a generic type.
-                return ReturnType.MWP_WITH_TYPE;
-            }
-        }
-    }
-    var ReturnType;
-    (function (ReturnType) {
-        ReturnType[ReturnType["INFERRED"] = 0] = "INFERRED";
-        ReturnType[ReturnType["MWP_NO_TYPE"] = 1] = "MWP_NO_TYPE";
-        ReturnType[ReturnType["MWP_WITH_TYPE"] = 2] = "MWP_WITH_TYPE";
-        ReturnType[ReturnType["OTHER"] = 3] = "OTHER";
-    })(ReturnType || (ReturnType = {}));
-    /** Whether the resolved value map represents a ModuleWithProviders object */
-    function isModuleWithProvidersType(value) {
-        const ngModule = value.has('ngModule');
-        const providers = value.has('providers');
-        return ngModule && (value.size === 1 || (providers && value.size === 2));
-    }
-    function isStatic(node) {
-        return node.modifiers !== undefined &&
-            node.modifiers.some(mod => mod.kind === ts$1.SyntaxKind.StaticKeyword);
-    }
-
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -31519,6 +31559,9 @@ Either add the @Injectable() decorator to '${provider.node.name
             if (alias === null) {
                 return dirOrPipe;
             }
+            // TypeScript incorrectly narrows the type here:
+            // https://github.com/microsoft/TypeScript/issues/43966.
+            // TODO: Remove/Update once https://github.com/microsoft/TypeScript/issues/43966 is resolved.
             return Object.assign(Object.assign({}, dirOrPipe), { ref: ref.cloneWithAlias(alias) });
         }
     }
@@ -33164,6 +33207,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
+    const INELIGIBLE = {};
     /**
      * Determines whether the provided type can be emitted, which means that it can be safely emitted
      * into a different location.
@@ -33175,13 +33219,24 @@ Either add the @Injectable() decorator to '${provider.node.name
     function canEmitType(type, resolver) {
         return canEmitTypeWorker(type);
         function canEmitTypeWorker(type) {
-            return visitTypeNode(type, {
-                visitTypeReferenceNode: type => canEmitTypeReference(type),
-                visitArrayTypeNode: type => canEmitTypeWorker(type.elementType),
-                visitKeywordType: () => true,
-                visitLiteralType: () => true,
-                visitOtherType: () => false,
-            });
+            return visitNode(type) !== INELIGIBLE;
+        }
+        // To determine whether a type can be emitted, we have to recursively look through all type nodes.
+        // If a type reference node is found at any position within the type and that type reference
+        // cannot be emitted, then the `INELIGIBLE` constant is returned to stop the recursive walk as
+        // the type as a whole cannot be emitted in that case. Otherwise, the result of visiting all child
+        // nodes determines the result. If no ineligible type reference node is found then the walk
+        // returns `undefined`, indicating that no type node was visited that could not be emitted.
+        function visitNode(node) {
+            // Emitting a type reference node in a different context requires that an import for the type
+            // can be created. If a type reference node cannot be emitted, `INELIGIBLE` is returned to stop
+            // the walk.
+            if (ts$1.isTypeReferenceNode(node) && !canEmitTypeReference(node)) {
+                return INELIGIBLE;
+            }
+            else {
+                return ts$1.forEachChild(node, visitNode);
+            }
         }
         function canEmitTypeReference(type) {
             const reference = resolver(type);
@@ -33189,10 +33244,9 @@ Either add the @Injectable() decorator to '${provider.node.name
             if (reference === null) {
                 return false;
             }
-            // If the type is a reference without a owning module, consider the type not to be eligible for
-            // emitting.
-            if (reference instanceof Reference$1 && !reference.hasOwningModuleGuess) {
-                return false;
+            // If the type is a reference, consider the type to be eligible for emitting.
+            if (reference instanceof Reference$1) {
+                return true;
             }
             // The type can be emitted if either it does not have any type arguments, or all of them can be
             // emitted.
@@ -33234,15 +33288,18 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.emitReference = emitReference;
         }
         emitType(type) {
-            return visitTypeNode(type, {
-                visitTypeReferenceNode: type => this.emitTypeReference(type),
-                visitArrayTypeNode: type => ts$1.updateArrayTypeNode(type, this.emitType(type.elementType)),
-                visitKeywordType: type => type,
-                visitLiteralType: type => type,
-                visitOtherType: () => {
-                    throw new Error('Unable to emit a complex type');
-                },
-            });
+            const typeReferenceTransformer = context => {
+                const visitNode = (node) => {
+                    if (ts$1.isTypeReferenceNode(node)) {
+                        return this.emitTypeReference(node);
+                    }
+                    else {
+                        return ts$1.visitEachChild(node, visitNode, context);
+                    }
+                };
+                return node => ts$1.visitNode(node, visitNode);
+            };
+            return ts$1.transform(type, [typeReferenceTransformer]).transformed[0];
         }
         emitTypeReference(type) {
             // Determine the reference that the type corresponds with.
@@ -33258,9 +33315,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             // Emit the type name.
             let typeName = type.typeName;
             if (reference instanceof Reference$1) {
-                if (!reference.hasOwningModuleGuess) {
-                    throw new Error('A type reference to emit must be imported from an absolute module');
-                }
                 const emittedType = this.emitReference(reference);
                 if (!ts$1.isTypeReferenceNode(emittedType)) {
                     throw new Error(`Expected TypeReferenceNode for emitted reference, got ${ts$1.SyntaxKind[emittedType.kind]}`);
@@ -33270,30 +33324,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             return ts$1.updateTypeReferenceNode(type, typeName, typeArguments);
         }
     }
-    function visitTypeNode(type, visitor) {
-        if (ts$1.isTypeReferenceNode(type)) {
-            return visitor.visitTypeReferenceNode(type);
-        }
-        else if (ts$1.isArrayTypeNode(type)) {
-            return visitor.visitArrayTypeNode(type);
-        }
-        else if (ts$1.isLiteralTypeNode(type)) {
-            return visitor.visitLiteralType(type);
-        }
-        switch (type.kind) {
-            case ts$1.SyntaxKind.AnyKeyword:
-            case ts$1.SyntaxKind.UnknownKeyword:
-            case ts$1.SyntaxKind.NumberKeyword:
-            case ts$1.SyntaxKind.ObjectKeyword:
-            case ts$1.SyntaxKind.BooleanKeyword:
-            case ts$1.SyntaxKind.StringKeyword:
-            case ts$1.SyntaxKind.UndefinedKeyword:
-            case ts$1.SyntaxKind.NullKeyword:
-                return visitor.visitKeywordType(type);
-            default:
-                return visitor.visitOtherType(type);
-        }
-    }
 
     /**
      * @license
@@ -33320,12 +33350,15 @@ Either add the @Injectable() decorator to '${provider.node.name
                 return true;
             }
             return this.typeParameters.every(typeParam => {
-                if (typeParam.constraint === undefined) {
-                    return true;
-                }
-                return canEmitType(typeParam.constraint, type => this.resolveTypeReference(type));
+                return this.canEmitType(typeParam.constraint) && this.canEmitType(typeParam.default);
             });
         }
+        canEmitType(type) {
+            if (type === undefined) {
+                return true;
+            }
+            return canEmitType(type, typeReference => this.resolveTypeReference(typeReference));
+        }
         /**
          * Emits the type parameters using the provided emitter function for `Reference`s.
          */
@@ -33336,11 +33369,12 @@ Either add the @Injectable() decorator to '${provider.node.name
             const emitter = new TypeEmitter(type => this.resolveTypeReference(type), emitReference);
             return this.typeParameters.map(typeParam => {
                 const constraint = typeParam.constraint !== undefined ? emitter.emitType(typeParam.constraint) : undefined;
+                const defaultType = typeParam.default !== undefined ? emitter.emitType(typeParam.default) : undefined;
                 return ts$1.updateTypeParameterDeclaration(
                 /* node */ typeParam, 
                 /* name */ typeParam.name, 
                 /* constraint */ constraint, 
-                /* defaultType */ typeParam.default);
+                /* defaultType */ defaultType);
             });
         }
         resolveTypeReference(type) {
@@ -33363,8 +33397,16 @@ Either add the @Injectable() decorator to '${provider.node.name
                     resolutionContext: type.getSourceFile().fileName,
                 };
             }
+            // If no owning module is known, the reference needs to be exported to be able to emit an import
+            // statement for it. If the declaration is not exported, null is returned to prevent emit.
+            if (owningModule === null && !this.isStaticallyExported(declaration.node)) {
+                return null;
+            }
             return new Reference$1(declaration.node, owningModule);
         }
+        isStaticallyExported(decl) {
+            return isNamedClassDeclaration(decl) && this.reflector.isStaticallyExported(decl);
+        }
         isLocalTypeParameter(decl) {
             // Checking for local type parameters only occurs during resolution of type parameters, so it is
             // guaranteed that type parameters are present.
@@ -34227,14 +34269,14 @@ Either add the @Injectable() decorator to '${provider.node.name
             return ast.expressions.reduce((lhs, ast) => ts$1.createBinary(lhs, ts$1.SyntaxKind.PlusToken, wrapForTypeChecker(this.translate(ast))), ts$1.createLiteral(''));
         }
         visitKeyedRead(ast) {
-            const receiver = wrapForDiagnostics(this.translate(ast.obj));
+            const receiver = wrapForDiagnostics(this.translate(ast.receiver));
             const key = this.translate(ast.key);
             const node = ts$1.createElementAccess(receiver, key);
             addParseSpanInfo(node, ast.sourceSpan);
             return node;
         }
         visitKeyedWrite(ast) {
-            const receiver = wrapForDiagnostics(this.translate(ast.obj));
+            const receiver = wrapForDiagnostics(this.translate(ast.receiver));
             const left = ts$1.createElementAccess(receiver, this.translate(ast.key));
             // TODO(joost): annotate `left` with the span of the element access, which is not currently
             //  available on `ast`.
@@ -34393,6 +34435,30 @@ Either add the @Injectable() decorator to '${provider.node.name
             addParseSpanInfo(node, ast.sourceSpan);
             return node;
         }
+        visitSafeKeyedRead(ast) {
+            const receiver = wrapForDiagnostics(this.translate(ast.receiver));
+            const key = this.translate(ast.key);
+            let node;
+            // The form of safe property reads depends on whether strictness is in use.
+            if (this.config.strictSafeNavigationTypes) {
+                // "a?.[...]" becomes (null as any ? a![...] : undefined)
+                const expr = ts$1.createElementAccess(ts$1.createNonNullExpression(receiver), key);
+                addParseSpanInfo(expr, ast.sourceSpan);
+                node = ts$1.createParen(ts$1.createConditional(NULL_AS_ANY, expr, UNDEFINED));
+            }
+            else if (VeSafeLhsInferenceBugDetector.veWillInferAnyFor(ast)) {
+                // "a?.[...]" becomes (a as any)[...]
+                node = ts$1.createElementAccess(tsCastToAny(receiver), key);
+            }
+            else {
+                // "a?.[...]" becomes (a!.[...] as any)
+                const expr = ts$1.createElementAccess(ts$1.createNonNullExpression(receiver), key);
+                addParseSpanInfo(expr, ast.sourceSpan);
+                node = tsCastToAny(expr);
+            }
+            addParseSpanInfo(node, ast.sourceSpan);
+            return node;
+        }
     }
     /**
      * Checks whether View Engine will infer a type of 'any' for the left-hand side of a safe navigation
@@ -34409,7 +34475,8 @@ Either add the @Injectable() decorator to '${provider.node.name
      */
     class VeSafeLhsInferenceBugDetector {
         static veWillInferAnyFor(ast) {
-            return ast.receiver.visit(VeSafeLhsInferenceBugDetector.SINGLETON);
+            const visitor = VeSafeLhsInferenceBugDetector.SINGLETON;
+            return ast instanceof SafeKeyedRead ? ast.receiver.visit(visitor) : ast.receiver.visit(visitor);
         }
         visitUnary(ast) {
             return ast.expr.visit(this);
@@ -34477,6 +34544,9 @@ Either add the @Injectable() decorator to '${provider.node.name
         visitSafePropertyRead(ast) {
             return false;
         }
+        visitSafeKeyedRead(ast) {
+            return false;
+        }
     }
     VeSafeLhsInferenceBugDetector.SINGLETON = new VeSafeLhsInferenceBugDetector();
 
@@ -36889,8 +36959,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                 .map(node => {
                 var _a;
                 const symbol = this.getSymbolOfTsNode(node.parent);
-                if (symbol === null || symbol.tsSymbol === null ||
-                    symbol.tsSymbol.valueDeclaration === undefined ||
+                if (symbol === null || !isSymbolWithValueDeclaration(symbol.tsSymbol) ||
                     !ts$1.isClassDeclaration(symbol.tsSymbol.valueDeclaration)) {
                     return null;
                 }
@@ -37046,7 +37115,8 @@ Either add the @Injectable() decorator to '${provider.node.name
             // In either case, `_t1["index"]` or `_t1.index`, `node.expression` is _t1.
             // The retrieved symbol for _t1 will be the variable declaration.
             const tsSymbol = this.getTypeChecker().getSymbolAtLocation(node.expression);
-            if (tsSymbol === undefined || tsSymbol.declarations.length === 0 || selector === null) {
+            if ((tsSymbol === null || tsSymbol === void 0 ? void 0 : tsSymbol.declarations) === undefined || tsSymbol.declarations.length === 0 ||
+                selector === null) {
                 return null;
             }
             const [declaration] = tsSymbol.declarations;
@@ -37058,8 +37128,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                 return null;
             }
             const symbol = this.getSymbolOfTsNode(declaration);
-            if (symbol === null || symbol.tsSymbol === null ||
-                symbol.tsSymbol.valueDeclaration === undefined ||
+            if (symbol === null || !isSymbolWithValueDeclaration(symbol.tsSymbol) ||
                 !ts$1.isClassDeclaration(symbol.tsSymbol.valueDeclaration)) {
                 return null;
             }
@@ -37159,7 +37228,10 @@ Either add the @Injectable() decorator to '${provider.node.name
                 return null;
             }
             const pipeInstance = this.getSymbolOfTsNode(pipeDeclaration.valueDeclaration);
-            if (pipeInstance === null || pipeInstance.tsSymbol === null) {
+            // The instance should never be null, nor should the symbol lack a value declaration. This
+            // is because the node used to look for the `pipeInstance` symbol info is a value
+            // declaration of another symbol (i.e. the `pipeDeclaration` symbol).
+            if (pipeInstance === null || !isSymbolWithValueDeclaration(pipeInstance.tsSymbol)) {
                 return null;
             }
             const symbolInfo = this.getSymbolOfTsNode(methodAccess);
@@ -37181,7 +37253,16 @@ Either add the @Injectable() decorator to '${provider.node.name
             const withSpan = (expression instanceof PropertyWrite || expression instanceof MethodCall) ?
                 expression.nameSpan :
                 expression.sourceSpan;
-            let node = findFirstMatchingNode(this.typeCheckBlock, { withSpan, filter: (n) => true });
+            let node = null;
+            // Property reads in templates usually map to a `PropertyAccessExpression`
+            // (e.g. `ctx.foo`) so try looking for one first.
+            if (expression instanceof PropertyRead) {
+                node = findFirstMatchingNode(this.typeCheckBlock, { withSpan, filter: ts$1.isPropertyAccessExpression });
+            }
+            // Otherwise fall back to searching for any AST node.
+            if (node === null) {
+                node = findFirstMatchingNode(this.typeCheckBlock, { withSpan, filter: anyNodeFilter });
+            }
             if (node === null) {
                 return null;
             }
@@ -37255,6 +37336,10 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
         }
     }
+    /** Filter predicate function that matches any AST node. */
+    function anyNodeFilter(n) {
+        return true;
+    }
 
     /**
      * @license
@@ -37694,7 +37779,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                     continue;
                 }
                 const tsSymbol = typeChecker.getSymbolAtLocation(dir.ref.node.name);
-                if (tsSymbol === undefined) {
+                if (!isSymbolWithValueDeclaration(tsSymbol)) {
                     continue;
                 }
                 let ngModule = null;
@@ -38190,7 +38275,6 @@ Either add the @Injectable() decorator to '${provider.node.name
                             continue;
                         }
                         let analysisPromise = this.compilation.traitCompiler.analyzeAsync(sf);
-                        this.scanForMwp(sf);
                         if (analysisPromise !== undefined) {
                             promises.push(analysisPromise);
                         }
@@ -38280,6 +38364,15 @@ Either add the @Injectable() decorator to '${provider.node.name
             compilation.traitCompiler.index(context);
             return generateAnalysis(context);
         }
+        /**
+         * Collect i18n messages into the `Xi18nContext`.
+         */
+        xi18n(ctx) {
+            // Note that the 'resolve' phase is not strictly necessary for xi18n, but this is not currently
+            // optimized.
+            const compilation = this.ensureAnalyzed();
+            compilation.traitCompiler.xi18n(ctx);
+        }
         ensureAnalyzed() {
             if (this.compilation === null) {
                 this.analyzeSync();
@@ -38294,7 +38387,6 @@ Either add the @Injectable() decorator to '${provider.node.name
                         continue;
                     }
                     this.compilation.traitCompiler.analyzeSync(sf);
-                    this.scanForMwp(sf);
                 }
                 this.perfRecorder.memory(PerfCheckpoint.Analysis);
                 this.resolveCompilation(this.compilation.traitCompiler);
@@ -38465,15 +38557,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             return this.nonTemplateDiagnostics;
         }
-        scanForMwp(sf) {
-            this.compilation.mwpScanner.scan(sf, {
-                addTypeReplacement: (node, type) => {
-                    // Only obtain the return type transform for the source file once there's a type to replace,
-                    // so that no transform is allocated when there's nothing to do.
-                    this.compilation.dtsTransforms.getReturnTypeTransform(sf).addTypeReplacement(node, type);
-                }
-            });
-        }
         makeCompilation() {
             const checker = this.inputProgram.getTypeChecker();
             const reflector = new TypeScriptReflectionHost(checker);
@@ -38556,7 +38639,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             const routeAnalyzer = new NgModuleRouteAnalyzer(this.moduleResolver, evaluator);
             const dtsTransforms = new DtsTransformRegistry();
-            const mwpScanner = new ModuleWithProvidersScanner(reflector, evaluator, refEmitter);
             const isCore = isAngularCorePackage(this.inputProgram);
             const resourceRegistry = new ResourceRegistry();
             const compilationMode = this.options.compilationMode === 'partial' ? CompilationMode.PARTIAL : CompilationMode.FULL;
@@ -38596,7 +38678,6 @@ Either add the @Injectable() decorator to '${provider.node.name
                 dtsTransforms,
                 exportReferenceGraph,
                 routeAnalyzer,
-                mwpScanner,
                 metaReader,
                 typeCheckScopeRegistry,
                 aliasingHost,
@@ -38984,7 +39065,9 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
     }
     function getTsSymbolDisplayInfo(tsLS, checker, symbol, kind, ownerName) {
         const decl = symbol.valueDeclaration;
-        if (decl === undefined || (!ts$1.isPropertyDeclaration(decl) && !ts$1.isMethodDeclaration(decl)) ||
+        if (decl === undefined ||
+            (!ts$1.isPropertyDeclaration(decl) && !ts$1.isMethodDeclaration(decl) &&
+                !isNamedClassDeclaration(decl)) ||
             !ts$1.isIdentifier(decl.name)) {
             return null;
         }
@@ -39084,7 +39167,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         const members = [];
         const apparentProps = typeChecker.getTypeAtLocation(clazz).getApparentProperties();
         for (const prop of apparentProps) {
-            if (ts$1.isMethodDeclaration(prop.valueDeclaration) && prop.valueDeclaration) {
+            if (prop.valueDeclaration && ts$1.isMethodDeclaration(prop.valueDeclaration)) {
                 members.push(prop.valueDeclaration);
             }
         }
@@ -40157,7 +40240,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         }
         visit(node) {
             const { start, end } = getSpanIncludingEndTag(node);
-            if (!isWithin(this.position, { start, end })) {
+            if (end !== null && !isWithin(this.position, { start, end })) {
                 return;
             }
             const last = this.path[this.path.length - 1];
@@ -40291,8 +40374,15 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         // the end of the closing tag. Otherwise, for situation like
         // <my-component></my-comp¦onent> where the cursor is in the closing tag
         // we will not be able to return any information.
-        if ((ast instanceof Element || ast instanceof Template) && ast.endSourceSpan) {
-            result.end = ast.endSourceSpan.end.offset;
+        if (ast instanceof Element || ast instanceof Template) {
+            if (ast.endSourceSpan) {
+                result.end = ast.endSourceSpan.end.offset;
+            }
+            else if (ast.children.length > 0) {
+                // If the AST has children but no end source span, then it is an unclosed element with an end
+                // that should be the end of the last child.
+                result.end = getSpanIncludingEndTag(ast.children[ast.children.length - 1]).end;
+            }
         }
         return result;
     }
@@ -40361,9 +40451,9 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         /**
          * Analogue for `ts.LanguageService.getCompletionEntryDetails`.
          */
-        getCompletionEntryDetails(entryName, formatOptions, preferences) {
+        getCompletionEntryDetails(entryName, formatOptions, preferences, data) {
             if (this.isPropertyExpressionCompletion()) {
-                return this.getPropertyExpressionCompletionDetails(entryName, formatOptions, preferences);
+                return this.getPropertyExpressionCompletionDetails(entryName, formatOptions, preferences, data);
             }
             else if (this.isElementTagCompletion()) {
                 return this.getElementTagCompletionDetails(entryName);
@@ -40431,12 +40521,11 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         /**
          * Get the details of a specific completion for a property expression.
          */
-        getPropertyExpressionCompletionDetails(entryName, formatOptions, preferences) {
+        getPropertyExpressionCompletionDetails(entryName, formatOptions, preferences, data) {
             let details = undefined;
             if (this.node instanceof EmptyExpr || this.node instanceof BoundEvent ||
                 this.node.receiver instanceof ImplicitReceiver) {
-                details =
-                    this.getGlobalPropertyExpressionCompletionDetails(entryName, formatOptions, preferences);
+                details = this.getGlobalPropertyExpressionCompletionDetails(entryName, formatOptions, preferences, data);
             }
             else {
                 const location = this.compiler.getTemplateTypeChecker().getExpressionCompletionLocation(this.node, this.component);
@@ -40444,7 +40533,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                     return undefined;
                 }
                 details = this.tsLS.getCompletionEntryDetails(location.shimPath, location.positionInShimFile, entryName, formatOptions, 
-                /* source */ undefined, preferences);
+                /* source */ undefined, preferences, data);
             }
             if (details !== undefined) {
                 details.displayParts = filterAliasImports(details.displayParts);
@@ -40530,7 +40619,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
          * Get the details of a specific completion for a property expression in a global context (e.g.
          * `{{y|}}`).
          */
-        getGlobalPropertyExpressionCompletionDetails(entryName, formatOptions, preferences) {
+        getGlobalPropertyExpressionCompletionDetails(entryName, formatOptions, preferences, data) {
             const completions = this.templateTypeChecker.getGlobalCompletions(this.template, this.component, this.node);
             if (completions === null) {
                 return undefined;
@@ -40555,7 +40644,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             }
             else {
                 return this.tsLS.getCompletionEntryDetails(componentContext.shimPath, componentContext.positionInShimFile, entryName, formatOptions, 
-                /* source */ undefined, preferences);
+                /* source */ undefined, preferences, data);
             }
         }
         /**
@@ -40769,14 +40858,24 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                     displayParts = info.displayParts;
                     documentation = info.documentation;
                     break;
+                case AttributeCompletionKind.StructuralDirectiveAttribute:
                 case AttributeCompletionKind.DirectiveInput:
                 case AttributeCompletionKind.DirectiveOutput:
                     const propertySymbol = getAttributeCompletionSymbol(completion, this.typeChecker);
                     if (propertySymbol === null) {
                         return undefined;
                     }
-                    info = getTsSymbolDisplayInfo(this.tsLS, this.typeChecker, propertySymbol, completion.kind === AttributeCompletionKind.DirectiveInput ? DisplayInfoKind.PROPERTY :
-                        DisplayInfoKind.EVENT, completion.directive.tsSymbol.name);
+                    let kind;
+                    if (completion.kind === AttributeCompletionKind.DirectiveInput) {
+                        kind = DisplayInfoKind.PROPERTY;
+                    }
+                    else if (completion.kind === AttributeCompletionKind.DirectiveOutput) {
+                        kind = DisplayInfoKind.EVENT;
+                    }
+                    else {
+                        kind = DisplayInfoKind.DIRECTIVE;
+                    }
+                    info = getTsSymbolDisplayInfo(this.tsLS, this.typeChecker, propertySymbol, kind, completion.directive.tsSymbol.name);
                     if (info === null) {
                         return undefined;
                     }
@@ -40787,7 +40886,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 name: entryName,
                 kind: unsafeCastDisplayInfoKindToScriptElementKind(kind),
                 kindModifiers: ts$1.ScriptElementKindModifier.none,
-                displayParts: [],
+                displayParts,
                 documentation,
             };
         }
@@ -40920,6 +41019,240 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         }
     }
 
+    /**
+     * @license
+     * Copyright Google LLC All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    /**
+     * Converts a `ShimLocation` to a more genericly named `FilePosition`.
+     */
+    function toFilePosition(shimLocation) {
+        return { fileName: shimLocation.shimPath, position: shimLocation.positionInShimFile };
+    }
+    /**
+     * Takes a position in a template and finds equivalent targets in TS files as well as details about
+     * the targeted template node.
+     */
+    function getTargetDetailsAtTemplatePosition({ template, component }, position, templateTypeChecker) {
+        // Find the AST node in the template at the position.
+        const positionDetails = getTargetAtPosition(template, position);
+        if (positionDetails === null) {
+            return null;
+        }
+        const nodes = positionDetails.context.kind === TargetNodeKind.TwoWayBindingContext ?
+            positionDetails.context.nodes :
+            [positionDetails.context.node];
+        const details = [];
+        for (const node of nodes) {
+            // Get the information about the TCB at the template position.
+            const symbol = templateTypeChecker.getSymbolOfNode(node, component);
+            if (symbol === null) {
+                continue;
+            }
+            const templateTarget = node;
+            switch (symbol.kind) {
+                case SymbolKind.Directive:
+                case SymbolKind.Template:
+                    // References to elements, templates, and directives will be through template references
+                    // (#ref). They shouldn't be used directly for a Language Service reference request.
+                    break;
+                case SymbolKind.Element: {
+                    const matches = getDirectiveMatchesForElementTag(symbol.templateNode, symbol.directives);
+                    details.push({
+                        typescriptLocations: getPositionsForDirectives(matches),
+                        templateTarget,
+                        symbol,
+                    });
+                    break;
+                }
+                case SymbolKind.DomBinding: {
+                    // Dom bindings aren't currently type-checked (see `checkTypeOfDomBindings`) so they don't
+                    // have a shim location. This means we can't match dom bindings to their lib.dom
+                    // reference, but we can still see if they match to a directive.
+                    if (!(node instanceof TextAttribute) && !(node instanceof BoundAttribute)) {
+                        return null;
+                    }
+                    const directives = getDirectiveMatchesForAttribute(node.name, symbol.host.templateNode, symbol.host.directives);
+                    details.push({
+                        typescriptLocations: getPositionsForDirectives(directives),
+                        templateTarget,
+                        symbol,
+                    });
+                    break;
+                }
+                case SymbolKind.Reference: {
+                    details.push({
+                        typescriptLocations: [toFilePosition(symbol.referenceVarLocation)],
+                        templateTarget,
+                        symbol,
+                    });
+                    break;
+                }
+                case SymbolKind.Variable: {
+                    if ((templateTarget instanceof Variable)) {
+                        if (templateTarget.valueSpan !== undefined &&
+                            isWithin(position, templateTarget.valueSpan)) {
+                            // In the valueSpan of the variable, we want to get the reference of the initializer.
+                            details.push({
+                                typescriptLocations: [toFilePosition(symbol.initializerLocation)],
+                                templateTarget,
+                                symbol,
+                            });
+                        }
+                        else if (isWithin(position, templateTarget.keySpan)) {
+                            // In the keySpan of the variable, we want to get the reference of the local variable.
+                            details.push({
+                                typescriptLocations: [toFilePosition(symbol.localVarLocation)],
+                                templateTarget,
+                                symbol,
+                            });
+                        }
+                    }
+                    else {
+                        // If the templateNode is not the `TmplAstVariable`, it must be a usage of the
+                        // variable somewhere in the template.
+                        details.push({
+                            typescriptLocations: [toFilePosition(symbol.localVarLocation)],
+                            templateTarget,
+                            symbol,
+                        });
+                    }
+                    break;
+                }
+                case SymbolKind.Input:
+                case SymbolKind.Output: {
+                    details.push({
+                        typescriptLocations: symbol.bindings.map(binding => toFilePosition(binding.shimLocation)),
+                        templateTarget,
+                        symbol,
+                    });
+                    break;
+                }
+                case SymbolKind.Pipe:
+                case SymbolKind.Expression: {
+                    details.push({
+                        typescriptLocations: [toFilePosition(symbol.shimLocation)],
+                        templateTarget,
+                        symbol,
+                    });
+                    break;
+                }
+            }
+        }
+        return details.length > 0 ? details : null;
+    }
+    /**
+     * Given a set of `DirectiveSymbol`s, finds the equivalent `FilePosition` of the class declaration.
+     */
+    function getPositionsForDirectives(directives) {
+        const allDirectives = [];
+        for (const dir of directives.values()) {
+            const dirClass = dir.tsSymbol.valueDeclaration;
+            if (dirClass === undefined || !ts$1.isClassDeclaration(dirClass) || dirClass.name === undefined) {
+                continue;
+            }
+            const { fileName } = dirClass.getSourceFile();
+            const position = dirClass.name.getStart();
+            allDirectives.push({ fileName, position });
+        }
+        return allDirectives;
+    }
+    /**
+     * Creates a "key" for a rename/reference location by concatenating file name, span start, and span
+     * length. This allows us to de-duplicate template results when an item may appear several times
+     * in the TCB but map back to the same template location.
+     */
+    function createLocationKey(ds) {
+        return ds.fileName + ds.textSpan.start + ds.textSpan.length;
+    }
+    /**
+     * Converts a given `ts.DocumentSpan` in a shim file to its equivalent `ts.DocumentSpan` in the
+     * template.
+     *
+     * You can optionally provide a `requiredNodeText` that ensures the equivalent template node's text
+     * matches. If it does not, this function will return `null`.
+     */
+    function convertToTemplateDocumentSpan(shimDocumentSpan, templateTypeChecker, program, requiredNodeText) {
+        const sf = program.getSourceFile(shimDocumentSpan.fileName);
+        if (sf === undefined) {
+            return null;
+        }
+        const tcbNode = findTightestNode(sf, shimDocumentSpan.textSpan.start);
+        if (tcbNode === undefined ||
+            hasExpressionIdentifier(sf, tcbNode, ExpressionIdentifier.EVENT_PARAMETER)) {
+            // If the reference result is the $event parameter in the subscribe/addEventListener
+            // function in the TCB, we want to filter this result out of the references. We really only
+            // want to return references to the parameter in the template itself.
+            return null;
+        }
+        // TODO(atscott): Determine how to consistently resolve paths. i.e. with the project
+        // serverHost or LSParseConfigHost in the adapter. We should have a better defined way to
+        // normalize paths.
+        const mapping = getTemplateLocationFromShimLocation(templateTypeChecker, absoluteFrom(shimDocumentSpan.fileName), shimDocumentSpan.textSpan.start);
+        if (mapping === null) {
+            return null;
+        }
+        const { span, templateUrl } = mapping;
+        if (requiredNodeText !== undefined && span.toString() !== requiredNodeText) {
+            return null;
+        }
+        return Object.assign(Object.assign({}, shimDocumentSpan), { fileName: templateUrl, textSpan: toTextSpan(span), 
+            // Specifically clear other text span values because we do not have enough knowledge to
+            // convert these to spans in the template.
+            contextSpan: undefined, originalContextSpan: undefined, originalTextSpan: undefined });
+    }
+    /**
+     * Finds the text and `ts.TextSpan` for the node at a position in a template.
+     */
+    function getRenameTextAndSpanAtPosition(node, position) {
+        if (node instanceof BoundAttribute || node instanceof TextAttribute ||
+            node instanceof BoundEvent) {
+            if (node.keySpan === undefined) {
+                return null;
+            }
+            return { text: node.name, span: toTextSpan(node.keySpan) };
+        }
+        else if (node instanceof Variable || node instanceof Reference) {
+            if (isWithin(position, node.keySpan)) {
+                return { text: node.keySpan.toString(), span: toTextSpan(node.keySpan) };
+            }
+            else if (node.valueSpan && isWithin(position, node.valueSpan)) {
+                return { text: node.valueSpan.toString(), span: toTextSpan(node.valueSpan) };
+            }
+        }
+        if (node instanceof PropertyRead || node instanceof MethodCall || node instanceof PropertyWrite ||
+            node instanceof SafePropertyRead || node instanceof SafeMethodCall ||
+            node instanceof BindingPipe) {
+            return { text: node.name, span: toTextSpan(node.nameSpan) };
+        }
+        else if (node instanceof LiteralPrimitive) {
+            const span = toTextSpan(node.sourceSpan);
+            const text = node.value;
+            if (typeof text === 'string') {
+                // The span of a string literal includes the quotes but they should be removed for renaming.
+                span.start += 1;
+                span.length -= 2;
+            }
+            return { text, span };
+        }
+        return null;
+    }
+    /**
+     * Retrives the `PipeMeta` or `DirectiveMeta` of the given `ts.Node`'s parent class.
+     *
+     * Returns `null` if the node has no parent class or there is no meta associated with the class.
+     */
+    function getParentClassMeta(requestNode, compiler) {
+        const parentClass = getParentClassDeclaration(requestNode);
+        if (parentClass === undefined) {
+            return null;
+        }
+        return compiler.getMeta(parentClass);
+    }
+
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -40928,9 +41261,11 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
      * found in the LICENSE file at https://angular.io/license
      */
     class DefinitionBuilder {
-        constructor(tsLS, compiler) {
+        constructor(tsLS, compiler, driver) {
             this.tsLS = tsLS;
             this.compiler = compiler;
+            this.driver = driver;
+            this.ttc = this.compiler.getTemplateTypeChecker();
         }
         getDefinitionAndBoundSpan(fileName, position) {
             var _a;
@@ -41025,11 +41360,34 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         }
         getDefinitionsForSymbols(...symbols) {
             return flatMap(symbols, ({ shimLocation }) => {
-                var _a;
                 const { shimPath, positionInShimFile } = shimLocation;
-                return (_a = this.tsLS.getDefinitionAtPosition(shimPath, positionInShimFile)) !== null && _a !== void 0 ? _a : [];
+                const definitionInfos = this.tsLS.getDefinitionAtPosition(shimPath, positionInShimFile);
+                if (definitionInfos === undefined) {
+                    return [];
+                }
+                return this.mapShimResultsToTemplates(definitionInfos);
             });
         }
+        /**
+         * Converts and definition info result that points to a template typecheck file to a reference to
+         * the corresponding location in the template.
+         */
+        mapShimResultsToTemplates(definitionInfos) {
+            const result = [];
+            for (const info of definitionInfos) {
+                if (this.ttc.isTrackedTypeCheckFile(absoluteFrom(info.fileName))) {
+                    const templateDefinitionInfo = convertToTemplateDocumentSpan(info, this.ttc, this.driver.getProgram());
+                    if (templateDefinitionInfo === null) {
+                        continue;
+                    }
+                    result.push(templateDefinitionInfo);
+                }
+                else {
+                    result.push(info);
+                }
+            }
+            return result;
+        }
         getTypeDefinitionsAtPosition(fileName, position) {
             const templateInfo = getTemplateInfoAtPosition(fileName, position, this.compiler);
             if (templateInfo === undefined) {
@@ -41380,240 +41738,6 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         };
     }
 
-    /**
-     * @license
-     * Copyright Google LLC All Rights Reserved.
-     *
-     * Use of this source code is governed by an MIT-style license that can be
-     * found in the LICENSE file at https://angular.io/license
-     */
-    /**
-     * Converts a `ShimLocation` to a more genericly named `FilePosition`.
-     */
-    function toFilePosition(shimLocation) {
-        return { fileName: shimLocation.shimPath, position: shimLocation.positionInShimFile };
-    }
-    /**
-     * Takes a position in a template and finds equivalent targets in TS files as well as details about
-     * the targeted template node.
-     */
-    function getTargetDetailsAtTemplatePosition({ template, component }, position, templateTypeChecker) {
-        // Find the AST node in the template at the position.
-        const positionDetails = getTargetAtPosition(template, position);
-        if (positionDetails === null) {
-            return null;
-        }
-        const nodes = positionDetails.context.kind === TargetNodeKind.TwoWayBindingContext ?
-            positionDetails.context.nodes :
-            [positionDetails.context.node];
-        const details = [];
-        for (const node of nodes) {
-            // Get the information about the TCB at the template position.
-            const symbol = templateTypeChecker.getSymbolOfNode(node, component);
-            if (symbol === null) {
-                continue;
-            }
-            const templateTarget = node;
-            switch (symbol.kind) {
-                case SymbolKind.Directive:
-                case SymbolKind.Template:
-                    // References to elements, templates, and directives will be through template references
-                    // (#ref). They shouldn't be used directly for a Language Service reference request.
-                    break;
-                case SymbolKind.Element: {
-                    const matches = getDirectiveMatchesForElementTag(symbol.templateNode, symbol.directives);
-                    details.push({
-                        typescriptLocations: getPositionsForDirectives(matches),
-                        templateTarget,
-                        symbol,
-                    });
-                    break;
-                }
-                case SymbolKind.DomBinding: {
-                    // Dom bindings aren't currently type-checked (see `checkTypeOfDomBindings`) so they don't
-                    // have a shim location. This means we can't match dom bindings to their lib.dom
-                    // reference, but we can still see if they match to a directive.
-                    if (!(node instanceof TextAttribute) && !(node instanceof BoundAttribute)) {
-                        return null;
-                    }
-                    const directives = getDirectiveMatchesForAttribute(node.name, symbol.host.templateNode, symbol.host.directives);
-                    details.push({
-                        typescriptLocations: getPositionsForDirectives(directives),
-                        templateTarget,
-                        symbol,
-                    });
-                    break;
-                }
-                case SymbolKind.Reference: {
-                    details.push({
-                        typescriptLocations: [toFilePosition(symbol.referenceVarLocation)],
-                        templateTarget,
-                        symbol,
-                    });
-                    break;
-                }
-                case SymbolKind.Variable: {
-                    if ((templateTarget instanceof Variable)) {
-                        if (templateTarget.valueSpan !== undefined &&
-                            isWithin(position, templateTarget.valueSpan)) {
-                            // In the valueSpan of the variable, we want to get the reference of the initializer.
-                            details.push({
-                                typescriptLocations: [toFilePosition(symbol.initializerLocation)],
-                                templateTarget,
-                                symbol,
-                            });
-                        }
-                        else if (isWithin(position, templateTarget.keySpan)) {
-                            // In the keySpan of the variable, we want to get the reference of the local variable.
-                            details.push({
-                                typescriptLocations: [toFilePosition(symbol.localVarLocation)],
-                                templateTarget,
-                                symbol,
-                            });
-                        }
-                    }
-                    else {
-                        // If the templateNode is not the `TmplAstVariable`, it must be a usage of the
-                        // variable somewhere in the template.
-                        details.push({
-                            typescriptLocations: [toFilePosition(symbol.localVarLocation)],
-                            templateTarget,
-                            symbol,
-                        });
-                    }
-                    break;
-                }
-                case SymbolKind.Input:
-                case SymbolKind.Output: {
-                    details.push({
-                        typescriptLocations: symbol.bindings.map(binding => toFilePosition(binding.shimLocation)),
-                        templateTarget,
-                        symbol,
-                    });
-                    break;
-                }
-                case SymbolKind.Pipe:
-                case SymbolKind.Expression: {
-                    details.push({
-                        typescriptLocations: [toFilePosition(symbol.shimLocation)],
-                        templateTarget,
-                        symbol,
-                    });
-                    break;
-                }
-            }
-        }
-        return details.length > 0 ? details : null;
-    }
-    /**
-     * Given a set of `DirectiveSymbol`s, finds the equivalent `FilePosition` of the class declaration.
-     */
-    function getPositionsForDirectives(directives) {
-        const allDirectives = [];
-        for (const dir of directives.values()) {
-            const dirClass = dir.tsSymbol.valueDeclaration;
-            if (dirClass === undefined || !ts$1.isClassDeclaration(dirClass) || dirClass.name === undefined) {
-                continue;
-            }
-            const { fileName } = dirClass.getSourceFile();
-            const position = dirClass.name.getStart();
-            allDirectives.push({ fileName, position });
-        }
-        return allDirectives;
-    }
-    /**
-     * Creates a "key" for a rename/reference location by concatenating file name, span start, and span
-     * length. This allows us to de-duplicate template results when an item may appear several times
-     * in the TCB but map back to the same template location.
-     */
-    function createLocationKey(ds) {
-        return ds.fileName + ds.textSpan.start + ds.textSpan.length;
-    }
-    /**
-     * Converts a given `ts.DocumentSpan` in a shim file to its equivalent `ts.DocumentSpan` in the
-     * template.
-     *
-     * You can optionally provide a `requiredNodeText` that ensures the equivalent template node's text
-     * matches. If it does not, this function will return `null`.
-     */
-    function convertToTemplateDocumentSpan(shimDocumentSpan, templateTypeChecker, program, requiredNodeText) {
-        const sf = program.getSourceFile(shimDocumentSpan.fileName);
-        if (sf === undefined) {
-            return null;
-        }
-        const tcbNode = findTightestNode(sf, shimDocumentSpan.textSpan.start);
-        if (tcbNode === undefined ||
-            hasExpressionIdentifier(sf, tcbNode, ExpressionIdentifier.EVENT_PARAMETER)) {
-            // If the reference result is the $event parameter in the subscribe/addEventListener
-            // function in the TCB, we want to filter this result out of the references. We really only
-            // want to return references to the parameter in the template itself.
-            return null;
-        }
-        // TODO(atscott): Determine how to consistently resolve paths. i.e. with the project
-        // serverHost or LSParseConfigHost in the adapter. We should have a better defined way to
-        // normalize paths.
-        const mapping = getTemplateLocationFromShimLocation(templateTypeChecker, absoluteFrom(shimDocumentSpan.fileName), shimDocumentSpan.textSpan.start);
-        if (mapping === null) {
-            return null;
-        }
-        const { span, templateUrl } = mapping;
-        if (requiredNodeText !== undefined && span.toString() !== requiredNodeText) {
-            return null;
-        }
-        return Object.assign(Object.assign({}, shimDocumentSpan), { fileName: templateUrl, textSpan: toTextSpan(span), 
-            // Specifically clear other text span values because we do not have enough knowledge to
-            // convert these to spans in the template.
-            contextSpan: undefined, originalContextSpan: undefined, originalTextSpan: undefined });
-    }
-    /**
-     * Finds the text and `ts.TextSpan` for the node at a position in a template.
-     */
-    function getRenameTextAndSpanAtPosition(node, position) {
-        if (node instanceof BoundAttribute || node instanceof TextAttribute ||
-            node instanceof BoundEvent) {
-            if (node.keySpan === undefined) {
-                return null;
-            }
-            return { text: node.name, span: toTextSpan(node.keySpan) };
-        }
-        else if (node instanceof Variable || node instanceof Reference) {
-            if (isWithin(position, node.keySpan)) {
-                return { text: node.keySpan.toString(), span: toTextSpan(node.keySpan) };
-            }
-            else if (node.valueSpan && isWithin(position, node.valueSpan)) {
-                return { text: node.valueSpan.toString(), span: toTextSpan(node.valueSpan) };
-            }
-        }
-        if (node instanceof PropertyRead || node instanceof MethodCall || node instanceof PropertyWrite ||
-            node instanceof SafePropertyRead || node instanceof SafeMethodCall ||
-            node instanceof BindingPipe) {
-            return { text: node.name, span: toTextSpan(node.nameSpan) };
-        }
-        else if (node instanceof LiteralPrimitive) {
-            const span = toTextSpan(node.sourceSpan);
-            const text = node.value;
-            if (typeof text === 'string') {
-                // The span of a string literal includes the quotes but they should be removed for renaming.
-                span.start += 1;
-                span.length -= 2;
-            }
-            return { text, span };
-        }
-        return null;
-    }
-    /**
-     * Retrives the `PipeMeta` or `DirectiveMeta` of the given `ts.Node`'s parent class.
-     *
-     * Returns `null` if the node has no parent class or there is no meta associated with the class.
-     */
-    function getParentClassMeta(requestNode, compiler) {
-        const parentClass = getParentClassDeclaration(requestNode);
-        if (parentClass === undefined) {
-            return null;
-        }
-        return compiler.getMeta(parentClass);
-    }
-
     class ReferencesBuilder {
         constructor(driver, tsLS, compiler) {
             this.driver = driver;
@@ -41689,7 +41813,30 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 // We could not get a template at position so we assume the request came from outside the
                 // template.
                 if (templateInfo === undefined) {
-                    return this.tsLS.getRenameInfo(filePath, position);
+                    const renameRequest = this.buildRenameRequestAtTypescriptPosition(filePath, position);
+                    if (renameRequest === null) {
+                        return {
+                            canRename: false,
+                            localizedErrorMessage: 'Could not determine rename info at typescript position.',
+                        };
+                    }
+                    if (renameRequest.type === RequestKind.PipeName) {
+                        const pipeName = renameRequest.pipeNameExpr.text;
+                        return {
+                            canRename: true,
+                            displayName: pipeName,
+                            fullDisplayName: pipeName,
+                            triggerSpan: {
+                                length: pipeName.length,
+                                // Offset the pipe name by 1 to account for start of string '/`/"
+                                start: renameRequest.pipeNameExpr.getStart() + 1,
+                            },
+                        };
+                    }
+                    else {
+                        // TODO(atscott): Add support for other special indirect renames from typescript files.
+                        return this.tsLS.getRenameInfo(filePath, position);
+                    }
                 }
                 const allTargetDetails = getTargetDetailsAtTemplatePosition(templateInfo, position, this.ttc);
                 if (allTargetDetails === null) {
@@ -42088,7 +42235,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 if (!isInAngularContext(compiler.getCurrentProgram(), fileName, position)) {
                     return undefined;
                 }
-                return new DefinitionBuilder(this.tsLS, compiler)
+                return new DefinitionBuilder(this.tsLS, compiler, this.programDriver)
                     .getDefinitionAndBoundSpan(fileName, position);
             });
         }
@@ -42097,7 +42244,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 if (!isTemplateContext(compiler.getCurrentProgram(), fileName, position)) {
                     return undefined;
                 }
-                return new DefinitionBuilder(this.tsLS, compiler)
+                return new DefinitionBuilder(this.tsLS, compiler, this.programDriver)
                     .getTypeDefinitionsAtPosition(fileName, position);
             });
         }
@@ -42185,7 +42332,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             }
             return builder.getCompletionsAtPosition(options);
         }
-        getCompletionEntryDetails(fileName, position, entryName, formatOptions, preferences) {
+        getCompletionEntryDetails(fileName, position, entryName, formatOptions, preferences, data) {
             return this.withCompilerAndPerfTracing(PerfPhase.LsCompletions, (compiler) => {
                 if (!isTemplateContext(compiler.getCurrentProgram(), fileName, position)) {
                     return undefined;
@@ -42194,7 +42341,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 if (builder === null) {
                     return undefined;
                 }
-                return builder.getCompletionEntryDetails(entryName, formatOptions, preferences);
+                return builder.getCompletionEntryDetails(entryName, formatOptions, preferences, data);
             });
         }
         getSignatureHelpItems(fileName, position, options) {
@@ -42541,14 +42688,14 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 return (_a = tsLS.getCompletionsAtPosition(fileName, position, options)) !== null && _a !== void 0 ? _a : ngLS.getCompletionsAtPosition(fileName, position, options);
             }
         }
-        function getCompletionEntryDetails(fileName, position, entryName, formatOptions, source, preferences) {
+        function getCompletionEntryDetails(fileName, position, entryName, formatOptions, source, preferences, data) {
             var _a;
             if (angularOnly) {
-                return ngLS.getCompletionEntryDetails(fileName, position, entryName, formatOptions, preferences);
+                return ngLS.getCompletionEntryDetails(fileName, position, entryName, formatOptions, preferences, data);
             }
             else {
                 // If TS could answer the query, then return that result. Otherwise, return from Angular LS.
-                return (_a = tsLS.getCompletionEntryDetails(fileName, position, entryName, formatOptions, source, preferences)) !== null && _a !== void 0 ? _a : ngLS.getCompletionEntryDetails(fileName, position, entryName, formatOptions, preferences);
+                return (_a = tsLS.getCompletionEntryDetails(fileName, position, entryName, formatOptions, source, preferences, data)) !== null && _a !== void 0 ? _a : ngLS.getCompletionEntryDetails(fileName, position, entryName, formatOptions, preferences, data);
             }
         }
         function getCompletionEntrySymbol(fileName, position, name, source) {