@angular/core 13.0.0-next.9 → 13.0.0-rc.3

package/esm2020/src/di/injectable.mjs

@@ -0,0 +1,27 @@
+import { makeDecorator } from '../util/decorators';
+import { getInjectableDef, ɵɵdefineInjectable } from './interface/defs';
+import { compileInjectable as render3CompileInjectable } from './jit/injectable';
+import { convertInjectableProviderToFactory } from './util';
+/**
+ * Injectable decorator and metadata.
+ *
+ * @Annotation
+ * @publicApi
+ */
+export const Injectable = makeDecorator('Injectable', undefined, undefined, undefined, (type, meta) => SWITCH_COMPILE_INJECTABLE(type, meta));
+/**
+ * Supports @Injectable() in JIT mode for Render2.
+ */
+function render2CompileInjectable(injectableType, options) {
+    if (options && options.providedIn !== undefined && !getInjectableDef(injectableType)) {
+        injectableType.ɵprov = ɵɵdefineInjectable({
+            token: injectableType,
+            providedIn: options.providedIn,
+            factory: convertInjectableProviderToFactory(injectableType, options),
+        });
+    }
+}
+export const SWITCH_COMPILE_INJECTABLE__POST_R3__ = render3CompileInjectable;
+const SWITCH_COMPILE_INJECTABLE__PRE_R3__ = render2CompileInjectable;
+const SWITCH_COMPILE_INJECTABLE = SWITCH_COMPILE_INJECTABLE__POST_R3__;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/di/injection_token.mjs

