@angular/language-service 12.2.2 → 12.2.6

package/bundles/ivy.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v12.2.2
+ * @license Angular v12.2.6
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -19938,7 +19938,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.2.2');
+    const VERSION$1 = new Version('12.2.6');
 
     /**
      * @license
@@ -20577,7 +20577,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.2.2'));
+        definitionMap.set('version', literal('12.2.6'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', metadata.type);
         definitionMap.set('decorators', metadata.decorators);
@@ -20617,7 +20617,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.2.2'));
+        definitionMap.set('version', literal('12.2.6'));
         // e.g. `type: MyDirective`
         definitionMap.set('type', meta.internalType);
         // e.g. `selector: 'some-dir'`
@@ -20834,7 +20834,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.2.2'));
+        definitionMap.set('version', literal('12.2.6'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         definitionMap.set('deps', compileDependencies(meta.deps));
@@ -20876,7 +20876,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.2.2'));
+        definitionMap.set('version', literal('12.2.6'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         // Only generate providedIn property if it has a non-null value
@@ -20955,7 +20955,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.2.2'));
+        definitionMap.set('version', literal('12.2.6'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         definitionMap.set('providers', meta.providers);
@@ -20992,7 +20992,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.2.2'));
+        definitionMap.set('version', literal('12.2.6'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         // We only generate the keys in the metadata if the arrays contain values.
@@ -21050,7 +21050,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.2.2'));
+        definitionMap.set('version', literal('12.2.6'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         // e.g. `type: MyPipe`
         definitionMap.set('type', meta.internalType);
@@ -21082,7 +21082,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.2.2');
+    const VERSION$2 = new Version('12.2.6');
 
     /**
      * @license
@@ -21294,6 +21294,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
          * ```
          */
         ErrorCode[ErrorCode["INVALID_BANANA_IN_BOX"] = 8101] = "INVALID_BANANA_IN_BOX";
