@angular/core
Version:
Angular - the core framework
539 lines • 51.8 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: packages/core/src/di/injector.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. 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, INJECTOR, NG_TEMP_TOKEN_PATH, NullInjector, setCurrentInjector, THROW_IF_NOT_FOUND, USE_VALUE, ɵɵinject } from './injector_compatibility';
import { getInjectableDef, ɵɵdefineInjectable } from './interface/defs';
import { InjectFlags } from './interface/injector';
import { Inject, Optional, Self, SkipSelf } from './metadata';
import { createInjector } from './r3_injector';
import { INJECTOR_SCOPE } from './scope';
/**
* @param {?} providers
* @param {?} parent
* @param {?} name
* @return {?}
*/
export function INJECTOR_IMPL__PRE_R3__(providers, parent, name) {
return new StaticInjector(providers, parent, name);
}
/**
* @param {?} providers
* @param {?} parent
* @param {?} name
* @return {?}
*/
export function INJECTOR_IMPL__POST_R3__(providers, parent, name) {
return createInjector({ name: name }, parent, providers, name);
}
/** @type {?} */
export const INJECTOR_IMPL = INJECTOR_IMPL__PRE_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
* @abstract
*/
export class Injector {
/**
* @param {?} options
* @param {?=} parent
* @return {?}
*/
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 = new NullInjector();
/** @nocollapse */
Injector.ɵprov = ɵɵdefineInjectable({
token: Injector,
providedIn: (/** @type {?} */ ('any')),
factory: (/**
* @return {?}
*/
() => ɵɵinject(INJECTOR)),
});
/**
* \@internal
* @nocollapse
*/
Injector.__NG_ELEMENT_ID__ = -1;
if (false) {
/** @type {?} */
Injector.THROW_IF_NOT_FOUND;
/** @type {?} */
Injector.NULL;
/**
* @nocollapse
* @type {?}
*/
Injector.ɵprov;
/**
* \@internal
* @nocollapse
* @type {?}
*/
Injector.__NG_ELEMENT_ID__;
/**
* Retrieves an instance from the injector based on the provided token.
* @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
* @abstract
* @template T
* @param {?} token
* @param {?=} notFoundValue
* @param {?=} flags
* @return {?} The instance from the injector if defined, otherwise the `notFoundValue`.
*/
Injector.prototype.get = function (token, notFoundValue, flags) { };
/**
* @deprecated from v4.0.0 use Type<T> or InjectionToken<T>
* @suppress {duplicate}
* @abstract
* @param {?} token
* @param {?=} notFoundValue
* @return {?}
*/
Injector.prototype.get = function (token, notFoundValue) { };
}
/** @type {?} */
const IDENT = (/**
* @template T
* @param {?} value
* @return {?}
*/
function (value) {
return value;
});
const ɵ0 = IDENT;
/** @type {?} */
const EMPTY = (/** @type {?} */ ([]));
/** @type {?} */
const CIRCULAR = IDENT;
/** @type {?} */
const MULTI_PROVIDER_FN = (/**
* @return {?}
*/
function () {
return Array.prototype.slice.call(arguments);
});
const ɵ1 = MULTI_PROVIDER_FN;
/** @enum {number} */
const OptionFlags = {
Optional: 1,
CheckSelf: 2,
CheckParent: 4,
Default: 6,
};
/** @type {?} */
const NO_NEW_LINE = 'ɵ';
export class StaticInjector {
/**
* @param {?} providers
* @param {?=} parent
* @param {?=} source
*/
constructor(providers, parent = Injector.NULL, source = null) {
this.parent = parent;
this.source = source;
/** @type {?} */
const records = this._records = new Map();
records.set(Injector, (/** @type {?} */ ({ token: Injector, fn: IDENT, deps: EMPTY, value: this, useNew: false })));
records.set(INJECTOR, (/** @type {?} */ ({ token: INJECTOR, fn: IDENT, deps: EMPTY, value: this, useNew: false })));
this.scope = recursivelyProcessProviders(records, providers);
}
/**
* @param {?} token
* @param {?=} notFoundValue
* @param {?=} flags
* @return {?}
*/
get(token, notFoundValue, flags = InjectFlags.Default) {
/** @type {?} */
const records = this._records;
/** @type {?} */
let record = records.get(token);
if (record === undefined) {
// This means we have never seen this record, see if it is tree shakable provider.
/** @type {?} */
const injectableDef = getInjectableDef(token);
if (injectableDef) {
/** @type {?} */
const providedIn = injectableDef && 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);
}
}
/** @type {?} */
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);
}
}
/**
* @return {?}
*/
toString() {
/** @type {?} */
const tokens = (/** @type {?} */ ([]));
/** @type {?} */
const records = this._records;
records.forEach((/**
* @param {?} v
* @param {?} token
* @return {?}
*/
(v, token) => tokens.push(stringify(token))));
return `StaticInjector[${tokens.join(', ')}]`;
}
}
if (false) {
/** @type {?} */
StaticInjector.prototype.parent;
/** @type {?} */
StaticInjector.prototype.source;
/** @type {?} */
StaticInjector.prototype.scope;
/**
* @type {?}
* @private
*/
StaticInjector.prototype._records;
}
/**
* @record
*/
function Record() { }
if (false) {
/** @type {?} */
Record.prototype.fn;
/** @type {?} */
Record.prototype.useNew;
/** @type {?} */
Record.prototype.deps;
/** @type {?} */
Record.prototype.value;
}
/**
* @record
*/
function DependencyRecord() { }
if (false) {
/** @type {?} */
DependencyRecord.prototype.token;
/** @type {?} */
DependencyRecord.prototype.options;
}
/**
* @param {?} provider
* @return {?}
*/
function resolveProvider(provider) {
/** @type {?} */
const deps = computeDeps(provider);
/** @type {?} */
let fn = IDENT;
/** @type {?} */
let value = EMPTY;
/** @type {?} */
let useNew = false;
/** @type {?} */
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 = ((/** @type {?} */ (provider))).useValue;
}
else if (((/** @type {?} */ (provider))).useFactory) {
fn = ((/** @type {?} */ (provider))).useFactory;
}
else if (((/** @type {?} */ (provider))).useExisting) {
// Just use IDENT
}
else if (((/** @type {?} */ (provider))).useClass) {
useNew = true;
fn = resolveForwardRef(((/** @type {?} */ (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 };
}
/**
* @param {?} token
* @return {?}
*/
function multiProviderMixError(token) {
return staticError('Cannot mix multi providers and regular providers', token);
}
/**
* @param {?} records
* @param {?} provider
* @return {?}
*/
function recursivelyProcessProviders(records, provider) {
/** @type {?} */
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: ?, ....}
/** @type {?} */
let token = resolveForwardRef(provider.provide);
/** @type {?} */
const resolvedProvider = resolveProvider(provider);
if (provider.multi === true) {
// This is a multi provider.
/** @type {?} */
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 = (/** @type {?} */ ({
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 */ });
}
/** @type {?} */
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;
}
/**
* @param {?} token
* @param {?} record
* @param {?} records
* @param {?} parent
* @param {?} notFoundValue
* @param {?} flags
* @return {?}
*/
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);
}
/** @type {?} */
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;
}
}
/**
* @param {?} token
* @param {?} record
* @param {?} records
* @param {?} parent
* @param {?} notFoundValue
* @param {?} flags
* @return {?}
*/
function resolveToken(token, record, records, parent, notFoundValue, flags) {
/** @type {?} */
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;
/** @type {?} */
let obj = undefined;
/** @type {?} */
let useNew = record.useNew;
/** @type {?} */
let fn = record.fn;
/** @type {?} */
let depRecords = record.deps;
/** @type {?} */
let deps = EMPTY;
if (depRecords.length) {
deps = [];
for (let i = 0; i < depRecords.length; i++) {
/** @type {?} */
const depRecord = depRecords[i];
/** @type {?} */
const options = depRecord.options;
/** @type {?} */
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 ((/** @type {?} */ (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;
}
/**
* @param {?} provider
* @return {?}
*/
function computeDeps(provider) {
/** @type {?} */
let deps = EMPTY;
/** @type {?} */
const providerDeps = ((/** @type {?} */ (provider))).deps;
if (providerDeps && providerDeps.length) {
deps = [];
for (let i = 0; i < providerDeps.length; i++) {
/** @type {?} */
let options = 6 /* Default */;
/** @type {?} */
let token = resolveForwardRef(providerDeps[i]);
if (Array.isArray(token)) {
for (let j = 0, annotations = token; j < annotations.length; j++) {
/** @type {?} */
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 = ((/** @type {?} */ (annotation))).token;
}
else {
token = resolveForwardRef(annotation);
}
}
}
deps.push({ token, options });
}
}
else if (((/** @type {?} */ (provider))).useExisting) {
/** @type {?} */
const token = resolveForwardRef(((/** @type {?} */ (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;
}
/**
* @param {?} text
* @param {?} obj
* @return {?}
*/
function staticError(text, obj) {
return new Error(formatError(text, obj, 'StaticInjectorError'));
}
export { ɵ0, ɵ1 };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"injector.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/di/injector.ts"],"names":[],"mappings":";;;;;;;;;;;;AASA,OAAO,EAAC,SAAS,EAAC,MAAM,mBAAmB,CAAC;AAE5C,OAAO,EAAC,iBAAiB,EAAC,MAAM,eAAe,CAAC;AAEhD,OAAO,EAAC,kBAAkB,EAAE,WAAW,EAAE,QAAQ,EAAE,kBAAkB,EAAE,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,SAAS,EAAE,QAAQ,EAAC,MAAM,0BAA0B,CAAC;AAClL,OAAO,EAAC,gBAAgB,EAAE,kBAAkB,EAAC,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAC,WAAW,EAAC,MAAM,sBAAsB,CAAC;AAEjD,OAAO,EAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAC,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAC,cAAc,EAAC,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAC,cAAc,EAAC,MAAM,SAAS,CAAC;;;;;;;AAEvC,MAAM,UAAU,uBAAuB,CACnC,SAA2B,EAAE,MAA0B,EAAE,IAAY;IACvE,OAAO,IAAI,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;AACrD,CAAC;;;;;;;AAED,MAAM,UAAU,wBAAwB,CACpC,SAA2B,EAAE,MAA0B,EAAE,IAAY;IACvE,OAAO,cAAc,CAAC,EAAC,IAAI,EAAE,IAAI,EAAC,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;AAC/D,CAAC;;AAED,MAAM,OAAO,aAAa,GAAG,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BpD,MAAM,OAAgB,QAAQ;;;;;;IAqC5B,MAAM,CAAC,MAAM,CACT,OAAyF,EACzF,MAAiB;QACnB,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YAC1B,OAAO,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;SAC3C;aAAM;YACL,OAAO,aAAa,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;SAC7E;IACH,CAAC;;AA5CM,2BAAkB,GAAG,kBAAkB,CAAC;AACxC,aAAI,GAAa,IAAI,YAAY,EAAE,CAAC;;AA8CpC,cAAK,GAAG,kBAAkB,CAAC;IAChC,KAAK,EAAE,QAAQ;IACf,UAAU,EAAE,mBAAA,KAAK,EAAO;IACxB,OAAO;;;IAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA;CAClC,CAAC,CAAC;;;;;AAMI,0BAAiB,GAAG,CAAC,CAAC,CAAC;;;IAzD9B,4BAA+C;;IAC/C,cAA2C;;;;;IA8C3C,eAIG;;;;;;IAMH,2BAA8B;;;;;;;;;;;IAjD9B,oEACiG;;;;;;;;;IAKjG,6DAAmD;;;MAgD/C,KAAK;;;;;AAAG,UAAY,KAAQ;IAChC,OAAO,KAAK,CAAC;AACf,CAAC,CAAA;;;MACK,KAAK,GAAG,mBAAO,EAAE,EAAA;;MACjB,QAAQ,GAAG,KAAK;;MAChB,iBAAiB;;;AAAG;IACxB,OAAO,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAC/C,CAAC,CAAA;;;AAED,MAAW,WAAW;IACpB,QAAQ,GAAS;IACjB,SAAS,GAAS;IAClB,WAAW,GAAS;IACpB,OAAO,GAA0B;EAClC;;MACK,WAAW,GAAG,GAAG;AAEvB,MAAM,OAAO,cAAc;;;;;;IAOzB,YACI,SAA2B,EAAE,SAAmB,QAAQ,CAAC,IAAI,EAAE,SAAsB,IAAI;QAC3F,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;;cACf,OAAO,GAAG,IAAI,CAAC,QAAQ,GAAG,IAAI,GAAG,EAAe;QACtD,OAAO,CAAC,GAAG,CACP,QAAQ,EAAE,mBAAQ,EAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAC,EAAA,CAAC,CAAC;QAC7F,OAAO,CAAC,GAAG,CACP,QAAQ,EAAE,mBAAQ,EAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAC,EAAA,CAAC,CAAC;QAC7F,IAAI,CAAC,KAAK,GAAG,2BAA2B,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAC/D,CAAC;;;;;;;IAID,GAAG,CAAC,KAAU,EAAE,aAAmB,EAAE,QAAqB,WAAW,CAAC,OAAO;;cACrE,OAAO,GAAG,IAAI,CAAC,QAAQ;;YACzB,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC;QAC/B,IAAI,MAAM,KAAK,SAAS,EAAE;;;kBAElB,aAAa,GAAG,gBAAgB,CAAC,KAAK,CAAC;YAC7C,IAAI,aAAa,EAAE;;sBACX,UAAU,GAAG,aAAa,IAAI,aAAa,CAAC,UAAU;gBAC5D,IAAI,UAAU,KAAK,KAAK,IAAI,UAAU,IAAI,IAAI,IAAI,UAAU,KAAK,IAAI,CAAC,KAAK,EAAE;oBAC3E,OAAO,CAAC,GAAG,CACP,KAAK,EACL,MAAM,GAAG,eAAe,CACpB,EAAC,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,aAAa,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAC,CAAC,CAAC,CAAC;iBAC5E;aACF;YACD,IAAI,MAAM,KAAK,SAAS,EAAE;gBACxB,yFAAyF;gBACzF,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;aAC1B;SACF;;YACG,YAAY,GAAG,kBAAkB,CAAC,IAAI,CAAC;QAC3C,IAAI;YACF,OAAO,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;SACnF;QAAC,OAAO,CAAC,EAAE;YACV,OAAO,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,qBAAqB,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;SACzE;gBAAS;YACR,kBAAkB,CAAC,YAAY,CAAC,CAAC;SAClC;IACH,CAAC;;;;IAED,QAAQ;;cACA,MAAM,GAAG,mBAAU,EAAE,EAAA;;cAAE,OAAO,GAAG,IAAI,CAAC,QAAQ;QACpD,OAAO,CAAC,OAAO;;;;;QAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAC,CAAC;QAC7D,OAAO,kBAAkB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;IAChD,CAAC;CACF;;;IAvDC,gCAA0B;;IAC1B,gCAA6B;;IAC7B,+BAA4B;;;;;IAE5B,kCAAwC;;;;;AAwD1C,qBAKC;;;IAJC,oBAAa;;IACb,wBAAgB;;IAChB,sBAAyB;;IACzB,uBAAW;;;;;AAGb,+BAGC;;;IAFC,iCAAW;;IACX,mCAAgB;;;;;;AAGlB,SAAS,eAAe,CAAC,QAA2B;;UAC5C,IAAI,GAAG,WAAW,CAAC,QAAQ,CAAC;;QAC9B,EAAE,GAAa,KAAK;;QACpB,KAAK,GAAQ,KAAK;;QAClB,MAAM,GAAY,KAAK;;QACvB,OAAO,GAAG,iBAAiB,CAAC,QAAQ,CAAC,OAAO,CAAC;IACjD,IAAI,SAAS,IAAI,QAAQ,EAAE;QACzB,8FAA8F;QAC9F,KAAK,GAAG,CAAC,mBAAA,QAAQ,EAAiB,CAAC,CAAC,QAAQ,CAAC;KAC9C;SAAM,IAAI,CAAC,mBAAA,QAAQ,EAAmB,CAAC,CAAC,UAAU,EAAE;QACnD,EAAE,GAAG,CAAC,mBAAA,QAAQ,EAAmB,CAAC,CAAC,UAAU,CAAC;KAC/C;SAAM,IAAI,CAAC,mBAAA,QAAQ,EAAoB,CAAC,CAAC,WAAW,EAAE;QACrD,iBAAiB;KAClB;SAAM,IAAI,CAAC,mBAAA,QAAQ,EAAuB,CAAC,CAAC,QAAQ,EAAE;QACrD,MAAM,GAAG,IAAI,CAAC;QACd,EAAE,GAAG,iBAAiB,CAAC,CAAC,mBAAA,QAAQ,EAAuB,CAAC,CAAC,QAAQ,CAAC,CAAC;KACpE;SAAM,IAAI,OAAO,OAAO,IAAI,UAAU,EAAE;QACvC,MAAM,GAAG,IAAI,CAAC;QACd,EAAE,GAAG,OAAO,CAAC;KACd;SAAM;QACL,MAAM,WAAW,CACb,qGAAqG,EACrG,QAAQ,CAAC,CAAC;KACf;IACD,OAAO,EAAC,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAC,CAAC;AACnC,CAAC;;;;;AAED,SAAS,qBAAqB,CAAC,KAAU;IACvC,OAAO,WAAW,CAAC,kDAAkD,EAAE,KAAK,CAAC,CAAC;AAChF,CAAC;;;;;;AAED,SAAS,2BAA2B,CAAC,OAAyB,EAAE,QAAwB;;QAElF,KAAK,GAAgB,IAAI;IAC7B,IAAI,QAAQ,EAAE;QACZ,QAAQ,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QACvC,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;YAC3B,6CAA6C;YAC7C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBACxC,KAAK,GAAG,2BAA2B,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC;aACpE;SACF;aAAM,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE;YACzC,2FAA2F;YAC3F,iBAAiB;YACjB,MAAM,WAAW,CAAC,8BAA8B,EAAE,QAAQ,CAAC,CAAC;SAC7D;aAAM,IAAI,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,OAAO,EAAE;;;gBAEnE,KAAK,GAAG,iBAAiB,CAAC,QAAQ,CAAC,OAAO,CAAC;;kBACzC,gBAAgB,GAAG,eAAe,CAAC,QAAQ,CAAC;YAClD,IAAI,QAAQ,CAAC,KAAK,KAAK,IAAI,EAAE;;;oBAEvB,aAAa,GAAqB,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC;gBACxD,IAAI,aAAa,EAAE;oBACjB,IAAI,aAAa,CAAC,EAAE,KAAK,iBAAiB,EAAE;wBAC1C,MAAM,qBAAqB,CAAC,KAAK,CAAC,CAAC;qBACpC;iBACF;qBAAM;oBACL,0FAA0F;oBAC1F,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,aAAa,GAAG,mBAAQ;wBACzC,KAAK,EAAE,QAAQ,CAAC,OAAO;wBACvB,IAAI,EAAE,EAAE;wBACR,MAAM,EAAE,KAAK;wBACb,EAAE,EAAE,iBAAiB;wBACrB,KAAK,EAAE,KAAK;qBACb,EAAA,CAAC,CAAC;iBACJ;gBACD,mCAAmC;gBACnC,KAAK,GAAG,QAAQ,CAAC;gBACjB,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAC,KAAK,EAAE,OAAO,iBAAqB,EAAC,CAAC,CAAC;aAChE;;kBACK,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC;YACjC,IAAI,MAAM,IAAI,MAAM,CAAC,EAAE,IAAI,iBAAiB,EAAE;gBAC5C,MAAM,qBAAqB,CAAC,KAAK,CAAC,CAAC;aACpC;YACD,IAAI,KAAK,KAAK,cAAc,EAAE;gBAC5B,KAAK,GAAG,gBAAgB,CAAC,KAAK,CAAC;aAChC;YACD,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;SACtC;aAAM;YACL,MAAM,WAAW,CAAC,qBAAqB,EAAE,QAAQ,CAAC,CAAC;SACpD;KACF;IACD,OAAO,KAAK,CAAC;AACf,CAAC;;;;;;;;;;AAED,SAAS,eAAe,CACpB,KAAU,EAAE,MAA6B,EAAE,OAA8B,EAAE,MAAgB,EAC3F,aAAkB,EAAE,KAAkB;IACxC,IAAI;QACF,OAAO,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;KAC3E;IAAC,OAAO,CAAC,EAAE;QACV,oCAAoC;QACpC,IAAI,CAAC,CAAC,CAAC,YAAY,KAAK,CAAC,EAAE;YACzB,CAAC,GAAG,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;SAClB;;cACK,IAAI,GAAU,CAAC,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,kBAAkB,CAAC,IAAI,EAAE;QACvE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACpB,IAAI,MAAM,IAAI,MAAM,CAAC,KAAK,IAAI,QAAQ,EAAE;YACtC,2BAA2B;YAC3B,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;SACtB;QACD,MAAM,CAAC,CAAC;KACT;AACH,CAAC;;;;;;;;;;AAED,SAAS,YAAY,CACjB,KAAU,EAAE,MAA6B,EAAE,OAA8B,EAAE,MAAgB,EAC3F,aAAkB,EAAE,KAAkB;;QACpC,KAAK;IACT,IAAI,MAAM,IAAI,CAAC,CAAC,KAAK,GAAG,WAAW,CAAC,QAAQ,CAAC,EAAE;QAC7C,8FAA8F;QAC9F,iBAAiB;QACjB,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QACrB,IAAI,KAAK,IAAI,QAAQ,EAAE;YACrB,MAAM,KAAK,CAAC,WAAW,GAAG,qBAAqB,CAAC,CAAC;SAClD;aAAM,IAAI,KAAK,KAAK,KAAK,EAAE;YAC1B,MAAM,CAAC,KAAK,GAAG,QAAQ,CAAC;;gBACpB,GAAG,GAAG,SAAS;;gBACf,MAAM,GAAG,MAAM,CAAC,MAAM;;gBACtB,EAAE,GAAG,MAAM,CAAC,EAAE;;gBACd,UAAU,GAAG,MAAM,CAAC,IAAI;;gBACxB,IAAI,GAAG,KAAK;YAChB,IAAI,UAAU,CAAC,MAAM,EAAE;gBACrB,IAAI,GAAG,EAAE,CAAC;gBACV,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;;0BACpC,SAAS,GAAqB,UAAU,CAAC,CAAC,CAAC;;0BAC3C,OAAO,GAAG,SAAS,CAAC,OAAO;;0BAC3B,WAAW,GACb,OAAO,oBAAwB,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS;oBAC9E,IAAI,CAAC,IAAI,CAAC,eAAe;oBACrB,2BAA2B;oBAC3B,SAAS,CAAC,KAAK;oBACf,qDAAqD;oBACrD,uDAAuD;oBACvD,WAAW;oBACX,+BAA+B;oBAC/B,OAAO;oBACP,oFAAoF;oBACpF,8BAA8B;oBAC9B,CAAC,WAAW,IAAI,CAAC,CAAC,OAAO,sBAA0B,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAC7E,OAAO,mBAAuB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,kBAAkB,EACnE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;iBAC3B;aACF;YACD,MAAM,CAAC,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAA,EAAE,EAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;SAChF;KACF;SAAM,IAAI,CAAC,CAAC,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,EAAE;QACtC,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,aAAa,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;KAC/D;SAAM,IAAI,CAAC,CAAC,KAAK,GAAG,WAAW,CAAC,QAAQ,CAAC,EAAE;QAC1C,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;KACjD;SAAM;QACL,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,aAAa,KAAK,WAAW,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;KAC/F;IACD,OAAO,KAAK,CAAC;AACf,CAAC;;;;;AAED,SAAS,WAAW,CAAC,QAAwB;;QACvC,IAAI,GAAuB,KAAK;;UAC9B,YAAY,GACd,CAAC,mBAAA,QAAQ,EAAgE,CAAC,CAAC,IAAI;IACnF,IAAI,YAAY,IAAI,YAAY,CAAC,MAAM,EAAE;QACvC,IAAI,GAAG,EAAE,CAAC;QACV,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;;gBACxC,OAAO,kBAAsB;;gBAC7B,KAAK,GAAG,iBAAiB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YAC9C,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBACxB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,WAAW,GAAG,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;;0BAC1D,UAAU,GAAG,WAAW,CAAC,CAAC,CAAC;oBACjC,IAAI,UAAU,YAAY,QAAQ,IAAI,UAAU,IAAI,QAAQ,EAAE;wBAC5D,OAAO,GAAG,OAAO,mBAAuB,CAAC;qBAC1C;yBAAM,IAAI,UAAU,YAAY,QAAQ,IAAI,UAAU,IAAI,QAAQ,EAAE;wBACnE,OAAO,GAAG,OAAO,GAAG,kBAAsB,CAAC;qBAC5C;yBAAM,IAAI,UAAU,YAAY,IAAI,IAAI,UAAU,IAAI,IAAI,EAAE;wBAC3D,OAAO,GAAG,OAAO,GAAG,oBAAwB,CAAC;qBAC9C;yBAAM,IAAI,UAAU,YAAY,MAAM,EAAE;wBACvC,KAAK,GAAG,CAAC,mBAAA,UAAU,EAAU,CAAC,CAAC,KAAK,CAAC;qBACtC;yBAAM;wBACL,KAAK,GAAG,iBAAiB,CAAC,UAAU,CAAC,CAAC;qBACvC;iBACF;aACF;YACD,IAAI,CAAC,IAAI,CAAC,EAAC,KAAK,EAAE,OAAO,EAAC,CAAC,CAAC;SAC7B;KACF;SAAM,IAAI,CAAC,mBAAA,QAAQ,EAAoB,CAAC,CAAC,WAAW,EAAE;;cAC/C,KAAK,GAAG,iBAAiB,CAAC,CAAC,mBAAA,QAAQ,EAAoB,CAAC,CAAC,WAAW,CAAC;QAC3E,IAAI,GAAG,CAAC,EAAC,KAAK,EAAE,OAAO,iBAAqB,EAAC,CAAC,CAAC;KAChD;SAAM,IAAI,CAAC,YAAY,IAAI,CAAC,CAAC,SAAS,IAAI,QAAQ,CAAC,EAAE;QACpD,0FAA0F;QAC1F,MAAM,WAAW,CAAC,mBAAmB,EAAE,QAAQ,CAAC,CAAC;KAClD;IACD,OAAO,IAAI,CAAC;AACd,CAAC;;;;;;AAED,SAAS,WAAW,CAAC,IAAY,EAAE,GAAQ;IACzC,OAAO,IAAI,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,GAAG,EAAE,qBAAqB,CAAC,CAAC,CAAC;AAClE,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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 {AbstractType, Type} from '../interface/type';\nimport {stringify} from '../util/stringify';\n\nimport {resolveForwardRef} from './forward_ref';\nimport {InjectionToken} from './injection_token';\nimport {catchInjectorError, formatError, INJECTOR, NG_TEMP_TOKEN_PATH, NullInjector, setCurrentInjector, THROW_IF_NOT_FOUND, USE_VALUE, ɵɵinject} from './injector_compatibility';\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 {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 = 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>(\n      token: Type<T>|InjectionToken<T>|AbstractType<T>, notFoundValue?: T, flags?: InjectFlags): T;\n  /**\n   * @deprecated from v4.0.0 use Type<T> or InjectionToken<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 = ɵɵdefineInjectable({\n    token: Injector,\n    providedIn: 'any' as any,\n    factory: () => ɵɵinject(INJECTOR),\n  });\n\n  /**\n   * @internal\n   * @nocollapse\n   */\n  static __NG_ELEMENT_ID__ = -1;\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: Type<T>|InjectionToken<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 && 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   