static-injector 2.1.0 → 2.2.0

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,42 @@ 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 {
+    code;
+    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 : ''}`;
+    if (false) {
+    }
+    return errorMessage;
 }
 
 /**
@@ -89,14 +141,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 +158,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.
@@ -129,9 +197,36 @@ const __forward_ref__ = getClosureSafeProperty({
  * DI is declared, but not yet defined. It is also used when the `token` which we use when creating
  * a query is not yet defined.
  *
+ * `forwardRef` is also used to break circularities in standalone components imports.
+ *
  * @usageNotes
- * ### Example
+ * ### Circular dependency example
  * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref'}
+ *
+ * ### Circular standalone reference import example
+ * ```ts
+ * @Component({
+ *   standalone: true,
+ *   imports: [ChildComponent],
+ *   selector: 'app-parent',
+ *   template: `<app-child [hideParent]="hideParent"></app-child>`,
+ * })
+ * export class ParentComponent {
+ *   @Input() hideParent: boolean;
+ * }
+ *
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [CommonModule, forwardRef(() => ParentComponent)],
+ *   selector: 'app-child',
+ *   template: `<app-parent *ngIf="!hideParent"></app-parent>`,
+ * })
+ * export class ChildComponent {
+ *   @Input() hideParent: boolean;
+ * }
+ * ```
+ *
  * @publicApi
  */
 function forwardRef(forwardRefFn) {
@@ -151,7 +246,7 @@ function forwardRef(forwardRefFn) {
  *
  * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}
  *
- * @see `forwardRef`
+ * @see {@link forwardRef}
  * @publicApi
  */
 function resolveForwardRef(type) {
@@ -159,79 +254,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 +269,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);
 }
 
 /**
@@ -264,7 +291,8 @@ function throwProviderNotFoundError(token, injectorName) {
  *   with an `@NgModule` or other `InjectorType`, or by specifying that this injectable should be
  *   provided in the `'root'` injector, which will be the application-level injector in most apps.
  * * `factory` gives the zero argument function which will create an instance of the injectable.
- *   The factory can call `inject` to access the `Injector` and request injection of dependencies.
+ *   The factory can call [`inject`](api/core/inject) to access the `Injector` and request injection
+ * of dependencies.
  *
  * @codeGenApi
  * @publicApi This instruction has been emitted by ViewEngine for some time and is deployed to npm.
@@ -304,7 +332,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 +344,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,36 +353,30 @@ 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
-    // it'll always return the name of the function itself, no matter how many other functions it
-    // inherits from. On IE the function doesn't have its own `name` property, but it takes it from
-    // the lowest level in the prototype chain. E.g. if we have `class Foo extends Parent` most
-    // browsers will evaluate `Foo.name` to `Foo` while IE will return `Parent`. We work around
-    // the issue by converting the function to a string and parsing its name out that way via a regex.
-    if (type.hasOwnProperty('name')) {
-        return type.name;
-    }
-    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
@@ -367,7 +389,7 @@ function getTypeName(type) {
  * Injection flags for DI.
  *
  * @publicApi
- * @deprecated use an options object for `inject` instead.
+ * @deprecated use an options object for [`inject`](api/core/inject) instead.
  */
 exports.InjectFlags = void 0;
 (function (InjectFlags) {
@@ -452,10 +474,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`
@@ -463,6 +481,9 @@ const USE_VALUE = getClosureSafeProperty({
  * - Injector instance: Use the injector for resolution.
  */
 let _currentInjector = undefined;
+function getCurrentInjector() {
+    return _currentInjector;
+}
 function setCurrentInjector(injector) {
     const former = _currentInjector;
     _currentInjector = injector;
@@ -470,32 +491,46 @@ 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);
     }
     else {
-        return _currentInjector.get(token, flags & exports.InjectFlags.Optional ? null : undefined, flags);
+        const value = _currentInjector.get(token, flags & exports.InjectFlags.Optional ? null : undefined, flags);
+        return value;
     }
 }
 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.
- * `inject` is only supported during instantiation of a dependency by the DI system. It can be used
- * during:
+ * `inject` is only supported in an [injection context](/guide/dependency-injection-context). It can
+ * be used during:
  * - Construction (via the `constructor`) of a class being instantiated by the DI system, such
  * as an `@Injectable` or `@Component`.
  * - In the initializer for fields of such classes.
  * - In the factory function specified for `useFactory` of a `Provider` or an `@Injectable`.
  * - In the `factory` function specified for an `InjectionToken`.
+ * - In a stackframe of a function call in a DI context
  *
  * @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 +594,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 +605,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;