+        /**
+         * The left side of a nullish coalescing operation is not nullable.
+         *
+         * ```
+         * {{ foo ?? bar }}
+         * ```
+         * When the type of foo doesn't include `null` or `undefined`.
+         */
+        ErrorCode[ErrorCode["NULLISH_COALESCING_NOT_NULLABLE"] = 8102] = "NULLISH_COALESCING_NOT_NULLABLE";
         /**
          * The template type-checking engine would need to generate an inline type check block for a
          * component, but the current type-checking environment doesn't support it.
@@ -26546,6 +26555,26 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 }
             }
         }
+        extendedTemplateCheck(sf, extendedTemplateChecker) {
+            const classes = this.fileToClasses.get(sf);
+            if (classes === undefined) {
+                return [];
+            }
+            const diagnostics = [];
+            for (const clazz of classes) {
+                if (!isNamedClassDeclaration(clazz)) {
+                    continue;
+                }
+                const record = this.classes.get(clazz);
+                for (const trait of record.traits) {
+                    if (trait.handler.extendedTemplateCheck === undefined) {
+                        continue;
+                    }
+                    diagnostics.push(...trait.handler.extendedTemplateCheck(clazz, extendedTemplateChecker));
+                }
+            }
+            return diagnostics;
+        }
         index(ctx) {
             for (const clazz of this.classes.keys()) {
                 const record = this.classes.get(clazz);
@@ -30553,6 +30582,9 @@ Either add the @Injectable() decorator to '${provider.node.name
             const binder = new R3TargetBinder(scope.matcher);
             ctx.addTemplate(new Reference$1(node), binder, meta.template.diagNodes, scope.pipes, scope.schemas, meta.template.sourceMapping, meta.template.file, meta.template.errors);
         }
+        extendedTemplateCheck(component, extendedTemplateChecker) {
+            return extendedTemplateChecker.getDiagnosticsForComponent(component);
+        }
         resolve(node, analysis, symbol) {
             if (this.semanticDepGraphUpdater !== null && analysis.baseClass instanceof Reference$1) {
                 symbol.baseClass = this.semanticDepGraphUpdater.getSymbol(analysis.baseClass.node);
@@ -39731,7 +39763,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             const fileRecord = this.state.get(sfPath);
             const templateId = fileRecord.sourceManager.getTemplateId(clazz);
             const mapping = fileRecord.sourceManager.getSourceMapping(templateId);
-            return makeTemplateDiagnostic(templateId, mapping, sourceSpan, category, errorCode, message, relatedInformation);
+            return Object.assign(Object.assign({}, makeTemplateDiagnostic(templateId, mapping, sourceSpan, category, ngErrorCode(errorCode), message, relatedInformation)), { __ngCode: errorCode });
         }
         getOrCreateCompletionEngine(component) {
             if (this.completionCache.has(component)) {
@@ -40093,6 +40125,195 @@ Either add the @Injectable() decorator to '${provider.node.name
         }
     }
 
+    /**
+     * @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 ExtendedTemplateCheckerImpl {
+        constructor(templateTypeChecker, typeChecker, templateChecks) {
+            this.templateChecks = templateChecks;
+            this.ctx = { templateTypeChecker: templateTypeChecker, typeChecker: typeChecker };
+        }
+        getDiagnosticsForComponent(component) {
+            const template = this.ctx.templateTypeChecker.getTemplate(component);
+            // Skip checks if component has no template. This can happen if the user writes a
+            // `@Component()` but doesn't add the template, could happen in the language service
+            // when users are in the middle of typing code.
+            if (template === null) {
+                return [];
+            }
+            const diagnostics = [];
+            for (const check of this.templateChecks) {
+                diagnostics.push(...check.run(this.ctx, component, template));
+            }
+            return diagnostics;
+        }
+    }
+
+    /**
+     * @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
+     */
+    /**
+     * This abstract class provides a base implementation for the run method.
+     */
+    class TemplateCheckWithVisitor {
+        /**
+         * Base implementation for run function, visits all nodes in template and calls
+         * `visitNode()` for each one.
+         */
+        run(ctx, component, template) {
+            const visitor = new TemplateVisitor$1(ctx, component, this);
+            return visitor.getDiagnostics(template);
+        }
+    }
+    /**
+     * Visits all nodes in a template (TmplAstNode and AST) and calls `visitNode` for each one.
+     */
+    class TemplateVisitor$1 extends RecursiveAstVisitor {
+        constructor(ctx, component, check) {
+            super();
+            this.ctx = ctx;
+            this.component = component;
+            this.check = check;
+            this.diagnostics = [];
+        }
+        visit(node, context) {
+            this.diagnostics.push(...this.check.visitNode(this.ctx, this.component, node));
+            node.visit(this);
+        }
+        visitAllNodes(nodes) {
+            for (const node of nodes) {
+                this.visit(node);
+            }
+        }
+        visitAst(ast) {
+            if (ast instanceof ASTWithSource) {
+                ast = ast.ast;
+            }
+            this.visit(ast);
+        }
+        visitElement(element) {
+            this.visitAllNodes(element.attributes);
+            this.visitAllNodes(element.inputs);
+            this.visitAllNodes(element.outputs);
+            this.visitAllNodes(element.references);
+            this.visitAllNodes(element.children);
+        }
+        visitTemplate(template) {
+            this.visitAllNodes(template.attributes);
+            if (template.tagName === 'ng-template') {
+                // Only visit input/outputs/templateAttrs if this isn't an inline template node
+                // generated for a structural directive (like `<div *ngIf></div>`). These nodes
+                // would be visited when the underlying element of an inline template node is processed.
+                this.visitAllNodes(template.inputs);
+                this.visitAllNodes(template.outputs);
+                this.visitAllNodes(template.templateAttrs);
+            }
+            this.visitAllNodes(template.variables);
+            this.visitAllNodes(template.references);
+            this.visitAllNodes(template.children);
+        }
+        visitContent(content) { }
+        visitVariable(variable) { }
+        visitReference(reference) { }
+        visitTextAttribute(attribute) { }
+        visitBoundAttribute(attribute) {
+            this.visitAst(attribute.value);
+        }
+        visitBoundEvent(attribute) {
+            this.visitAst(attribute.handler);
+        }
+        visitText(text) { }
+        visitBoundText(text) {
+            this.visitAst(text.value);
+        }
+        visitIcu(icu) { }
+        getDiagnostics(template) {
+            this.diagnostics = [];
+            this.visitAllNodes(template);
+            return this.diagnostics;
+        }
+    }
+
+    /**
+     * @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
+     */
+    /**
+     * Ensures the two-way binding syntax is correct.
+     * Parentheses should be inside the brackets "[()]".
+     * Will return diagnostic information when "([])" is found.
+     */
+    class InvalidBananaInBoxCheck extends TemplateCheckWithVisitor {
+        constructor() {
+            super(...arguments);
+            this.code = ErrorCode.INVALID_BANANA_IN_BOX;
+        }
+        visitNode(ctx, component, node) {
+            if (!(node instanceof BoundEvent))
+                return [];
+            const name = node.name;
+            if (!name.startsWith('[') || !name.endsWith(']'))
+                return [];
+            const boundSyntax = node.sourceSpan.toString();
+            const expectedBoundSyntax = boundSyntax.replace(`(${name})`, `[(${name.slice(1, -1)})]`);
+            const diagnostic = ctx.templateTypeChecker.makeTemplateDiagnostic(component, node.sourceSpan, ts$1.DiagnosticCategory.Warning, ErrorCode.INVALID_BANANA_IN_BOX, `In the two-way binding syntax the parentheses should be inside the brackets, ex. '${expectedBoundSyntax}'. 
+        Find more at https://angular.io/guide/two-way-binding`);
+            return [diagnostic];
+        }
+    }
+
+    /**
+     * @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
+     */
+    /**
+     * Ensures the left side of a nullish coalescing operation is nullable.
+     * Returns diagnostics for the cases where the operator is useless.
+     * This check should only be use if `strictNullChecks` is enabled,
+     * otherwise it would produce inaccurate results.
+     */
+    class NullishCoalescingNotNullableCheck extends TemplateCheckWithVisitor {
+        constructor() {
+            super(...arguments);
+            this.code = ErrorCode.NULLISH_COALESCING_NOT_NULLABLE;
+        }
+        visitNode(ctx, component, node) {
+            if (!(node instanceof Binary) || node.operation !== '??')
+                return [];
+            const symbolLeft = ctx.templateTypeChecker.getSymbolOfNode(node.left, component);
+            if (symbolLeft.kind !== SymbolKind.Expression) {
+                return [];
+            }
+            const typeLeft = symbolLeft.tsType;
+            // If the left operand's type is different from its non-nullable self, then it must
+            // contain a null or undefined so this nullish coalescing operator is useful. No diagnostic to
+            // report.
+            if (typeLeft.getNonNullableType() !== typeLeft)
+                return [];
+            const symbol = ctx.templateTypeChecker.getSymbolOfNode(node, component);
+            if (symbol.kind !== SymbolKind.Expression) {
+                return [];
+            }
+            const span = ctx.templateTypeChecker.getTemplateMappingAtShimLocation(symbol.shimLocation).span;
+            const diagnostic = ctx.templateTypeChecker.makeTemplateDiagnostic(component, span, ts$1.DiagnosticCategory.Warning, ErrorCode.NULLISH_COALESCING_NOT_NULLABLE, `The left side of this nullish coalescing operation does not include 'null' or 'undefined' in its type, therefore the '??' operator can be safely removed.`);
+            return [diagnostic];
+        }
+    }
+
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -40209,6 +40430,10 @@ Either add the @Injectable() decorator to '${provider.node.name
              * with each fresh compilation.
              */
             this.delegatingPerfRecorder = new DelegatingPerfRecorder(this.perfRecorder);
