static-injector 2.1.1 → 2.2.1

package/import/commonjs/index.js

@@ -108,9 +108,11 @@ function makeParamDecorator(name, props, parentClass) {
  *
  * 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.
+ * `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;
@@ -125,7 +127,7 @@ function formatRuntimeError(code, message) {
     // 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() : ''}`;
+    let errorMessage = `${fullCode}${message ? ': ' + message : ''}`;
     if (false) {
     }
     return errorMessage;
@@ -195,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) {
@@ -217,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) {
@@ -262,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.
@@ -325,27 +355,12 @@ function getOwnDefinition(type, field) {
 function getInheritedInjectableDef(type) {
     const def = type && (type[NG_PROV_DEF] || null);
     if (def) {
-        const typeName = getTypeName(type);
         return def;
     }
     else {
         return null;
     }
 }
-/** 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.
  *
@@ -374,7 +389,7 @@ const NG_INJ_DEF = getClosureSafeProperty({
  * 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) {
@@ -466,6 +481,9 @@ const SOURCE = '__source';
  * - Injector instance: Use the injector for resolution.
  */
 let _currentInjector = undefined;
+function getCurrentInjector() {
+    return _currentInjector;
+}
 function setCurrentInjector(injector) {
     const former = _currentInjector;
     _currentInjector = injector;
@@ -479,7 +497,8 @@ function injectInjectorOnly(token, flags = exports.InjectFlags.Default) {
         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) {
@@ -499,13 +518,14 @@ function ɵɵinvalidFactoryDep(index) {
 }
 /**
  * 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.
@@ -730,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
@@ -802,7 +833,7 @@ if (false) {
  * (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.
+ * 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
@@ -827,6 +858,10 @@ if (false) {
  * @publicApi
  */
 class InjectionToken {
+    _desc;
+    /** @internal */
+    ngMetadataName = 'InjectionToken';
+    ɵprov;
     /**
      * @param _desc   Description for the token,
      *                used only for debugging purposes,
@@ -835,8 +870,6 @@ class InjectionToken {
      */
     constructor(_desc, options) {
         this._desc = _desc;
-        /** @internal */
-        this.ngMetadataName = 'InjectionToken';
         this.ɵprov = undefined;
         if (typeof options == 'number') {
         }
@@ -942,7 +975,7 @@ class NullInjector {
  */
 /**
  * Wrap an array of `Provider`s into `EnvironmentProviders`, preventing them from being accidentally
- * referenced in `@Component in a component injector.
+ * referenced in `@Component` in a component injector.
  */
 function makeEnvironmentProviders(providers) {
     return {
@@ -999,9 +1032,12 @@ 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, providersOut);
+        processInjectorTypesWithProviders(injectorTypesWithProviders, collectProviders);
     }
     return providersOut;
 }
@@ -1009,145 +1045,11 @@ function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
  * Collects all providers from the list of `ModuleWithProviders` and appends them to the provided
  * array.
  */
-function processInjectorTypesWithProviders(typesWithProviders, providersOut) {
+function processInjectorTypesWithProviders(typesWithProviders, visitor) {
     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,
@@ -1218,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.
@@ -1272,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();
             }
         }
@@ -1281,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();
         }
@@ -1301,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 {
@@ -1370,6 +1288,8 @@ 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) {
@@ -1408,6 +1328,8 @@ 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.
@@ -1437,7 +1359,11 @@ class R3Injector extends EnvironmentInjector {
         }
         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 &&
@@ -1458,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.
@@ -1589,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);
@@ -1624,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
  *
@@ -1643,30 +1573,29 @@ 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 */;
 
 /**
  * Throws an error indicating that a factory function could not be generated by the compiler for a
@@ -1751,6 +1680,7 @@ exports.attachInjectFlag = attachInjectFlag;
 exports.catchInjectorError = catchInjectorError;
 exports.convertToBitFlags = convertToBitFlags;
 exports.formatError = formatError;
+exports.getCurrentInjector = getCurrentInjector;
 exports.getInheritedInjectableDef = getInheritedInjectableDef;
 exports.getInjectFlag = getInjectFlag;
 exports.getInjectableDef = getInjectableDef;

package/import/{es2015 → es2022}/di/create_injector.js

@@ -11,8 +11,6 @@ import { importProvidersFrom } from './provider_collection';
 import { getNullInjector, R3Injector } from './r3_injector';
 /**
  * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
- *
- * @publicApi
  */
 export function createInjector(defType, parent = null, additionalProviders = null, name) {
     const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);

package/import/{es2015 → es2022}/di/forward_ref.js

@@ -17,9 +17,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
  */
 export function forwardRef(forwardRefFn) {
@@ -39,7 +66,7 @@ export function forwardRef(forwardRefFn) {
  *
  * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}
  *
- * @see `forwardRef`
+ * @see {@link forwardRef}
  * @publicApi
  */
 export function resolveForwardRef(type) {

package/import/{es2015 → es2022}/di/injection_token.js

@@ -26,7 +26,7 @@ import { ɵɵdefineInjectable } from './interface/defs';
  * (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.
+ * 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
@@ -51,6 +51,10 @@ import { ɵɵdefineInjectable } from './interface/defs';
  * @publicApi
  */
 export class InjectionToken {
+    _desc;
+    /** @internal */
+    ngMetadataName = 'InjectionToken';
+    ɵprov;
     /**
      * @param _desc   Description for the token,
      *                used only for debugging purposes,
@@ -59,8 +63,6 @@ export class InjectionToken {
      */
     constructor(_desc, options) {
         this._desc = _desc;
-        /** @internal */
-        this.ngMetadataName = 'InjectionToken';
         this.ɵprov = undefined;
         if (typeof options == 'number') {
         }