static-injector 2.1.0 → 2.1.1

package/import/commonjs/index.js

@@ -42,6 +42,7 @@ function noSideEffects(fn) {
  * 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 PARAMETERS = '__parameters__';
 function makeMetadataCtor(props) {
     return function ctor(...args) {
         if (props) {
@@ -52,7 +53,7 @@ function makeMetadataCtor(props) {
         }
     };
 }
-function makeParamDecorator(name, props) {
+function makeParamDecorator(name, props, parentClass) {
     return noSideEffects(() => {
         const metaCtor = makeMetadataCtor(props);
         function ParamDecoratorFactory(...args) {
@@ -60,7 +61,29 @@ function makeParamDecorator(name, props) {
                 metaCtor.apply(this, args);
                 return this;
             }
+            const annotationInstance = new ParamDecoratorFactory(...args);
+            ParamDecorator.annotation = annotationInstance;
+            return ParamDecorator;
+            function ParamDecorator(cls, unusedKey, index) {
+                // Use of Object.defineProperty is important since it creates non-enumerable property which
+                // prevents the property is copied during subclassing.
+                const parameters = cls.hasOwnProperty(PARAMETERS)
+                    ? cls[PARAMETERS]
+                    : Object.defineProperty(cls, PARAMETERS, { value: [] })[PARAMETERS];
+                // there might be gaps if some in between parameters do not have annotations.
+                // we pad with nulls.
+                while (parameters.length <= index) {
+                    parameters.push(null);
+                }
+                (parameters[index] = parameters[index] || []).push(annotationInstance);
+                return cls;
+            }
         }
+        if (parentClass) {
+            ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);
+        }
+        ParamDecoratorFactory.prototype.ngMetadataName = name;
+        ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;
         return ParamDecoratorFactory;
     });
 }
@@ -72,13 +95,40 @@ function makeParamDecorator(name, props) {
  * 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 getClosureSafeProperty(objWithPropertyToExtract) {
-    for (let key in objWithPropertyToExtract) {
-        if (objWithPropertyToExtract[key] === getClosureSafeProperty) {
-            return key;
-        }
+/**
+ * Class that represents a runtime error.
+ * Formats and outputs the error message in a consistent way.
+ *
+ * Example:
+ * ```
+ *  throw new RuntimeError(
+ *    RuntimeErrorCode.INJECTOR_ALREADY_DESTROYED,
+ *    ngDevMode && 'Injector has already been destroyed.');
+ * ```
+ *
+ * Note: the `message` argument contains a descriptive error message as a string in development
+ * mode (when the `ngDevMode` is defined). In production mode (after tree-shaking pass), the
+ * `message` argument becomes `false`, thus we account for it in the typings and the runtime logic.
+ */
+class RuntimeError extends Error {
+    constructor(code, message) {
+        super(formatRuntimeError(code, message));
+        this.code = code;
     }
-    throw Error('Could not find renamed property on target object.');
+}
+/**
+ * Called to format a runtime error.
+ * See additional info on the `message` argument type in the `RuntimeError` class description.
+ */
+function formatRuntimeError(code, message) {
+    // Error code might be a negative number, which is a special marker that instructs the logic to
+    // generate a link to the error details page on angular.io.
+    // We also prepend `0` to non-compile-time errors.
+    const fullCode = `NG0${Math.abs(code)}`;
+    let errorMessage = `${fullCode}${message ? ': ' + message.trim() : ''}`;
+    if (false) {
+    }
+    return errorMessage;
 }
 
 /**
@@ -89,14 +139,14 @@ function getClosureSafeProperty(objWithPropertyToExtract) {
  * found in the LICENSE file at https://angular.io/license
  */
 function stringify(token) {
-    if (typeof token === "string") {
+    if (typeof token === 'string') {
         return token;
     }
     if (Array.isArray(token)) {
-        return "[" + token.map(stringify).join(", ") + "]";
+        return '[' + token.map(stringify).join(', ') + ']';
     }
     if (token == null) {
-        return "" + token;
+        return '' + token;
     }
     if (token.overriddenName) {
         return `${token.overriddenName}`;
@@ -106,12 +156,28 @@ function stringify(token) {
     }
     const res = token.toString();
     if (res == null) {
-        return "" + res;
+        return '' + res;
     }
-    const newLineIndex = res.indexOf("\n");
+    const newLineIndex = res.indexOf('\n');
     return newLineIndex === -1 ? res : res.substring(0, newLineIndex);
 }
 
+/**
+ * @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 getClosureSafeProperty(objWithPropertyToExtract) {
+    for (let key in objWithPropertyToExtract) {
+        if (objWithPropertyToExtract[key] === getClosureSafeProperty) {
+            return key;
+        }
+    }
+    throw Error('Could not find renamed property on target object.');
+}
+
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -159,79 +225,11 @@ function resolveForwardRef(type) {
 }
 /** Checks whether a function is wrapped by a `forwardRef`. */
 function isForwardRef(fn) {
-    return (typeof fn === "function" &&
+    return (typeof fn === 'function' &&
         fn.hasOwnProperty(__forward_ref__) &&
         fn.__forward_ref__ === forwardRef);
 }
 
-/**
- * @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 RuntimeError extends Error {
-    constructor(code, message) {
-        super(formatRuntimeError(code, message));
-        this.code = code;
-    }
-}
-/* tslint:enable:no-toplevel-property-access */
-/** Called to format a runtime error */
-function formatRuntimeError(code, message) {
-    const fullCode = code ? `NG0${code}: ` : '';
-    let errorMessage = `${fullCode}${message}`;
-    // Some runtime errors are still thrown without `ngDevMode` (for example
-    // `throwProviderNotFoundError`), so we add `ngDevMode` check here to avoid pulling
-    // `RUNTIME_ERRORS_WITH_GUIDES` symbol into prod bundles.
-    // TODO: revisit all instances where `RuntimeError` is thrown and see if `ngDevMode` can be added
-    // there instead to tree-shake more devmode-only code (and eventually remove `ngDevMode` check
-    // from this code).
-    // if (ngDevMode && RUNTIME_ERRORS_WITH_GUIDES.has(code)) {
-    //   errorMessage = `${errorMessage}. Find more at ${ERROR_DETAILS_PAGE_BASE_URL}/NG0${code}`;
-    // }
-    return errorMessage;
-}
-
-/**
- * @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
- */
-/**
- * Used for stringify render output in Ivy.
- * Important! This function is very performance-sensitive and we should
- * be extra careful not to introduce megamorphic reads in it.
- * Check `core/test/render3/perf/render_stringify` for benchmarks and alternate implementations.
- */
-function renderStringify(value) {
-    if (typeof value === "string")
-        return value;
-    if (value == null)
-        return "";
-    // Use `String` so that it invokes the `toString` method of the value. Note that this
-    // appears to be faster than calling `value.toString` (see `render_stringify` benchmark).
-    return String(value);
-}
-/**
- * Used to stringify a value so that it can be displayed in an error message.
- * Important! This function contains a megamorphic read and should only be
- * used for error messages.
- */
-function stringifyForError(value) {
-    if (typeof value === "function")
-        return value.name || value.toString();
-    if (typeof value === "object" &&
-        value != null &&
-        typeof value.type === "function") {
-        return value.type.name || value.type.toString();
-    }
-    return renderStringify(value);
-}
-
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -242,7 +240,7 @@ function stringifyForError(value) {
 /** Throws an error when a token is not found in DI. */
 function throwProviderNotFoundError(token, injectorName) {
     const injectorDetails = injectorName ? ` in ${injectorName}` : '';
-    throw new RuntimeError("201" /* RuntimeErrorCode.PROVIDER_NOT_FOUND */, `No provider for ${stringifyForError(token)} found${injectorDetails}`);
+    throw new RuntimeError(-201 /* RuntimeErrorCode.PROVIDER_NOT_FOUND */, null);
 }
 
 /**
@@ -304,7 +302,10 @@ function ɵɵdefineInjector(options) {
  * @param type A type which may have its own (non-inherited) `ɵprov`.
  */
 function getInjectableDef(type) {
-    return getOwnDefinition(type, NG_PROV_DEF);
+    return getOwnDefinition(type, NG_PROV_DEF) || null;
+}
+function isInjectable(type) {
+    return getInjectableDef(type) !== null;
 }
 /**
  * Return definition only if it is defined directly on `type` and is not inherited from a base
@@ -313,9 +314,6 @@ function getInjectableDef(type) {
 function getOwnDefinition(type, field) {
     return type.hasOwnProperty(field) ? type[field] : null;
 }
-const NG_PROV_DEF = getClosureSafeProperty({
-    ɵprov: getClosureSafeProperty,
-});
 /**
  * Read the injectable def (`ɵprov`) for `type` or read the `ɵprov` from one of its ancestors.
  *
@@ -325,22 +323,15 @@ const NG_PROV_DEF = getClosureSafeProperty({
  *     scenario if we find the `ɵprov` on an ancestor only.
  */
 function getInheritedInjectableDef(type) {
-    const def = type && (type[NG_PROV_DEF] || type[NG_INJECTABLE_DEF]);
+    const def = type && (type[NG_PROV_DEF] || null);
     if (def) {
         const typeName = getTypeName(type);
-        // TODO(FW-1307): Re-add ngDevMode when closure can handle it
-        // ngDevMode &&
-        console.warn(`DEPRECATED: DI is instantiating a token "${typeName}" that inherits its @Injectable decorator but does not provide one itself.\n` +
-            `This will become an error in a future version of Angular. Please add @Injectable() to the "${typeName}" class.`);
         return def;
     }
     else {
         return null;
     }
 }
-const NG_INJECTABLE_DEF = getClosureSafeProperty({
-    ngInjectableDef: getClosureSafeProperty,
-});
 /** Gets the name of a type, accounting for some cross-browser differences. */
 function getTypeName(type) {
     // `Function.prototype.name` behaves differently between IE and other browsers. In most browsers
@@ -355,6 +346,22 @@ function getTypeName(type) {
     const match = ('' + type).match(/^function\s*([^\s(]+)/);
     return match === null ? '' : match[1];
 }
+/**
+ * Read the injector def type in a way which is immune to accidentally reading inherited value.
+ *
+ * @param type type which may have an injector def (`ɵinj`)
+ */
+function getInjectorDef(type) {
+    return type && (type.hasOwnProperty(NG_INJ_DEF) || false)
+        ? type[NG_INJ_DEF]
+        : null;
+}
+const NG_PROV_DEF = getClosureSafeProperty({
+    ɵprov: getClosureSafeProperty,
+});
+const NG_INJ_DEF = getClosureSafeProperty({
+    ɵinj: getClosureSafeProperty,
+});
 
 /**
  * @license
@@ -452,10 +459,6 @@ const NG_TOKEN_PATH = 'ngTokenPath';
 const NEW_LINE = /\n/gm;
 const NO_NEW_LINE = 'ɵ';
 const SOURCE = '__source';
-const USE_VALUE = getClosureSafeProperty({
-    provide: String,
-    useValue: getClosureSafeProperty,
-});
 /**
  * Current injector value used by `inject`.
  * - `undefined`: it is an error to call `inject`
@@ -470,7 +473,7 @@ function setCurrentInjector(injector) {
 }
 function injectInjectorOnly(token, flags = exports.InjectFlags.Default) {
     if (_currentInjector === undefined) {
-        throw new Error(`inject() must be called from an injection context`);
+        throw new RuntimeError(-203 /* RuntimeErrorCode.MISSING_INJECTION_CONTEXT */, null);
     }
     else if (_currentInjector === null) {
         return injectRootLimpMode(token, undefined, flags);
@@ -480,7 +483,19 @@ function injectInjectorOnly(token, flags = exports.InjectFlags.Default) {
     }
 }
 function ɵɵinject(token, flags = exports.InjectFlags.Default) {
-    return injectInjectorOnly(resolveForwardRef(token), flags);
+    return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token), flags);
+}
+/**
+ * Throws an error indicating that a factory function could not be generated by the compiler for a
+ * particular class.
+ *
+ * The name of the class is not mentioned here, but will be in the generated factory function name
+ * and thus in the stack trace.
+ *
+ * @codeGenApi
+ */
+function ɵɵinvalidFactoryDep(index) {
+    throw new RuntimeError(202 /* RuntimeErrorCode.INVALID_FACTORY_DEPENDENCY */, null);
 }
 /**
  * Injects a token from the currently active injector.
@@ -495,7 +510,7 @@ function ɵɵinject(token, flags = exports.InjectFlags.Default) {
  * @param token A token that represents a dependency that should be injected.
  * @param flags Optional flags that control how injection is executed.
  * The flags correspond to injection strategies that can be specified with
- * parameter decorators `@Host`, `@Self`, `@SkipSef`, and `@Optional`.
+ * parameter decorators `@Host`, `@Self`, `@SkipSelf`, and `@Optional`.
  * @returns the injected value if operation is successful, `null` otherwise.
  * @throws if called outside of a supported context.
  *
@@ -559,6 +574,7 @@ function convertToBitFlags(flags) {
     // `InjectOptions` to `InjectFlags`.
     return (0 /* InternalInjectFlags.Default */ | // comment to force a line break in the formatter
         (flags.optional && 8 /* InternalInjectFlags.Optional */) |
+        0 |
         (flags.self && 2 /* InternalInjectFlags.Self */) |
         (flags.skipSelf &&
             4 /* InternalInjectFlags.SkipSelf */));
@@ -569,7 +585,7 @@ function injectArgs(types) {
         const arg = resolveForwardRef(types[i]);
         if (Array.isArray(arg)) {
             if (arg.length === 0) {
-                throw new Error('Arguments array must have arguments.');
+                throw new RuntimeError(900 /* RuntimeErrorCode.INVALID_DIFFER_INPUT */, null);
             }
             let type = undefined;
             let flags = exports.InjectFlags.Default;
@@ -724,19 +740,11 @@ const NG_FACTORY_DEF = getClosureSafeProperty({
  */
 function getFactoryDef(type, throwNotFound) {
     const hasFactoryDef = type.hasOwnProperty(NG_FACTORY_DEF);
-    // if (!hasFactoryDef && throwNotFound === true && ngDevMode) {
-    //   throw new Error(`Type ${stringify(type)} does not have 'ɵfac' property.`);
-    // }
+    if (false) {
+    }
     return hasFactoryDef ? type[NG_FACTORY_DEF] : null;
 }
 
-/**
- * @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 deepForEach(input, fn) {
     input.forEach((value) => Array.isArray(value) ? deepForEach(value, fn) : fn(value));
 }
@@ -761,7 +769,11 @@ function newArray(size, value) {
  * allows for identity checks against these values to be consistently used by the framework
  * code.
  */
+const EMPTY_OBJ = {};
 const EMPTY_ARRAY = [];
+// freezing the values prevents any code from accidentally inserting new values in
+if (false) {
+}
 
 /**
  * @license
@@ -778,11 +790,11 @@ const EMPTY_ARRAY = [];
  * parameterized type.
  *
  * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by
- * the `Injector`. This provides additional level of type safety.
+ * the `Injector`. This provides an additional level of type safety.
  *
  * ```
  * interface MyInterface {...}
- * var myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));
+ * const myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));
  * // myInterface is inferred to be MyInterface.
  * ```
  *
@@ -790,14 +802,18 @@ const EMPTY_ARRAY = [];
  * (possibly by creating) a default value of the parameterized type `T`. This sets up the
  * `InjectionToken` using this factory as a provider as if it was defined explicitly in the
  * application's root injector. If the factory function, which takes zero arguments, needs to inject
- * dependencies, it can do so using the `inject` function. See below for an example.
+ * dependencies, it can do so using the `inject` function.
+ * As you can see in the Tree-shakable InjectionToken example below.
  *
  * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which
- * overrides the above behavior and marks the token as belonging to a particular `@NgModule`. As
- * mentioned above, `'root'` is the default value for `providedIn`.
+ * overrides the above behavior and marks the token as belonging to a particular `@NgModule` (note:
+ * this option is now deprecated). As mentioned above, `'root'` is the default value for
+ * `providedIn`.
+ *
+ * The `providedIn: NgModule` and `providedIn: 'any'` options are deprecated.
  *
  * @usageNotes
- * ### Basic Example
+ * ### Basic Examples
  *
  * ### Plain InjectionToken
  *
@@ -811,15 +827,18 @@ const EMPTY_ARRAY = [];
  * @publicApi
  */
 class InjectionToken {
+    /**
+     * @param _desc   Description for the token,
+     *                used only for debugging purposes,
+     *                it should but does not need to be unique
+     * @param options Options for the token's usage, as described above
+     */
     constructor(_desc, options) {
         this._desc = _desc;
+        /** @internal */
+        this.ngMetadataName = 'InjectionToken';
         this.ɵprov = undefined;
         if (typeof options == 'number') {
-            // (typeof ngDevMode === "undefined" || ngDevMode) &&
-            //   assertLessThan(options, 0, "Only negative numbers are supported here");
-            // // This is a special hack to assign __NG_ELEMENT_ID__ to this instance.
-            // // See `InjectorMarkers`
-            // (this as any).__NG_ELEMENT_ID__ = options;
         }
         else if (options !== undefined) {
             this.ɵprov = ɵɵdefineInjectable({
@@ -870,12 +889,23 @@ const ENVIRONMENT_INITIALIZER = new InjectionToken('ENVIRONMENT_INITIALIZER');
  *
  * @publicApi
  */
-const INJECTOR = new InjectionToken("INJECTOR", 
-// Dissable tslint because this is const enum which gets inlined not top level prop access.
+const INJECTOR = new InjectionToken('INJECTOR', 
+// Disable tslint because this is const enum which gets inlined not top level prop access.
 // tslint:disable-next-line: no-toplevel-property-access
 -1 /* InjectorMarkers.Injector */ // Special value used by Ivy to identify `Injector`.
 );
 
+/**
+ * @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 isEnvironmentProviders(value) {
+    return value && !!value.ɵproviders;
+}
+
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -896,13 +926,248 @@ class NullInjector {
     get(token, notFoundValue = THROW_IF_NOT_FOUND) {
         if (notFoundValue === THROW_IF_NOT_FOUND) {
             const error = new Error(`NullInjectorError: No provider for ${stringify(token)}!`);
-            error.name = "NullInjectorError";
+            error.name = 'NullInjectorError';
             throw error;
         }
         return notFoundValue;
     }
 }
 
+/**
+ * @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
+ */
+/**
+ * Wrap an array of `Provider`s into `EnvironmentProviders`, preventing them from being accidentally
+ * referenced in `@Component in a component injector.
+ */
+function makeEnvironmentProviders(providers) {
+    return {
+        ɵproviders: providers,
+    };
+}
+/**
+ * Collects providers from all NgModules and standalone components, including transitively imported
+ * ones.
+ *
+ * Providers extracted via `importProvidersFrom` are only usable in an application injector or
+ * another environment injector (such as a route injector). They should not be used in component
+ * providers.
+ *
+ * More information about standalone components can be found in [this
+ * guide](guide/standalone-components).
+ *
+ * @usageNotes
+ * The results of the `importProvidersFrom` call can be used in the `bootstrapApplication` call:
+ *
+ * ```typescript
+ * await bootstrapApplication(RootComponent, {
+ *   providers: [
+ *     importProvidersFrom(NgModuleOne, NgModuleTwo)
+ *   ]
+ * });
+ * ```
+ *
+ * You can also use the `importProvidersFrom` results in the `providers` field of a route, when a
+ * standalone component is used:
+ *
+ * ```typescript
+ * export const ROUTES: Route[] = [
+ *   {
+ *     path: 'foo',
+ *     providers: [
+ *       importProvidersFrom(NgModuleOne, NgModuleTwo)
+ *     ],
+ *     component: YourStandaloneComponent
+ *   }
+ * ];
+ * ```
+ *
+ * @returns Collected providers from the specified list of types.
+ * @publicApi
+ */
+function importProvidersFrom(...sources) {
+    return {
+        ɵproviders: internalImportProvidersFrom(true, sources),
+        ɵfromNgModule: true,
+    };
+}
+function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
+    const providersOut = [];
+    const dedup = new Set(); // already seen types
+    let injectorTypesWithProviders;
+    // Collect all providers from `ModuleWithProviders` types.
+    if (injectorTypesWithProviders !== undefined) {
+        processInjectorTypesWithProviders(injectorTypesWithProviders, providersOut);
+    }
+    return providersOut;
+}
+/**
+ * Collects all providers from the list of `ModuleWithProviders` and appends them to the provided
+ * array.
+ */
+function processInjectorTypesWithProviders(typesWithProviders, providersOut) {
+    for (let i = 0; i < typesWithProviders.length; i++) {
+        const { ngModule, providers } = typesWithProviders[i];
+    }
+}
+/**
+ * The logic visits an `InjectorType`, an `InjectorTypeWithProviders`, or a standalone
+ * `ComponentType`, and all of its transitive providers and collects providers.
+ *
+ * If an `InjectorTypeWithProviders` that declares providers besides the type is specified,
+ * the function will return "true" to indicate that the providers of the type definition need
+ * to be processed. This allows us to process providers of injector types after all imports of
+ * an injector definition are processed. (following View Engine semantics: see FW-1349)
+ */
+function walkProviderTree(container, providersOut, parents, dedup) {
+    container = resolveForwardRef(container);
+    if (!container)
+        return false;
+    // The actual type which had the definition. Usually `container`, but may be an unwrapped type
+    // from `InjectorTypeWithProviders`.
+    let defType = null;
+    let injDef = getInjectorDef(container);
+    const cmpDef = !injDef && null;
+    if (!injDef && !cmpDef) {
+        // `container` is not an injector type or a component type. It might be:
+        //  * An `InjectorTypeWithProviders` that wraps an injector type.
+        //  * A standalone directive or pipe that got pulled in from a standalone component's
+        //    dependencies.
+        // Try to unwrap it as an `InjectorTypeWithProviders` first.
+        const ngModule = container.ngModule;
+        injDef = getInjectorDef(ngModule);
+        if (injDef) {
+            defType = ngModule;
+        }
+        else {
+            // Not a component or injector type, so ignore it.
+            return false;
+        }
+    }
+    else if (cmpDef && !cmpDef.standalone) {
+        return false;
+    }
+    else {
+        defType = container;
+    }
+    // Check for circular dependencies.
+    if (false) {
+    }
+    // Check for multiple imports of the same module
+    const isDuplicate = dedup.has(defType);
+    if (cmpDef) {
+        if (isDuplicate) {
+            // This component definition has already been processed.
+            return false;
+        }
+        dedup.add(defType);
+        if (cmpDef.dependencies) {
+            const deps = typeof cmpDef.dependencies === 'function'
+                ? cmpDef.dependencies()
+                : cmpDef.dependencies;
+            for (const dep of deps) {
+                walkProviderTree(dep, providersOut, parents, dedup);
+            }
+        }
+    }
+    else if (injDef) {
+        // First, include providers from any imports.
+        if (injDef.imports != null && !isDuplicate) {
+            // Before processing defType's imports, add it to the set of parents. This way, if it ends
+            // up deeply importing itself, this can be detected.
+            // Add it to the set of dedups. This way we can detect multiple imports of the same module
+            dedup.add(defType);
+            let importTypesWithProviders;
+            try {
+                deepForEach(injDef.imports, (imported) => {
+                    if (walkProviderTree(imported, providersOut, parents, dedup)) {
+                        importTypesWithProviders || (importTypesWithProviders = []);
+                        // If the processed import is an injector type with providers, we store it in the
+                        // list of import types with providers, so that we can process those afterwards.
+                        importTypesWithProviders.push(imported);
+                    }
+                });
+            }
+            finally {
+                // Remove it from the parents set when finished.
+            }
+            // Imports which are declared with providers (TypeWithProviders) need to be processed
+            // after all imported modules are processed. This is similar to how View Engine
+            // processes/merges module imports in the metadata resolver. See: FW-1349.
+            if (importTypesWithProviders !== undefined) {
+                processInjectorTypesWithProviders(importTypesWithProviders, providersOut);
+            }
+        }
+        if (!isDuplicate) {
+            // Track the InjectorType and add a provider for it.
+            // It's important that this is done after the def's imports.
+            const factory = getFactoryDef(defType) || (() => new defType());
+            // Append extra providers to make more info available for consumers (to retrieve an injector
+            // type), as well as internally (to calculate an injection scope correctly and eagerly
+            // instantiate a `defType` when an injector is created).
+            providersOut.push(
+            // Provider to create `defType` using its factory.
+            { provide: defType, useFactory: factory, deps: EMPTY_ARRAY }, 
+            // Make this `defType` available to an internal logic that calculates injector scope.
+            { provide: INJECTOR_DEF_TYPES, useValue: defType, multi: true }, 
+            // Provider to eagerly instantiate `defType` via `ENVIRONMENT_INITIALIZER`.
+            {
+                provide: ENVIRONMENT_INITIALIZER,
+                useValue: () => ɵɵinject(defType),
+                multi: true,
+            } //
+            );
+        }
+        // Next, include providers listed on the definition itself.
+        const defProviders = injDef.providers;
+        if (defProviders != null && !isDuplicate) {
+            const injectorType = container;
+        }
+    }
+    else {
+        // Should not happen, but just in case.
+        return false;
+    }
+    return (defType !== container &&
+        container.providers !== undefined);
+}
+function deepForEachProvider(providers, fn) {
+    for (let provider of providers) {
+        if (isEnvironmentProviders(provider)) {
+            provider = provider.ɵproviders;
+        }
+        if (Array.isArray(provider)) {
+            deepForEachProvider(provider, fn);
+        }
+        else {
+            fn(provider);
+        }
+    }
+}
+const USE_VALUE = getClosureSafeProperty({
+    provide: String,
+    useValue: getClosureSafeProperty,
+});
+function isValueProvider(value) {
+    return value !== null && typeof value == 'object' && USE_VALUE in value;
+}
+function isExistingProvider(value) {
+    return !!(value && value.useExisting);
+}
+function isFactoryProvider(value) {
+    return !!(value && value.useFactory);
+}
+function isTypeProvider(value) {
+    return typeof value === 'function';
+}
+function isClassProvider(value) {
+    return !!value.useClass;
+}
+
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -1107,6 +1372,8 @@ class R3Injector extends EnvironmentInjector {
         const previousInjectImplementation = setInjectImplementation(undefined);
         try {
             const initializers = this.get(ENVIRONMENT_INITIALIZER.multi, EMPTY_ARRAY, exports.InjectFlags.Self);
+            if (false) {
+            }
             for (const initializer of initializers) {
                 initializer();
             }
@@ -1126,7 +1393,7 @@ class R3Injector extends EnvironmentInjector {
     }
     assertNotDestroyed() {
         if (this._destroyed) {
-            throw new Error('Injector has already been destroyed.');
+            throw new RuntimeError(205 /* RuntimeErrorCode.INJECTOR_ALREADY_DESTROYED */, null);
         }
     }
     /**
@@ -1147,6 +1414,8 @@ class R3Injector extends EnvironmentInjector {
             let multiRecord = this.records.get(token);
             if (multiRecord) {
                 // It has. Throw a nice error if
+                if (false) {
+                }
             }
             else {
                 multiRecord = makeRecord(undefined, NOT_YET, true);
@@ -1158,11 +1427,15 @@ class R3Injector extends EnvironmentInjector {
         }
         else {
             const existing = this.records.get(token);
+            if (false) {
+            }
         }
         this.records.set(token, record);
     }
     hydrate(token, record) {
-        if (record.value === NOT_YET) {
+        if (false) {
+        }
+        else if (record.value === NOT_YET) {
             record.value = CIRCULAR;
             record.value = record.factory();
         }
@@ -1196,21 +1469,21 @@ function injectableDefOrInjectorDefFactory(token) {
     // InjectionTokens should have an injectable def (ɵprov) and thus should be handled above.
     // If it's missing that, it's an error.
     if (token instanceof InjectionToken) {
-        throw new Error(`Token ${stringify(token)} is missing a ɵprov definition.`);
+        throw new RuntimeError(204 /* RuntimeErrorCode.INVALID_INJECTION_TOKEN */, null);
     }
     // Undecorated types can sometimes be created if they have no constructor arguments.
     if (token instanceof Function) {
         return getUndecoratedInjectableFactory(token);
     }
     // There was no way to resolve a factory for this token.
-    throw new Error('unreachable');
+    throw new RuntimeError(204 /* RuntimeErrorCode.INVALID_INJECTION_TOKEN */, null);
 }
 function getUndecoratedInjectableFactory(token) {
     // If the token has parameters then it has dependencies that we cannot resolve implicitly.
     const paramLength = token.length;
     if (paramLength > 0) {
         const args = newArray(paramLength, '?');
-        throw new Error(`Can't resolve all parameters for ${stringify(token)}: (${args.join(', ')}).`);
+        throw new RuntimeError(204 /* RuntimeErrorCode.INVALID_INJECTION_TOKEN */, null);
     }
     // The constructor function appears to have no parameters.
     // This might be because it inherits from a super-class. In which case, use an injectable
@@ -1241,6 +1514,8 @@ function providerToRecord(provider) {
  */
 function providerToFactory(provider, ngModuleType, providers) {
     let factory = undefined;
+    if (false) {
+    }
     if (isTypeProvider(provider)) {
         const unwrappedProvider = resolveForwardRef(provider);
         return (getFactoryDef(unwrappedProvider) ||
@@ -1260,9 +1535,8 @@ function providerToFactory(provider, ngModuleType, providers) {
             const classRef = resolveForwardRef(provider &&
                 (provider.useClass ||
                     provider.provide));
-            // if (ngDevMode && !classRef) {
-            //   throwInvalidProviderError(ngModuleType, providers, provider);
-            // }
+            if (false) {
+            }
             if (hasDeps(provider)) {
                 factory = () => new classRef(...injectArgs(provider.deps));
             }
@@ -1280,18 +1554,6 @@ function makeRecord(factory, value, multi = false) {
         multi: multi ? [] : undefined,
     };
 }
-function isValueProvider(value) {
-    return value !== null && typeof value == 'object' && USE_VALUE in value;
-}
-function isExistingProvider(value) {
-    return !!(value && value.useExisting);
-}
-function isFactoryProvider(value) {
-    return !!(value && value.useFactory);
-}
-function isTypeProvider(value) {
-    return typeof value === 'function';
-}
 function hasDeps(value) {
     return !!value.deps;
 }
@@ -1309,6 +1571,9 @@ function forEachSingleProvider(providers, fn) {
         if (Array.isArray(provider)) {
             forEachSingleProvider(provider, fn);
         }
+        else if (provider && isEnvironmentProviders(provider)) {
+            forEachSingleProvider(provider.ɵproviders, fn);
+        }
         else {
             fn(provider);
         }
@@ -1338,7 +1603,10 @@ function createInjector(defType, parent = null, additionalProviders = null, name
  * should be resolved at a later point by calling `_resolveInjectorDefTypes`.
  */
 function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name, scopes = new Set()) {
-    const providers = [additionalProviders || EMPTY_ARRAY];
+    const providers = [
+        additionalProviders || EMPTY_ARRAY,
+        importProvidersFrom(defType),
+    ];
     name = name || (typeof defType === 'object' ? undefined : stringify(defType));
     return new R3Injector(providers, parent || getNullInjector(), name || null, scopes);
 }
@@ -1400,13 +1668,6 @@ Injector.ɵprov = ɵɵdefineInjectable({
  */
 Injector.__NG_ELEMENT_ID__ = -1 /* InjectorMarkers.Injector */;
 
-/**
- * @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
- */
 /**
  * Throws an error indicating that a factory function could not be generated by the compiler for a
  * particular class.
@@ -1476,7 +1737,7 @@ exports.Inject = Inject;
 exports.Injectable = Injectable;
 exports.InjectionToken = InjectionToken;
 exports.Injector = Injector;
-exports.NG_INJECTABLE_DEF = NG_INJECTABLE_DEF;
+exports.NG_INJ_DEF = NG_INJ_DEF;
 exports.NG_PROV_DEF = NG_PROV_DEF;
 exports.NG_TEMP_TOKEN_PATH = NG_TEMP_TOKEN_PATH;
 exports.NullInjector = NullInjector;
@@ -1486,7 +1747,6 @@ exports.SOURCE = SOURCE;
 exports.Self = Self;
 exports.SkipSelf = SkipSelf;
 exports.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
-exports.USE_VALUE = USE_VALUE;
 exports.attachInjectFlag = attachInjectFlag;
 exports.catchInjectorError = catchInjectorError;
 exports.convertToBitFlags = convertToBitFlags;
@@ -1494,11 +1754,12 @@ exports.formatError = formatError;
 exports.getInheritedInjectableDef = getInheritedInjectableDef;
 exports.getInjectFlag = getInjectFlag;
 exports.getInjectableDef = getInjectableDef;
+exports.getInjectorDef = getInjectorDef;
 exports.getNullInjector = getNullInjector;
 exports.inject = inject;
 exports.injectArgs = injectArgs;
 exports.injectInjectorOnly = injectInjectorOnly;
-exports.isTypeProvider = isTypeProvider;
+exports.isInjectable = isInjectable;
 exports.providerToFactory = providerToFactory;
 exports.setCurrentInjector = setCurrentInjector;
 exports["ɵɵdefineInjectable"] = ɵɵdefineInjectable;
@@ -1506,3 +1767,4 @@ exports["ɵɵdefineInjector"] = ɵɵdefineInjector;
 exports["ɵɵgetInheritedFactory"] = ɵɵgetInheritedFactory;
 exports["ɵɵinject"] = ɵɵinject;
 exports["ɵɵinvalidFactory"] = ɵɵinvalidFactory;
+exports["ɵɵinvalidFactoryDep"] = ɵɵinvalidFactoryDep;