@@ -714,6 +750,17 @@ attachInjectFlag(makeParamDecorator('SkipSelf'), 4 /* InternalInjectFlags.SkipSe
 const NG_FACTORY_DEF = getClosureSafeProperty({
     ɵfac: getClosureSafeProperty,
 });
+/**
+ * The `NG_ENV_ID` field on a DI token indicates special processing in the `EnvironmentInjector`:
+ * getting such tokens from the `EnvironmentInjector` will bypass the standard DI resolution
+ * strategy and instead will return implementation produced by the `NG_ENV_ID` factory function.
+ *
+ * This particular retrieval of DI tokens is mostly done to eliminate circular dependencies and
+ * improve tree-shaking.
+ */
+const NG_ENV_ID = getClosureSafeProperty({
+    __NG_ENV_ID__: getClosureSafeProperty,
+});
 
 /**
  * @license
@@ -724,19 +771,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 +800,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 +821,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 +833,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`](api/core/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 +858,20 @@ const EMPTY_ARRAY = [];
  * @publicApi
  */
 class InjectionToken {
+    _desc;
+    /** @internal */
+    ngMetadataName = 'InjectionToken';
+    ɵprov;
+    /**
+     * @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;
         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 +922,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 +959,117 @@ 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;
+    const collectProviders = (provider) => {
+        providersOut.push(provider);
+    };
+    // Collect all providers from `ModuleWithProviders` types.
+    if (injectorTypesWithProviders !== undefined) {
+        processInjectorTypesWithProviders(injectorTypesWithProviders, collectProviders);
+    }
+    return providersOut;
+}
+/**
+ * Collects all providers from the list of `ModuleWithProviders` and appends them to the provided
+ * array.
+ */
+function processInjectorTypesWithProviders(typesWithProviders, visitor) {
+    for (let i = 0; i < typesWithProviders.length; i++) {
+        const { ngModule, providers } = typesWithProviders[i];
+    }
+}
+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.
@@ -953,29 +1120,33 @@ function getNullInjector() {
 class EnvironmentInjector {
 }
 class R3Injector extends EnvironmentInjector {
+    parent;
+    source;
+    scopes;
+    /**
+     * Map of tokens to records which contain the instances of those tokens.
+     * - `null` value implies that we don't have the record. Used by tree-shakable injectors
+     * to prevent further searches.
+     */
+    records = new Map();
+    /**
+     * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.
+     */
+    _ngOnDestroyHooks = new Set();
+    _onDestroyHooks = [];
     /**
      * Flag indicating that this injector was previously destroyed.
      */
     get destroyed() {
         return this._destroyed;
     }
+    _destroyed = false;
+    injectorDefTypes;
     constructor(providers, parent, source, scopes) {
         super();
         this.parent = parent;
         this.source = source;
         this.scopes = scopes;
-        /**
-         * Map of tokens to records which contain the instances of those tokens.
-         * - `null` value implies that we don't have the record. Used by tree-shakable injectors
-         * to prevent further searches.
-         */
-        this.records = new Map();
-        /**
-         * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.
-         */
-        this._ngOnDestroyHooks = new Set();
-        this._onDestroyHooks = [];
-        this._destroyed = false;
         // Start off by creating Records for every provider.
         forEachSingleProvider(providers, (provider) => this.processProvider(provider));
         // Make sure the INJECTOR token provides this injector.
@@ -1007,7 +1178,11 @@ class R3Injector extends EnvironmentInjector {
             for (const service of this._ngOnDestroyHooks) {
                 service.ngOnDestroy();
             }
-            for (const hook of this._onDestroyHooks) {
+            const onDestroyHooks = this._onDestroyHooks;
+            // Reset the _onDestroyHooks array before iterating over it to prevent hooks that unregister
+            // themselves from mutating the array during iteration.
+            this._onDestroyHooks = [];
+            for (const hook of onDestroyHooks) {
                 hook();
             }
         }
@@ -1016,16 +1191,19 @@ class R3Injector extends EnvironmentInjector {
             this.records.clear();
             this._ngOnDestroyHooks.clear();
             this.injectorDefTypes.clear();
-            this._onDestroyHooks.length = 0;
         }
     }
     onDestroy(callback) {
+        this.assertNotDestroyed();
         this._onDestroyHooks.push(callback);
+        return () => this.removeOnDestroy(callback);
     }
     runInContext(fn) {
         this.assertNotDestroyed();
         const previousInjector = setCurrentInjector(this);
         const previousInjectImplementation = setInjectImplementation(undefined);
+        if (false) {
+        }
         try {
             return fn();
         }
@@ -1036,8 +1214,13 @@ class R3Injector extends EnvironmentInjector {
     }
     get(token, notFoundValue = THROW_IF_NOT_FOUND, flags = exports.InjectFlags.Default) {
         this.assertNotDestroyed();
+        if (token.hasOwnProperty(NG_ENV_ID)) {
+            return token[NG_ENV_ID](this);
+        }
         flags = convertToBitFlags(flags);
         // Set the injection context.
+        if (false) {
+        }
         const previousInjector = setCurrentInjector(this);
         const previousInjectImplementation = setInjectImplementation(undefined);
         try {
@@ -1105,8 +1288,12 @@ class R3Injector extends EnvironmentInjector {
     resolveInjectorInitializers() {
         const previousInjector = setCurrentInjector(this);
         const previousInjectImplementation = setInjectImplementation(undefined);
+        if (false) {
+        }
         try {
             const initializers = this.get(ENVIRONMENT_INITIALIZER.multi, EMPTY_ARRAY, exports.InjectFlags.Self);
+            if (false) {
+            }
             for (const initializer of initializers) {
                 initializer();
             }
@@ -1126,7 +1313,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);
         }
     }
     /**
@@ -1141,12 +1328,16 @@ class R3Injector extends EnvironmentInjector {
             : resolveForwardRef(provider && provider.provide);
         // Construct a `Record` for the provider.
         const record = providerToRecord(provider);
+        if (false) {
+        }
         if (!isTypeProvider(provider) && provider.multi === true) {
             // If the provider indicates that it's a multi-provider, process it specially.
             // First check whether it's been defined already.
             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,13 +1349,21 @@ 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();
+            if (false) {
+            }
+            else {
+                record.value = record.factory();
+            }
         }
         if (typeof record.value === 'object' &&
             record.value &&
@@ -1185,6 +1384,12 @@ class R3Injector extends EnvironmentInjector {
             return this.injectorDefTypes.has(providedIn);
         }
     }
+    removeOnDestroy(callback) {
+        const destroyCBIdx = this._onDestroyHooks.indexOf(callback);
+        if (destroyCBIdx !== -1) {
+            this._onDestroyHooks.splice(destroyCBIdx, 1);
+        }
+    }
 }
 function injectableDefOrInjectorDefFactory(token) {
     // Most tokens will have an injectable def directly on them, which specifies a factory directly.
@@ -1196,21 +1401,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 +1446,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 +1467,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 +1486,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 +1503,9 @@ function forEachSingleProvider(providers, fn) {
         if (Array.isArray(provider)) {
             forEachSingleProvider(provider, fn);
         }
+        else if (provider && isEnvironmentProviders(provider)) {
+            forEachSingleProvider(provider.ɵproviders, fn);
+        }
         else {
             fn(provider);
         }
@@ -1324,8 +1521,6 @@ function forEachSingleProvider(providers, fn) {
  */
 /**
  * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
- *
- * @publicApi
  */
 function createInjector(defType, parent = null, additionalProviders = null, name) {
     const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
@@ -1338,7 +1533,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);
 }
@@ -1356,7 +1554,7 @@ function createInjectorWithoutInjectorInstances(defType, parent = null, addition
  * dependencies of various types with [injection tokens](guide/glossary#di-token).
  *
  * @see ["DI Providers"](guide/dependency-injection-providers).
- * @see `StaticProvider`
+ * @see {@link StaticProvider}
  *
  * @usageNotes
  *
@@ -1375,38 +1573,30 @@ function createInjectorWithoutInjectorInstances(defType, parent = null, addition
  * @publicApi
  */
 class Injector {
+    static THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
+    static NULL = new NullInjector();
     static create(options, parent) {
-        var _a;
         if (Array.isArray(options)) {
             return createInjector({ name: '' }, parent, options, '');
         }
         else {
-            const name = (_a = options.name) !== null && _a !== void 0 ? _a : '';
+            const name = options.name ?? '';
             return createInjector({ name }, options.parent, options.providers, name);
         }
     }
+    /** @nocollapse */
+    static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({
+        token: Injector,
+        providedIn: 'any',
+        factory: () => ɵɵinject(INJECTOR),
+    });
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static __NG_ELEMENT_ID__ = -1 /* InjectorMarkers.Injector */;
 }
-Injector.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
-Injector.NULL = new NullInjector();
-/** @nocollapse */
-Injector.ɵprov = ɵɵdefineInjectable({
-    token: Injector,
-    providedIn: 'any',
-    factory: () => ɵɵinject(INJECTOR),
-});
-/**
- * @internal
- * @nocollapse
- */
-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 +1666,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,19 +1676,20 @@ 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;
 exports.formatError = formatError;
+exports.getCurrentInjector = getCurrentInjector;
 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 +1697,4 @@ exports["ɵɵdefineInjector"] = ɵɵdefineInjector;
 exports["ɵɵgetInheritedFactory"] = ɵɵgetInheritedFactory;
 exports["ɵɵinject"] = ɵɵinject;
 exports["ɵɵinvalidFactory"] = ɵɵinvalidFactory;
+exports["ɵɵinvalidFactoryDep"] = ɵɵinvalidFactoryDep;