+            if (this.options._extendedTemplateDiagnostics === true &&
+                this.options.strictTemplates === false) {
+                throw new Error('The \'_extendedTemplateDiagnostics\' option requires \'strictTemplates\' to also be enabled.');
+            }
             this.constructionDiagnostics.push(...this.adapter.constructionDiagnostics);
             const incompatibleTypeCheckOptionsDiagnostic = verifyCompatibleTypeCheckOptions(this.options);
             if (incompatibleTypeCheckOptionsDiagnostic !== null) {
@@ -40318,7 +40543,12 @@ Either add the @Injectable() decorator to '${provider.node.name
          * Get all Angular-related diagnostics for this compilation.
          */
         getDiagnostics() {
-            return this.addMessageTextDetails([...this.getNonTemplateDiagnostics(), ...this.getTemplateDiagnostics()]);
+            const diagnostics = [];
+            diagnostics.push(...this.getNonTemplateDiagnostics(), ...this.getTemplateDiagnostics());
+            if (this.options._extendedTemplateDiagnostics) {
+                diagnostics.push(...this.getExtendedTemplateDiagnostics());
+            }
+            return this.addMessageTextDetails(diagnostics);
         }
         /**
          * Get all Angular-related diagnostics for this compilation.
@@ -40326,10 +40556,26 @@ Either add the @Injectable() decorator to '${provider.node.name
          * If a `ts.SourceFile` is passed, only diagnostics related to that file are returned.
          */
         getDiagnosticsForFile(file, optimizeFor) {
-            return this.addMessageTextDetails([
-                ...this.getNonTemplateDiagnostics().filter(diag => diag.file === file),
-                ...this.getTemplateDiagnosticsForFile(file, optimizeFor)
-            ]);
+            const diagnostics = [];
+            diagnostics.push(...this.getNonTemplateDiagnostics().filter(diag => diag.file === file), ...this.getTemplateDiagnosticsForFile(file, optimizeFor));
+            if (this.options._extendedTemplateDiagnostics) {
+                diagnostics.push(...this.getExtendedTemplateDiagnostics(file));
+            }
+            return this.addMessageTextDetails(diagnostics);
+        }
+        /**
+         * Get all `ts.Diagnostic`s currently available that pertain to the given component.
+         */
+        getDiagnosticsForComponent(component) {
+            const compilation = this.ensureAnalyzed();
+            const ttc = compilation.templateTypeChecker;
+            const diagnostics = [];
+            diagnostics.push(...ttc.getDiagnosticsForComponent(component));
+            if (this.options._extendedTemplateDiagnostics) {
+                const extendedTemplateChecker = compilation.extendedTemplateChecker;
+                diagnostics.push(...extendedTemplateChecker.getDiagnosticsForComponent(component));
+            }
+            return this.addMessageTextDetails(diagnostics);
         }
         /**
          * Add Angular.io error guide links to diagnostics for this compilation.
@@ -40719,6 +40965,24 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             return this.nonTemplateDiagnostics;
         }
+        /**
+         * Calls the `extendedTemplateCheck` phase of the trait compiler
+         * @param sf optional parameter to get diagnostics for a certain file
+         *     or all files in the program if `sf` is undefined
+         * @returns generated extended template diagnostics
+         */
+        getExtendedTemplateDiagnostics(sf) {
+            const diagnostics = [];
+            const compilation = this.ensureAnalyzed();
+            const extendedTemplateChecker = compilation.extendedTemplateChecker;
+            if (sf !== undefined) {
+                return compilation.traitCompiler.extendedTemplateCheck(sf, extendedTemplateChecker);
+            }
+            for (const sf of this.inputProgram.getSourceFiles()) {
+                diagnostics.push(...compilation.traitCompiler.extendedTemplateCheck(sf, extendedTemplateChecker));
+            }
+            return diagnostics;
+        }
         makeCompilation() {
             const checker = this.inputProgram.getTypeChecker();
             const reflector = new TypeScriptReflectionHost(checker);
@@ -40832,6 +41096,11 @@ Either add the @Injectable() decorator to '${provider.node.name
                 this.currentProgram = program;
             });
             const templateTypeChecker = new TemplateTypeCheckerImpl(this.inputProgram, notifyingDriver, traitCompiler, this.getTypeCheckingConfig(), refEmitter, reflector, this.adapter, this.incrementalCompilation, scopeRegistry, typeCheckScopeRegistry, this.delegatingPerfRecorder);
+            const templateChecks = [new InvalidBananaInBoxCheck()];
+            if (this.options.strictNullChecks) {
+                templateChecks.push(new NullishCoalescingNotNullableCheck());
+            }
+            const extendedTemplateChecker = new ExtendedTemplateCheckerImpl(templateTypeChecker, checker, templateChecks);
             return {
                 isCore,
                 traitCompiler,
@@ -40846,6 +41115,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                 refEmitter,
                 templateTypeChecker,
                 resourceRegistry,
+                extendedTemplateChecker
             };
         }
     }