@@ -0,0 +1,82 @@
+/**
+ * @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
+ */
+import { assertLessThan } from '../util/assert';
+import { ɵɵdefineInjectable } from './interface/defs';
+/**
+ * Creates a token that can be used in a DI Provider.
+ *
+ * Use an `InjectionToken` whenever the type you are injecting is not reified (does not have a
+ * runtime representation) such as when injecting an interface, callable type, array or
+ * parameterized type.
+ *
+ * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by
+ * the `Injector`. This provides an additional level of type safety.
+ *
+ * ```
+ * interface MyInterface {...}
+ * const myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));
+ * // myInterface is inferred to be MyInterface.
+ * ```
+ *
+ * When creating an `InjectionToken`, you can optionally specify a factory function which returns
+ * (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.
+ * 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`.
+ *
+ * @usageNotes
+ * ### Basic Examples
+ *
+ * ### Plain InjectionToken
+ *
+ * {@example core/di/ts/injector_spec.ts region='InjectionToken'}
+ *
+ * ### Tree-shakable InjectionToken
+ *
+ * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}
+ *
+ *
+ * @publicApi
+ */
+export 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.__NG_ELEMENT_ID__ = options;
+        }
+        else if (options !== undefined) {
+            this.ɵprov = ɵɵdefineInjectable({
+                token: this,
+                providedIn: options.providedIn || 'root',
+                factory: options.factory,
+            });
+        }
+    }
+    toString() {
+        return `InjectionToken ${this._desc}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/di/injector.mjs

@@ -0,0 +1,323 @@
+/**
+ * @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
+ */
+import { stringify } from '../util/stringify';
+import { resolveForwardRef } from './forward_ref';
+import { catchInjectorError, formatError, NG_TEMP_TOKEN_PATH, setCurrentInjector, THROW_IF_NOT_FOUND, USE_VALUE, ɵɵinject } from './injector_compatibility';
+import { INJECTOR } from './injector_token';
+import { getInjectableDef, ɵɵdefineInjectable } from './interface/defs';
+import { InjectFlags } from './interface/injector';
+import { Inject, Optional, Self, SkipSelf } from './metadata';
+import { NullInjector } from './null_injector';
+import { createInjector } from './r3_injector';
+import { INJECTOR_SCOPE } from './scope';
+export function INJECTOR_IMPL__PRE_R3__(providers, parent, name) {
+    return new StaticInjector(providers, parent, name);
+}
+export function INJECTOR_IMPL__POST_R3__(providers, parent, name) {
+    return createInjector({ name: name }, parent, providers, name);
+}
+export const INJECTOR_IMPL = INJECTOR_IMPL__POST_R3__;
+/**
+ * Concrete injectors implement this interface. Injectors are configured
+ * with [providers](guide/glossary#provider) that associate
+ * dependencies of various types with [injection tokens](guide/glossary#di-token).
+ *
+ * @see ["DI Providers"](guide/dependency-injection-providers).
+ * @see `StaticProvider`
+ *
+ * @usageNotes
+ *
+ *  The following example creates a service injector instance.
+ *
+ * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}
+ *
+ * ### Usage example
+ *
+ * {@example core/di/ts/injector_spec.ts region='Injector'}
+ *
+ * `Injector` returns itself when given `Injector` as a token:
+ *
+ * {@example core/di/ts/injector_spec.ts region='injectInjector'}
+ *
+ * @publicApi
+ */
+export class Injector {
+    static create(options, parent) {
+        if (Array.isArray(options)) {
+            return INJECTOR_IMPL(options, parent, '');
+        }
+        else {
+            return INJECTOR_IMPL(options.providers, options.parent, options.name || '');
+        }
+    }
+}
+Injector.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
+Injector.NULL = ( /* @__PURE__ */new NullInjector());
+/** @nocollapse */
+Injector.ɵprov = ɵɵdefineInjectable({
+    token: Injector,
+    providedIn: 'any',
+    factory: () => ɵɵinject(INJECTOR),
+});
+/**
+ * @internal
+ * @nocollapse
+ */
+Injector.__NG_ELEMENT_ID__ = -1 /* Injector */;
+const IDENT = function (value) {
+    return value;
+};
+const EMPTY = [];
+const CIRCULAR = IDENT;
+const MULTI_PROVIDER_FN = function () {
+    return Array.prototype.slice.call(arguments);
+};
+const NO_NEW_LINE = 'ɵ';
+export class StaticInjector {
+    constructor(providers, parent = Injector.NULL, source = null) {
+        this.parent = parent;
+        this.source = source;
+        const records = this._records = new Map();
+        records.set(Injector, { token: Injector, fn: IDENT, deps: EMPTY, value: this, useNew: false });
+        records.set(INJECTOR, { token: INJECTOR, fn: IDENT, deps: EMPTY, value: this, useNew: false });
+        this.scope = recursivelyProcessProviders(records, providers);
+    }
+    get(token, notFoundValue, flags = InjectFlags.Default) {
+        const records = this._records;
+        let record = records.get(token);
+        if (record === undefined) {
+            // This means we have never seen this record, see if it is tree shakable provider.
+            const injectableDef = getInjectableDef(token);
+            if (injectableDef) {
+                const providedIn = injectableDef && resolveForwardRef(injectableDef.providedIn);
+                if (providedIn === 'any' || providedIn != null && providedIn === this.scope) {
+                    records.set(token, record = resolveProvider({ provide: token, useFactory: injectableDef.factory, deps: EMPTY }));
+                }
+            }
+            if (record === undefined) {
+                // Set record to null to make sure that we don't go through expensive lookup above again.
+                records.set(token, null);
+            }
+        }
+        let lastInjector = setCurrentInjector(this);
+        try {
+            return tryResolveToken(token, record, records, this.parent, notFoundValue, flags);
+        }
+        catch (e) {
+            return catchInjectorError(e, token, 'StaticInjectorError', this.source);
+        }
+        finally {
+            setCurrentInjector(lastInjector);
+        }
+    }
+    toString() {
+        const tokens = [], records = this._records;
+        records.forEach((v, token) => tokens.push(stringify(token)));
+        return `StaticInjector[${tokens.join(', ')}]`;
+    }
+}
+function resolveProvider(provider) {
+    const deps = computeDeps(provider);
+    let fn = IDENT;
+    let value = EMPTY;
+    let useNew = false;
+    let provide = resolveForwardRef(provider.provide);
+    if (USE_VALUE in provider) {
+        // We need to use USE_VALUE in provider since provider.useValue could be defined as undefined.
+        value = provider.useValue;
+    }
+    else if (provider.useFactory) {
+        fn = provider.useFactory;
+    }
+    else if (provider.useExisting) {
+        // Just use IDENT
+    }
+    else if (provider.useClass) {
+        useNew = true;
+        fn = resolveForwardRef(provider.useClass);
+    }
+    else if (typeof provide == 'function') {
+        useNew = true;
+        fn = provide;
+    }
+    else {
+        throw staticError('StaticProvider does not have [useValue|useFactory|useExisting|useClass] or [provide] is not newable', provider);
+    }
+    return { deps, fn, useNew, value };
+}
+function multiProviderMixError(token) {
+    return staticError('Cannot mix multi providers and regular providers', token);
+}
+function recursivelyProcessProviders(records, provider) {
+    let scope = null;
+    if (provider) {
+        provider = resolveForwardRef(provider);
+        if (Array.isArray(provider)) {
+            // if we have an array recurse into the array
+            for (let i = 0; i < provider.length; i++) {
+                scope = recursivelyProcessProviders(records, provider[i]) || scope;
+            }
+        }
+        else if (typeof provider === 'function') {
+            // Functions were supported in ReflectiveInjector, but are not here. For safety give useful
+            // error messages
+            throw staticError('Function/Class not supported', provider);
+        }
+        else if (provider && typeof provider === 'object' && provider.provide) {
+            // At this point we have what looks like a provider: {provide: ?, ....}
+            let token = resolveForwardRef(provider.provide);
+            const resolvedProvider = resolveProvider(provider);
+            if (provider.multi === true) {
+                // This is a multi provider.
+                let multiProvider = records.get(token);
+                if (multiProvider) {
+                    if (multiProvider.fn !== MULTI_PROVIDER_FN) {
+                        throw multiProviderMixError(token);
+                    }
+                }
+                else {
+                    // Create a placeholder factory which will look up the constituents of the multi provider.
+                    records.set(token, multiProvider = {
+                        token: provider.provide,
+                        deps: [],
+                        useNew: false,
+                        fn: MULTI_PROVIDER_FN,
+                        value: EMPTY
+                    });
+                }
+                // Treat the provider as the token.
+                token = provider;
+                multiProvider.deps.push({ token, options: 6 /* Default */ });
+            }
+            const record = records.get(token);
+            if (record && record.fn == MULTI_PROVIDER_FN) {
+                throw multiProviderMixError(token);
+            }
+            if (token === INJECTOR_SCOPE) {
+                scope = resolvedProvider.value;
+            }
+            records.set(token, resolvedProvider);
+        }
+        else {
+            throw staticError('Unexpected provider', provider);
+        }
+    }
+    return scope;
+}
+function tryResolveToken(token, record, records, parent, notFoundValue, flags) {
+    try {
+        return resolveToken(token, record, records, parent, notFoundValue, flags);
+    }
+    catch (e) {
+        // ensure that 'e' is of type Error.
+        if (!(e instanceof Error)) {
+            e = new Error(e);
+        }
+        const path = e[NG_TEMP_TOKEN_PATH] = e[NG_TEMP_TOKEN_PATH] || [];
+        path.unshift(token);
+        if (record && record.value == CIRCULAR) {
+            // Reset the Circular flag.
+            record.value = EMPTY;
+        }
+        throw e;
+    }
+}
+function resolveToken(token, record, records, parent, notFoundValue, flags) {
+    let value;
+    if (record && !(flags & InjectFlags.SkipSelf)) {
+        // If we don't have a record, this implies that we don't own the provider hence don't know how
+        // to resolve it.
+        value = record.value;
+        if (value == CIRCULAR) {
+            throw Error(NO_NEW_LINE + 'Circular dependency');
+        }
+        else if (value === EMPTY) {
+            record.value = CIRCULAR;
+            let obj = undefined;
+            let useNew = record.useNew;
+            let fn = record.fn;
+            let depRecords = record.deps;
+            let deps = EMPTY;
+            if (depRecords.length) {
+                deps = [];
+                for (let i = 0; i < depRecords.length; i++) {
+                    const depRecord = depRecords[i];
+                    const options = depRecord.options;
+                    const childRecord = options & 2 /* CheckSelf */ ? records.get(depRecord.token) : undefined;
+                    deps.push(tryResolveToken(
+                    // Current Token to resolve
+                    depRecord.token, 
+                    // A record which describes how to resolve the token.
+                    // If undefined, this means we don't have such a record
+                    childRecord, 
+                    // Other records we know about.
+                    records, 
+                    // If we don't know how to resolve dependency and we should not check parent for it,
+                    // than pass in Null injector.
+                    !childRecord && !(options & 4 /* CheckParent */) ? Injector.NULL : parent, options & 1 /* Optional */ ? null : Injector.THROW_IF_NOT_FOUND, InjectFlags.Default));
+                }
+            }
+            record.value = value = useNew ? new fn(...deps) : fn.apply(obj, deps);
+        }
+    }
+    else if (!(flags & InjectFlags.Self)) {
+        value = parent.get(token, notFoundValue, InjectFlags.Default);
+    }
+    else if (!(flags & InjectFlags.Optional)) {
+        value = Injector.NULL.get(token, notFoundValue);
+    }
+    else {
+        value = Injector.NULL.get(token, typeof notFoundValue !== 'undefined' ? notFoundValue : null);
+    }
+    return value;
+}
+function computeDeps(provider) {
+    let deps = EMPTY;
+    const providerDeps = provider.deps;
+    if (providerDeps && providerDeps.length) {
+        deps = [];
+        for (let i = 0; i < providerDeps.length; i++) {
+            let options = 6 /* Default */;
+            let token = resolveForwardRef(providerDeps[i]);
+            if (Array.isArray(token)) {
+                for (let j = 0, annotations = token; j < annotations.length; j++) {
+                    const annotation = annotations[j];
+                    if (annotation instanceof Optional || annotation == Optional) {
+                        options = options | 1 /* Optional */;
+                    }
+                    else if (annotation instanceof SkipSelf || annotation == SkipSelf) {
+                        options = options & ~2 /* CheckSelf */;
+                    }
+                    else if (annotation instanceof Self || annotation == Self) {
+                        options = options & ~4 /* CheckParent */;
+                    }
+                    else if (annotation instanceof Inject) {
+                        token = annotation.token;
+                    }
+                    else {
+                        token = resolveForwardRef(annotation);
+                    }
+                }
+            }
+            deps.push({ token, options });
+        }
+    }
+    else if (provider.useExisting) {
+        const token = resolveForwardRef(provider.useExisting);
+        deps = [{ token, options: 6 /* Default */ }];
+    }
+    else if (!providerDeps && !(USE_VALUE in provider)) {
+        // useValue & useExisting are the only ones which are exempt from deps all others need it.
+        throw staticError('\'deps\' required', provider);
+    }
+    return deps;
+}
+function staticError(text, obj) {
+    return new Error(formatError(text, obj, 'StaticInjectorError'));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"injector.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/di/injector.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {stringify} from '../util/stringify';\n\nimport {resolveForwardRef} from './forward_ref';\nimport {catchInjectorError, formatError, NG_TEMP_TOKEN_PATH, setCurrentInjector, THROW_IF_NOT_FOUND, USE_VALUE, ɵɵinject} from './injector_compatibility';\nimport {InjectorMarkers} from './injector_marker';\nimport {INJECTOR} from './injector_token';\nimport {getInjectableDef, ɵɵdefineInjectable} from './interface/defs';\nimport {InjectFlags} from './interface/injector';\nimport {ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, StaticProvider, ValueProvider} from './interface/provider';\nimport {Inject, Optional, Self, SkipSelf} from './metadata';\nimport {NullInjector} from './null_injector';\nimport {ProviderToken} from './provider_token';\nimport {createInjector} from './r3_injector';\nimport {INJECTOR_SCOPE} from './scope';\n\nexport function INJECTOR_IMPL__PRE_R3__(\n    providers: StaticProvider[], parent: Injector|undefined, name: string) {\n  return new StaticInjector(providers, parent, name);\n}\n\nexport function INJECTOR_IMPL__POST_R3__(\n    providers: StaticProvider[], parent: Injector|undefined, name: string) {\n  return createInjector({name: name}, parent, providers, name);\n}\n\nexport const INJECTOR_IMPL = INJECTOR_IMPL__PRE_R3__;\n\n/**\n * Concrete injectors implement this interface. Injectors are configured\n * with [providers](guide/glossary#provider) that associate\n * dependencies of various types with [injection tokens](guide/glossary#di-token).\n *\n * @see [\"DI Providers\"](guide/dependency-injection-providers).\n * @see `StaticProvider`\n *\n * @usageNotes\n *\n *  The following example creates a service injector instance.\n *\n * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}\n *\n * ### Usage example\n *\n * {@example core/di/ts/injector_spec.ts region='Injector'}\n *\n * `Injector` returns itself when given `Injector` as a token:\n *\n * {@example core/di/ts/injector_spec.ts region='injectInjector'}\n *\n * @publicApi\n */\nexport abstract class Injector {\n  static THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;\n  static NULL: Injector = (/* @__PURE__ */ new NullInjector());\n\n  /**\n   * Retrieves an instance from the injector based on the provided token.\n   * @returns The instance from the injector if defined, otherwise the `notFoundValue`.\n   * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.\n   */\n  abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;\n  /**\n   * @deprecated from v4.0.0 use ProviderToken<T>\n   * @suppress {duplicate}\n   */\n  abstract get(token: any, notFoundValue?: any): any;\n\n  /**\n   * @deprecated from v5 use the new signature Injector.create(options)\n   */\n  static create(providers: StaticProvider[], parent?: Injector): Injector;\n\n  /**\n   * Creates a new injector instance that provides one or more dependencies,\n   * according to a given type or types of `StaticProvider`.\n   *\n   * @param options An object with the following properties:\n   * * `providers`: An array of providers of the [StaticProvider type](api/core/StaticProvider).\n   * * `parent`: (optional) A parent injector.\n   * * `name`: (optional) A developer-defined identifying name for the new injector.\n   *\n   * @returns The new injector instance.\n   *\n   */\n  static create(options: {providers: StaticProvider[], parent?: Injector, name?: string}): Injector;\n\n\n  static create(\n      options: StaticProvider[]|{providers: StaticProvider[], parent?: Injector, name?: string},\n      parent?: Injector): Injector {\n    if (Array.isArray(options)) {\n      return INJECTOR_IMPL(options, parent, '');\n    } else {\n      return INJECTOR_IMPL(options.providers, options.parent, options.name || '');\n    }\n  }\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({\n    token: Injector,\n    providedIn: 'any',\n    factory: () => ɵɵinject(INJECTOR),\n  });\n\n  /**\n   * @internal\n   * @nocollapse\n   */\n  static __NG_ELEMENT_ID__ = InjectorMarkers.Injector;\n}\n\n\n\nconst IDENT = function<T>(value: T): T {\n  return value;\n};\nconst EMPTY = <any[]>[];\nconst CIRCULAR = IDENT;\nconst MULTI_PROVIDER_FN = function(): any[] {\n  return Array.prototype.slice.call(arguments);\n};\n\nconst enum OptionFlags {\n  Optional = 1 << 0,\n  CheckSelf = 1 << 1,\n  CheckParent = 1 << 2,\n  Default = CheckSelf | CheckParent\n}\nconst NO_NEW_LINE = 'ɵ';\n\nexport class StaticInjector implements Injector {\n  readonly parent: Injector;\n  readonly source: string|null;\n  readonly scope: string|null;\n\n  private _records: Map<any, Record|null>;\n\n  constructor(\n      providers: StaticProvider[], parent: Injector = Injector.NULL, source: string|null = null) {\n    this.parent = parent;\n    this.source = source;\n    const records = this._records = new Map<any, Record>();\n    records.set(\n        Injector, <Record>{token: Injector, fn: IDENT, deps: EMPTY, value: this, useNew: false});\n    records.set(\n        INJECTOR, <Record>{token: INJECTOR, fn: IDENT, deps: EMPTY, value: this, useNew: false});\n    this.scope = recursivelyProcessProviders(records, providers);\n  }\n\n  get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;\n  get(token: any, notFoundValue?: any): any;\n  get(token: any, notFoundValue?: any, flags: InjectFlags = InjectFlags.Default): any {\n    const records = this._records;\n    let record = records.get(token);\n    if (record === undefined) {\n      // This means we have never seen this record, see if it is tree shakable provider.\n      const injectableDef = getInjectableDef(token);\n      if (injectableDef) {\n        const providedIn = injectableDef && resolveForwardRef(injectableDef.providedIn);\n        if (providedIn === 'any' || providedIn != null && providedIn === this.scope) {\n          records.set(\n              token,\n              record = resolveProvider(\n                  {provide: token, useFactory: injectableDef.factory, deps: EMPTY}));\n        }\n      }\n      if (record === undefined) {\n        // Set record to null to make sure that we don't go through expensive lookup above again.\n        records.set(token, null);\n      }\n    }\n    let lastInjector = setCurrentInjector(this);\n    try {\n      return tryResolveToken(token, record, records, this.parent, notFoundValue, flags);\n    } catch (e) {\n      return catchInjectorError(e, token, 'StaticInjectorError', this.source);\n    } finally {\n      setCurrentInjector(lastInjector);\n    }\n  }\n\n  toString() {\n    const tokens = <string[]>[], records = this._records;\n    records.forEach((v, token) => tokens.push(stringify(token)));\n    return `StaticInjector[${tokens.join(', ')}]`;\n  }\n}\n\ntype SupportedProvider =\n    ValueProvider|ExistingProvider|StaticClassProvider|ConstructorProvider|FactoryProvider;\n\ninterface Record {\n  fn: Function;\n  useNew: boolean;\n  deps: DependencyRecord[];\n  value: any;\n}\n\ninterface DependencyRecord {\n  token: any;\n  options: number;\n}\n\nfunction resolveProvider(provider: SupportedProvider): Record {\n  const deps = computeDeps(provider);\n  let fn: Function = IDENT;\n  let value: any = EMPTY;\n  let useNew: boolean = false;\n  let provide = resolveForwardRef(provider.provide);\n  if (USE_VALUE in provider) {\n    // We need to use USE_VALUE in provider since provider.useValue could be defined as undefined.\n    value = (provider as ValueProvider).useValue;\n  } else if ((provider as FactoryProvider).useFactory) {\n    fn = (provider as FactoryProvider).useFactory;\n  } else if ((provider as ExistingProvider).useExisting) {\n    // Just use IDENT\n  } else if ((provider as StaticClassProvider).useClass) {\n    useNew = true;\n    fn = resolveForwardRef((provider as StaticClassProvider).useClass);\n  } else if (typeof provide == 'function') {\n    useNew = true;\n    fn = provide;\n  } else {\n    throw staticError(\n        'StaticProvider does not have [useValue|useFactory|useExisting|useClass] or [provide] is not newable',\n        provider);\n  }\n  return {deps, fn, useNew, value};\n}\n\nfunction multiProviderMixError(token: any) {\n  return staticError('Cannot mix multi providers and regular providers', token);\n}\n\nfunction recursivelyProcessProviders(records: Map<any, Record>, provider: StaticProvider): string|\n    null {\n  let scope: string|null = null;\n  if (provider) {\n    provider = resolveForwardRef(provider);\n    if (Array.isArray(provider)) {\n      // if we have an array recurse into the array\n      for (let i = 0; i < provider.length; i++) {\n        scope = recursivelyProcessProviders(records, provider[i]) || scope;\n      }\n    } else if (typeof provider === 'function') {\n      // Functions were supported in ReflectiveInjector, but are not here. For safety give useful\n      // error messages\n      throw staticError('Function/Class not supported', provider);\n    } else if (provider && typeof provider === 'object' && provider.provide) {\n      // At this point we have what looks like a provider: {provide: ?, ....}\n      let token = resolveForwardRef(provider.provide);\n      const resolvedProvider = resolveProvider(provider);\n      if (provider.multi === true) {\n        // This is a multi provider.\n        let multiProvider: Record|undefined = records.get(token);\n        if (multiProvider) {\n          if (multiProvider.fn !== MULTI_PROVIDER_FN) {\n            throw multiProviderMixError(token);\n          }\n        } else {\n          // Create a placeholder factory which will look up the constituents of the multi provider.\n          records.set(token, multiProvider = <Record>{\n            token: provider.provide,\n            deps: [],\n            useNew: false,\n            fn: MULTI_PROVIDER_FN,\n            value: EMPTY\n          });\n        }\n        // Treat the provider as the token.\n        token = provider;\n        multiProvider.deps.push({token, options: OptionFlags.Default});\n      }\n      const record = records.get(token);\n      if (record && record.fn == MULTI_PROVIDER_FN) {\n        throw multiProviderMixError(token);\n      }\n      if (token === INJECTOR_SCOPE) {\n        scope = resolvedProvider.value;\n      }\n      records.set(token, resolvedProvider);\n    } else {\n      throw staticError('Unexpected provider', provider);\n    }\n  }\n  return scope;\n}\n\nfunction tryResolveToken(\n    token: any, record: Record|undefined|null, records: Map<any, Record|null>, parent: Injector,\n    notFoundValue: any, flags: InjectFlags): any {\n  try {\n    return resolveToken(token, record, records, parent, notFoundValue, flags);\n  } catch (e) {\n    // ensure that 'e' is of type Error.\n    if (!(e instanceof Error)) {\n      e = new Error(e);\n    }\n    const path: any[] = e[NG_TEMP_TOKEN_PATH] = e[NG_TEMP_TOKEN_PATH] || [];\n    path.unshift(token);\n    if (record && record.value == CIRCULAR) {\n      // Reset the Circular flag.\n      record.value = EMPTY;\n    }\n    throw e;\n  }\n}\n\nfunction resolveToken(\n    token: any, record: Record|undefined|null, records: Map<any, Record|null>, parent: Injector,\n    notFoundValue: any, flags: InjectFlags): any {\n  let value;\n  if (record && !(flags & InjectFlags.SkipSelf)) {\n    // If we don't have a record, this implies that we don't own the provider hence don't know how\n    // to resolve it.\n    value = record.value;\n    if (value == CIRCULAR) {\n      throw Error(NO_NEW_LINE + 'Circular dependency');\n    } else if (value === EMPTY) {\n      record.value = CIRCULAR;\n      let obj = undefined;\n      let useNew = record.useNew;\n      let fn = record.fn;\n      let depRecords = record.deps;\n      let deps = EMPTY;\n      if (depRecords.length) {\n        deps = [];\n        for (let i = 0; i < depRecords.length; i++) {\n          const depRecord: DependencyRecord = depRecords[i];\n          const options = depRecord.options;\n          const childRecord =\n              options & OptionFlags.CheckSelf ? records.get(depRecord.token) : undefined;\n          deps.push(tryResolveToken(\n              // Current Token to resolve\n              depRecord.token,\n              // A record which describes how to resolve the token.\n              // If undefined, this means we don't have such a record\n              childRecord,\n              // Other records we know about.\n              records,\n              // If we don't know how to resolve dependency and we should not check parent for it,\n              // than pass in Null injector.\n              !childRecord && !(options & OptionFlags.CheckParent) ? Injector.NULL : parent,\n              options & OptionFlags.Optional ? null : Injector.THROW_IF_NOT_FOUND,\n              InjectFlags.Default));\n        }\n      }\n      record.value = value = useNew ? new (fn as any)(...deps) : fn.apply(obj, deps);\n    }\n  } else if (!(flags & InjectFlags.Self)) {\n    value = parent.get(token, notFoundValue, InjectFlags.Default);\n  } else if (!(flags & InjectFlags.Optional)) {\n    value = Injector.NULL.get(token, notFoundValue);\n  } else {\n    value = Injector.NULL.get(token, typeof notFoundValue !== 'undefined' ? notFoundValue : null);\n  }\n  return value;\n}\n\nfunction computeDeps(provider: StaticProvider): DependencyRecord[] {\n  let deps: DependencyRecord[] = EMPTY;\n  const providerDeps: any[] =\n      (provider as ExistingProvider & StaticClassProvider & ConstructorProvider).deps;\n  if (providerDeps && providerDeps.length) {\n    deps = [];\n    for (let i = 0; i < providerDeps.length; i++) {\n      let options = OptionFlags.Default;\n      let token = resolveForwardRef(providerDeps[i]);\n      if (Array.isArray(token)) {\n        for (let j = 0, annotations = token; j < annotations.length; j++) {\n          const annotation = annotations[j];\n          if (annotation instanceof Optional || annotation == Optional) {\n            options = options | OptionFlags.Optional;\n          } else if (annotation instanceof SkipSelf || annotation == SkipSelf) {\n            options = options & ~OptionFlags.CheckSelf;\n          } else if (annotation instanceof Self || annotation == Self) {\n            options = options & ~OptionFlags.CheckParent;\n          } else if (annotation instanceof Inject) {\n            token = (annotation as Inject).token;\n          } else {\n            token = resolveForwardRef(annotation);\n          }\n        }\n      }\n      deps.push({token, options});\n    }\n  } else if ((provider as ExistingProvider).useExisting) {\n    const token = resolveForwardRef((provider as ExistingProvider).useExisting);\n    deps = [{token, options: OptionFlags.Default}];\n  } else if (!providerDeps && !(USE_VALUE in provider)) {\n    // useValue & useExisting are the only ones which are exempt from deps all others need it.\n    throw staticError('\\'deps\\' required', provider);\n  }\n  return deps;\n}\n\nfunction staticError(text: string, obj: any): Error {\n  return new Error(formatError(text, obj, 'StaticInjectorError'));\n}\n"]}