@@ -44409,7 +44679,6 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         }
         getSemanticDiagnostics(fileName) {
             return this.withCompilerAndPerfTracing(PerfPhase.LsDiagnostics, (compiler) => {
-                const ttc = compiler.getTemplateTypeChecker();
                 const diagnostics = [];
                 if (isTypeScriptFile(fileName)) {
                     const program = compiler.getCurrentProgram();
@@ -44445,7 +44714,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                     const components = compiler.getComponentsWithTemplateFile(fileName);
                     for (const component of components) {
                         if (ts.isClassDeclaration(component)) {
-                            diagnostics.push(...ttc.getDiagnosticsForComponent(component));
+                            diagnostics.push(...compiler.getDiagnosticsForComponent(component));
                         }
                     }
                 }

package/bundles/language-service.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v12.2.2
+ * @license Angular v12.2.6
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -21475,7 +21475,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
-    const VERSION$1 = new Version('12.2.2');
+    const VERSION$1 = new Version('12.2.6');
 
     /**
      * @license
@@ -32958,12 +32958,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     const ERROR_DEBUG_CONTEXT = 'ngDebugContext';
     const ERROR_ORIGINAL_ERROR = 'ngOriginalError';
     const ERROR_LOGGER = 'ngErrorLogger';
-    function wrappedError(message, originalError) {
-        const msg = `${message} caused by: ${originalError instanceof Error ? originalError.message : originalError}`;
-        const error = Error(msg);
-        error[ERROR_ORIGINAL_ERROR] = originalError;
-        return error;
-    }
 
     /**
      * @license
@@ -35794,7 +35788,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
         }
     }
     Injector.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
-    Injector.NULL = new NullInjector();
+    Injector.NULL = ( /* @__PURE__ */new NullInjector());
     /** @nocollapse */
     Injector.ɵprov = ɵɵdefineInjectable({
         token: Injector,
@@ -36316,864 +36310,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     const SWITCH_COMPILE_INJECTABLE__PRE_R3__ = render2CompileInjectable;
     const SWITCH_COMPILE_INJECTABLE = SWITCH_COMPILE_INJECTABLE__PRE_R3__;
 
-    /**
-     * @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
-     */
-    function findFirstClosedCycle(keys) {
-        const res = [];
-        for (let i = 0; i < keys.length; ++i) {
-            if (res.indexOf(keys[i]) > -1) {
-                res.push(keys[i]);
-                return res;
-            }
-            res.push(keys[i]);
-        }
-        return res;
-    }
-    function constructResolvingPath(keys) {
-        if (keys.length > 1) {
-            const reversed = findFirstClosedCycle(keys.slice().reverse());
-            const tokenStrs = reversed.map(k => stringify$1(k.token));
-            return ' (' + tokenStrs.join(' -> ') + ')';
-        }
-        return '';
-    }
-    function injectionError(injector, key, constructResolvingMessage, originalError) {
-        const keys = [key];
-        const errMsg = constructResolvingMessage(keys);
-        const error = (originalError ? wrappedError(errMsg, originalError) : Error(errMsg));
-        error.addKey = addKey;
-        error.keys = keys;
-        error.injectors = [injector];
-        error.constructResolvingMessage = constructResolvingMessage;
-        error[ERROR_ORIGINAL_ERROR] = originalError;
-        return error;
-    }
-    function addKey(injector, key) {
-        this.injectors.push(injector);
-        this.keys.push(key);
-        // Note: This updated message won't be reflected in the `.stack` property
-        this.message = this.constructResolvingMessage(this.keys);
-    }
-    /**
-     * Thrown when trying to retrieve a dependency by key from {@link Injector}, but the
-     * {@link Injector} does not have a {@link Provider} for the given key.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * class A {
-     *   constructor(b:B) {}
-     * }
-     *
-     * expect(() => Injector.resolveAndCreate([A])).toThrowError();
-     * ```
-     */
-    function noProviderError(injector, key) {
-        return injectionError(injector, key, function (keys) {
-            const first = stringify$1(keys[0].token);
-            return `No provider for ${first}!${constructResolvingPath(keys)}`;
-        });
-    }
-    /**
-     * Thrown when dependencies form a cycle.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * var injector = Injector.resolveAndCreate([
-     *   {provide: "one", useFactory: (two) => "two", deps: [[new Inject("two")]]},
-     *   {provide: "two", useFactory: (one) => "one", deps: [[new Inject("one")]]}
-     * ]);
-     *
-     * expect(() => injector.get("one")).toThrowError();
-     * ```
-     *
-     * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.
-     */
-    function cyclicDependencyError(injector, key) {
-        return injectionError(injector, key, function (keys) {
-            return `Cannot instantiate cyclic dependency!${constructResolvingPath(keys)}`;
-        });
-    }
-    /**
-     * Thrown when a constructing type returns with an Error.
-     *
-     * The `InstantiationError` class contains the original error plus the dependency graph which caused
-     * this object to be instantiated.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * class A {
-     *   constructor() {
-     *     throw new Error('message');
-     *   }
-     * }
-     *
-     * var injector = Injector.resolveAndCreate([A]);
-
-     * try {
-     *   injector.get(A);
-     * } catch (e) {
-     *   expect(e instanceof InstantiationError).toBe(true);
-     *   expect(e.originalException.message).toEqual("message");
-     *   expect(e.originalStack).toBeDefined();
-     * }
-     * ```
-     */
-    function instantiationError(injector, originalException, originalStack, key) {
-        return injectionError(injector, key, function (keys) {
-            const first = stringify$1(keys[0].token);
-            return `${originalException.message}: Error during instantiation of ${first}!${constructResolvingPath(keys)}.`;
-        }, originalException);
-    }
-    /**
-     * Thrown when an object other then {@link Provider} (or `Type`) is passed to {@link Injector}
-     * creation.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * expect(() => Injector.resolveAndCreate(["not a type"])).toThrowError();
-     * ```
-     */
-    function invalidProviderError(provider) {
-        return Error(`Invalid provider - only instances of Provider and Type are allowed, got: ${provider}`);
-    }
-    /**
-     * Thrown when the class has no annotation information.
-     *
-     * Lack of annotation information prevents the {@link Injector} from determining which dependencies
-     * need to be injected into the constructor.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * class A {
-     *   constructor(b) {}
-     * }
-     *
-     * expect(() => Injector.resolveAndCreate([A])).toThrowError();
-     * ```
-     *
-     * This error is also thrown when the class not marked with {@link Injectable} has parameter types.
-     *
-     * ```typescript
-     * class B {}
-     *
-     * class A {
-     *   constructor(b:B) {} // no information about the parameter types of A is available at runtime.
-     * }
-     *
-     * expect(() => Injector.resolveAndCreate([A,B])).toThrowError();
-     * ```
-     *
-     */
-    function noAnnotationError(typeOrFunc, params) {
-        const signature = [];
-        for (let i = 0, ii = params.length; i < ii; i++) {
-            const parameter = params[i];
-            if (!parameter || parameter.length == 0) {
-                signature.push('?');
-            }
-            else {
-                signature.push(parameter.map(stringify$1).join(' '));
-            }
-        }
-        return Error('Cannot resolve all parameters for \'' + stringify$1(typeOrFunc) + '\'(' +
-            signature.join(', ') + '). ' +
-            'Make sure that all the parameters are decorated with Inject or have valid type annotations and that \'' +
-            stringify$1(typeOrFunc) + '\' is decorated with Injectable.');
-    }
-    /**
-     * Thrown when getting an object by index.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * class A {}
-     *
-     * var injector = Injector.resolveAndCreate([A]);
-     *
-     * expect(() => injector.getAt(100)).toThrowError();
-     * ```
-     *
-     */
-    function outOfBoundsError(index) {
-        return Error(`Index ${index} is out-of-bounds.`);
-    }
-    // TODO: add a working example after alpha38 is released
-    /**
-     * Thrown when a multi provider and a regular provider are bound to the same token.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```typescript
-     * expect(() => Injector.resolveAndCreate([
-     *   { provide: "Strings", useValue: "string1", multi: true},
-     *   { provide: "Strings", useValue: "string2", multi: false}
-     * ])).toThrowError();
-     * ```
-     */
-    function mixingMultiProvidersWithRegularProvidersError(provider1, provider2) {
-        return Error(`Cannot mix multi providers and regular providers, got: ${provider1} ${provider2}`);
-    }
-
-    /**
-     * @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
-     */
-    /**
-     * A unique object used for retrieving items from the {@link ReflectiveInjector}.
-     *
-     * Keys have:
-     * - a system-wide unique `id`.
-     * - a `token`.
-     *
-     * `Key` is used internally by {@link ReflectiveInjector} because its system-wide unique `id` allows
-     * the
-     * injector to store created objects in a more efficient way.
-     *
-     * `Key` should not be created directly. {@link ReflectiveInjector} creates keys automatically when
-     * resolving
-     * providers.
-     *
-     * @deprecated No replacement
-     * @publicApi
-     */
-    class ReflectiveKey {
-        /**
-         * Private
-         */
-        constructor(token, id) {
-            this.token = token;
-            this.id = id;
-            if (!token) {
-                throw new Error('Token must be defined!');
-            }
-            this.displayName = stringify$1(this.token);
-        }
-        /**
-         * Retrieves a `Key` for a token.
-         */
-        static get(token) {
-            return _globalKeyRegistry.get(resolveForwardRef$1(token));
-        }
-        /**
-         * @returns the number of keys registered in the system.
-         */
-        static get numberOfKeys() {
-            return _globalKeyRegistry.numberOfKeys;
-        }
-    }
-    class KeyRegistry {
-        constructor() {
-            this._allKeys = new Map();
-        }
-        get(token) {
-            if (token instanceof ReflectiveKey)
-                return token;
-            if (this._allKeys.has(token)) {
-                return this._allKeys.get(token);
-            }
-            const newKey = new ReflectiveKey(token, ReflectiveKey.numberOfKeys);
-            this._allKeys.set(token, newKey);
-            return newKey;
-        }
-        get numberOfKeys() {
-            return this._allKeys.size;
-        }
-    }
-    const _globalKeyRegistry = new KeyRegistry();
-
-    /**
-     * @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
-     */
-    /**
-     * Provides access to reflection data about symbols. Used internally by Angular
-     * to power dependency injection and compilation.
-     */
-    class Reflector {
-        constructor(reflectionCapabilities) {
-            this.reflectionCapabilities = reflectionCapabilities;
-        }
-        updateCapabilities(caps) {
-            this.reflectionCapabilities = caps;
-        }
-        factory(type) {
-            return this.reflectionCapabilities.factory(type);
-        }
-        parameters(typeOrFunc) {
-            return this.reflectionCapabilities.parameters(typeOrFunc);
-        }
-        annotations(typeOrFunc) {
-            return this.reflectionCapabilities.annotations(typeOrFunc);
-        }
-        propMetadata(typeOrFunc) {
-            return this.reflectionCapabilities.propMetadata(typeOrFunc);
-        }
-        hasLifecycleHook(type, lcProperty) {
-            return this.reflectionCapabilities.hasLifecycleHook(type, lcProperty);
-        }
-        getter(name) {
-            return this.reflectionCapabilities.getter(name);
-        }
-        setter(name) {
-            return this.reflectionCapabilities.setter(name);
-        }
-        method(name) {
-            return this.reflectionCapabilities.method(name);
-        }
-        importUri(type) {
-            return this.reflectionCapabilities.importUri(type);
-        }
-        resourceUri(type) {
-            return this.reflectionCapabilities.resourceUri(type);
-        }
-        resolveIdentifier(name, moduleUrl, members, runtime) {
-            return this.reflectionCapabilities.resolveIdentifier(name, moduleUrl, members, runtime);
-        }
-        resolveEnum(identifier, name) {
-            return this.reflectionCapabilities.resolveEnum(identifier, name);
-        }
-    }
-
-    /**
-     * @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
-     */
-    /**
-     * The {@link Reflector} used internally in Angular to access metadata
-     * about symbols.
-     */
-    const reflector = new Reflector(new ReflectionCapabilities());
-
-    /**
-     * @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
-     */
-    /**
-     * `Dependency` is used by the framework to extend DI.
-     * This is internal to Angular and should not be used directly.
-     */
-    class ReflectiveDependency {
-        constructor(key, optional, visibility) {
-            this.key = key;
-            this.optional = optional;
-            this.visibility = visibility;
-        }
-        static fromKey(key) {
-            return new ReflectiveDependency(key, false, null);
-        }
-    }
-    const _EMPTY_LIST = [];
-    class ResolvedReflectiveProvider_ {
-        constructor(key, resolvedFactories, multiProvider) {
-            this.key = key;
-            this.resolvedFactories = resolvedFactories;
-            this.multiProvider = multiProvider;
-            this.resolvedFactory = this.resolvedFactories[0];
-        }
-    }
-    /**
-     * An internal resolved representation of a factory function created by resolving `Provider`.
-     * @publicApi
-     */
-    class ResolvedReflectiveFactory {
-        constructor(
-        /**
-         * Factory function which can return an instance of an object represented by a key.
-         */
-        factory, 
-        /**
-         * Arguments (dependencies) to the `factory` function.
-         */
-        dependencies) {
-            this.factory = factory;
-            this.dependencies = dependencies;
-        }
-    }
-    /**
-     * Resolve a single provider.
-     */
-    function resolveReflectiveFactory(provider) {
-        let factoryFn;
-        let resolvedDeps;
-        if (provider.useClass) {
-            const useClass = resolveForwardRef$1(provider.useClass);
-            factoryFn = reflector.factory(useClass);
-            resolvedDeps = _dependenciesFor(useClass);
-        }
-        else if (provider.useExisting) {
-            factoryFn = (aliasInstance) => aliasInstance;
-            resolvedDeps = [ReflectiveDependency.fromKey(ReflectiveKey.get(provider.useExisting))];
-        }
-        else if (provider.useFactory) {
-            factoryFn = provider.useFactory;
-            resolvedDeps = constructDependencies(provider.useFactory, provider.deps);
-        }
-        else {
-            factoryFn = () => provider.useValue;
-            resolvedDeps = _EMPTY_LIST;
-        }
-        return new ResolvedReflectiveFactory(factoryFn, resolvedDeps);
-    }
-    /**
-     * Converts the `Provider` into `ResolvedProvider`.
-     *
-     * `Injector` internally only uses `ResolvedProvider`, `Provider` contains convenience provider
-     * syntax.
-     */
-    function resolveReflectiveProvider(provider) {
-        return new ResolvedReflectiveProvider_(ReflectiveKey.get(provider.provide), [resolveReflectiveFactory(provider)], provider.multi || false);
-    }
-    /**
-     * Resolve a list of Providers.
-     */
-    function resolveReflectiveProviders(providers) {
-        const normalized = _normalizeProviders(providers, []);
-        const resolved = normalized.map(resolveReflectiveProvider);
-        const resolvedProviderMap = mergeResolvedReflectiveProviders(resolved, new Map());
-        return Array.from(resolvedProviderMap.values());
-    }
-    /**
-     * Merges a list of ResolvedProviders into a list where each key is contained exactly once and
-     * multi providers have been merged.
-     */
-    function mergeResolvedReflectiveProviders(providers, normalizedProvidersMap) {
-        for (let i = 0; i < providers.length; i++) {
-            const provider = providers[i];
-            const existing = normalizedProvidersMap.get(provider.key.id);
-            if (existing) {
-                if (provider.multiProvider !== existing.multiProvider) {
-                    throw mixingMultiProvidersWithRegularProvidersError(existing, provider);
-                }
-                if (provider.multiProvider) {
-                    for (let j = 0; j < provider.resolvedFactories.length; j++) {
-                        existing.resolvedFactories.push(provider.resolvedFactories[j]);
-                    }
-                }
-                else {
-                    normalizedProvidersMap.set(provider.key.id, provider);
-                }
-            }
-            else {
-                let resolvedProvider;
-                if (provider.multiProvider) {
-                    resolvedProvider = new ResolvedReflectiveProvider_(provider.key, provider.resolvedFactories.slice(), provider.multiProvider);
-                }
-                else {
-                    resolvedProvider = provider;
-                }
-                normalizedProvidersMap.set(provider.key.id, resolvedProvider);
-            }
-        }
-        return normalizedProvidersMap;
-    }
-    function _normalizeProviders(providers, res) {
-        providers.forEach(b => {
-            if (b instanceof Type$2) {
-                res.push({ provide: b, useClass: b });
-            }
-            else if (b && typeof b == 'object' && b.provide !== undefined) {
-                res.push(b);
-            }
-            else if (Array.isArray(b)) {
-                _normalizeProviders(b, res);
-            }
-            else {
-                throw invalidProviderError(b);
-            }
-        });
-        return res;
-    }
-    function constructDependencies(typeOrFunc, dependencies) {
-        if (!dependencies) {
-            return _dependenciesFor(typeOrFunc);
-        }
-        else {
-            const params = dependencies.map(t => [t]);
-            return dependencies.map(t => _extractToken(typeOrFunc, t, params));
-        }
-    }
-    function _dependenciesFor(typeOrFunc) {
-        const params = reflector.parameters(typeOrFunc);
-        if (!params)
-            return [];
-        if (params.some(p => p == null)) {
-            throw noAnnotationError(typeOrFunc, params);
-        }
-        return params.map(p => _extractToken(typeOrFunc, p, params));
-    }
-    function _extractToken(typeOrFunc, metadata, params) {
-        let token = null;
-        let optional = false;
-        if (!Array.isArray(metadata)) {
-            if (metadata instanceof Inject) {
-                return _createDependency(metadata.token, optional, null);
-            }
-            else {
-                return _createDependency(metadata, optional, null);
-            }
-        }
-        let visibility = null;
-        for (let i = 0; i < metadata.length; ++i) {
-            const paramMetadata = metadata[i];
-            if (paramMetadata instanceof Type$2) {
-                token = paramMetadata;
-            }
-            else if (paramMetadata instanceof Inject) {
-                token = paramMetadata.token;
-            }
-            else if (paramMetadata instanceof Optional) {
-                optional = true;
-            }
-            else if (paramMetadata instanceof Self || paramMetadata instanceof SkipSelf) {
-                visibility = paramMetadata;
-            }
-            else if (paramMetadata instanceof InjectionToken) {
-                token = paramMetadata;
-            }
-        }
-        token = resolveForwardRef$1(token);
-        if (token != null) {
-            return _createDependency(token, optional, visibility);
-        }
-        else {
-            throw noAnnotationError(typeOrFunc, params);
-        }
-    }
-    function _createDependency(token, optional, visibility) {
-        return new ReflectiveDependency(ReflectiveKey.get(token), optional, visibility);
-    }
-
-    /**
-     * @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
-     */
-    // Threshold for the dynamic version
-    const UNDEFINED = {};
-    /**
-     * A ReflectiveDependency injection container used for instantiating objects and resolving
-     * dependencies.
-     *
-     * An `Injector` is a replacement for a `new` operator, which can automatically resolve the
-     * constructor dependencies.
-     *
-     * In typical use, application code asks for the dependencies in the constructor and they are
-     * resolved by the `Injector`.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * The following example creates an `Injector` configured to create `Engine` and `Car`.
-     *
-     * ```typescript
-     * @Injectable()
-     * class Engine {
-     * }
-     *
-     * @Injectable()
-     * class Car {
-     *   constructor(public engine:Engine) {}
-     * }
-     *
-     * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
-     * var car = injector.get(Car);
-     * expect(car instanceof Car).toBe(true);
-     * expect(car.engine instanceof Engine).toBe(true);
-     * ```
-     *
-     * Notice, we don't use the `new` operator because we explicitly want to have the `Injector`
-     * resolve all of the object's dependencies automatically.
-     *
-     * @deprecated from v5 - slow and brings in a lot of code, Use `Injector.create` instead.
-     * @publicApi
-     */
-    class ReflectiveInjector {
-        /**
-         * Turns an array of provider definitions into an array of resolved providers.
-         *
-         * A resolution is a process of flattening multiple nested arrays and converting individual
-         * providers into an array of `ResolvedReflectiveProvider`s.
-         *
-         * @usageNotes
-         * ### Example
-         *
-         * ```typescript
-         * @Injectable()
-         * class Engine {
-         * }
-         *
-         * @Injectable()
-         * class Car {
-         *   constructor(public engine:Engine) {}
-         * }
-         *
-         * var providers = ReflectiveInjector.resolve([Car, [[Engine]]]);
-         *
-         * expect(providers.length).toEqual(2);
-         *
-         * expect(providers[0] instanceof ResolvedReflectiveProvider).toBe(true);
-         * expect(providers[0].key.displayName).toBe("Car");
-         * expect(providers[0].dependencies.length).toEqual(1);
-         * expect(providers[0].factory).toBeDefined();
-         *
-         * expect(providers[1].key.displayName).toBe("Engine");
-         * });
-         * ```
-         *
-         */
-        static resolve(providers) {
-            return resolveReflectiveProviders(providers);
-        }
-        /**
-         * Resolves an array of providers and creates an injector from those providers.
-         *
-         * The passed-in providers can be an array of `Type`, `Provider`,
-         * or a recursive array of more providers.
-         *
-         * @usageNotes
-         * ### Example
-         *
-         * ```typescript
-         * @Injectable()
-         * class Engine {
-         * }
-         *
-         * @Injectable()
-         * class Car {
-         *   constructor(public engine:Engine) {}
-         * }
-         *
-         * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
-         * expect(injector.get(Car) instanceof Car).toBe(true);
-         * ```
-         */
-        static resolveAndCreate(providers, parent) {
-            const ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
-            return ReflectiveInjector.fromResolvedProviders(ResolvedReflectiveProviders, parent);
-        }
-        /**
-         * Creates an injector from previously resolved providers.
-         *
-         * This API is the recommended way to construct injectors in performance-sensitive parts.
-         *
-         * @usageNotes
-         * ### Example
-         *
-         * ```typescript
-         * @Injectable()
-         * class Engine {
-         * }
-         *
-         * @Injectable()
-         * class Car {
-         *   constructor(public engine:Engine) {}
-         * }
-         *
-         * var providers = ReflectiveInjector.resolve([Car, Engine]);
-         * var injector = ReflectiveInjector.fromResolvedProviders(providers);
-         * expect(injector.get(Car) instanceof Car).toBe(true);
-         * ```
-         */
-        static fromResolvedProviders(providers, parent) {
-            return new ReflectiveInjector_(providers, parent);
-        }
-    }
-    class ReflectiveInjector_ {
-        /**
-         * Private
-         */
-        constructor(_providers, _parent) {
-            /** @internal */
-            this._constructionCounter = 0;
-            this._providers = _providers;
-            this.parent = _parent || null;
-            const len = _providers.length;
-            this.keyIds = [];
-            this.objs = [];
-            for (let i = 0; i < len; i++) {
-                this.keyIds[i] = _providers[i].key.id;
-                this.objs[i] = UNDEFINED;
-            }
-        }
-        get(token, notFoundValue = THROW_IF_NOT_FOUND) {
-            return this._getByKey(ReflectiveKey.get(token), null, notFoundValue);
-        }
-        resolveAndCreateChild(providers) {
-            const ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
-            return this.createChildFromResolved(ResolvedReflectiveProviders);
-        }
-        createChildFromResolved(providers) {
-            const inj = new ReflectiveInjector_(providers);
-            inj.parent = this;
-            return inj;
-        }
-        resolveAndInstantiate(provider) {
-            return this.instantiateResolved(ReflectiveInjector.resolve([provider])[0]);
-        }
-        instantiateResolved(provider) {
-            return this._instantiateProvider(provider);
-        }
-        getProviderAtIndex(index) {
-            if (index < 0 || index >= this._providers.length) {
-                throw outOfBoundsError(index);
-            }
-            return this._providers[index];
-        }
-        /** @internal */
-        _new(provider) {
-            if (this._constructionCounter++ > this._getMaxNumberOfObjects()) {
-                throw cyclicDependencyError(this, provider.key);
-            }
-            return this._instantiateProvider(provider);
-        }
-        _getMaxNumberOfObjects() {
-            return this.objs.length;
-        }
-        _instantiateProvider(provider) {
-            if (provider.multiProvider) {
-                const res = [];
-                for (let i = 0; i < provider.resolvedFactories.length; ++i) {
-                    res[i] = this._instantiate(provider, provider.resolvedFactories[i]);
-                }
-                return res;
-            }
-            else {
-                return this._instantiate(provider, provider.resolvedFactories[0]);
-            }
-        }
-        _instantiate(provider, ResolvedReflectiveFactory) {
-            const factory = ResolvedReflectiveFactory.factory;
-            let deps;
-            try {
-                deps =
-                    ResolvedReflectiveFactory.dependencies.map(dep => this._getByReflectiveDependency(dep));
-            }
-            catch (e) {
-                if (e.addKey) {
-                    e.addKey(this, provider.key);
-                }
-                throw e;
-            }
-            let obj;
-            try {
-                obj = factory(...deps);
-            }
-            catch (e) {
-                throw instantiationError(this, e, e.stack, provider.key);
-            }
-            return obj;
-        }
-        _getByReflectiveDependency(dep) {
-            return this._getByKey(dep.key, dep.visibility, dep.optional ? null : THROW_IF_NOT_FOUND);
-        }
-        _getByKey(key, visibility, notFoundValue) {
-            if (key === ReflectiveInjector_.INJECTOR_KEY) {
-                return this;
-            }
-            if (visibility instanceof Self) {
-                return this._getByKeySelf(key, notFoundValue);
-            }
-            else {
-                return this._getByKeyDefault(key, notFoundValue, visibility);
-            }
-        }
-        _getObjByKeyId(keyId) {
-            for (let i = 0; i < this.keyIds.length; i++) {
-                if (this.keyIds[i] === keyId) {
-                    if (this.objs[i] === UNDEFINED) {
-                        this.objs[i] = this._new(this._providers[i]);
-                    }
-                    return this.objs[i];
-                }
-            }
-            return UNDEFINED;
-        }
-        /** @internal */
-        _throwOrNull(key, notFoundValue) {
-            if (notFoundValue !== THROW_IF_NOT_FOUND) {
-                return notFoundValue;
-            }
-            else {
-                throw noProviderError(this, key);
-            }
-        }
-        /** @internal */
-        _getByKeySelf(key, notFoundValue) {
-            const obj = this._getObjByKeyId(key.id);
-            return (obj !== UNDEFINED) ? obj : this._throwOrNull(key, notFoundValue);
-        }
-        /** @internal */
-        _getByKeyDefault(key, notFoundValue, visibility) {
-            let inj;
-            if (visibility instanceof SkipSelf) {
-                inj = this.parent;
-            }
-            else {
-                inj = this;
-            }
-            while (inj instanceof ReflectiveInjector_) {
-                const inj_ = inj;
-                const obj = inj_._getObjByKeyId(key.id);
-                if (obj !== UNDEFINED)
-                    return obj;
-                inj = inj_.parent;
-            }
-            if (inj !== null) {
-                return inj.get(key.token, notFoundValue);
-            }
-            else {
-                return this._throwOrNull(key, notFoundValue);
-            }
-        }
-        get displayName() {
-            const providers = _mapProviders(this, (b) => ' "' + b.key.displayName + '" ')
-                .join(', ');
-            return `ReflectiveInjector(providers: [${providers}])`;
-        }
-        toString() {
-            return this.displayName;
-        }
-    }
-    ReflectiveInjector_.INJECTOR_KEY = ReflectiveKey.get(Injector);
-    function _mapProviders(injector, fn) {
-        const res = [];
-        for (let i = 0; i < injector._providers.length; ++i) {
-            res[i] = fn(injector.getProviderAtIndex(i));
-        }
-        return res;
-    }
-
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -37397,7 +36533,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
      */
     class ComponentFactoryResolver {
     }
-    ComponentFactoryResolver.NULL = new _NullComponentFactoryResolver();
+    ComponentFactoryResolver.NULL = ( /* @__PURE__ */new _NullComponentFactoryResolver());
     class ComponentFactoryBoundToModule extends ComponentFactory {
         constructor(factory, ngModule) {
             super();
@@ -37554,7 +36690,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'typescript', 'path'], func
     /**
      * @publicApi
      */
-    const VERSION$2 = new Version$1('12.2.2');
+    const VERSION$2 = new Version$1('12.2.6');
 
     /**
      * @license

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/language-service",
-  "version": "12.2.2",
+  "version": "12.2.6",
   "description": "Angular - language services",
   "main": "./index.js",
   "typings": "./index.d.ts",