uv-charts-dashboard/dist/main.map

A dashboard for uvCharts examples

{"version":3,"file":"main.bundle.js","sources":["webpack:///webpack/bootstrap 0aba3212edf22837662c","webpack:///./src/main.ts","webpack:///./~/@angular/core/bundles/core.umd.js","webpack:///./~/rxjs/Observable.js","webpack:///./~/rxjs/Subscriber.js","webpack:///./~/rxjs/util/root.js","webpack:///./src/app/shared/common.service.ts","webpack:///./~/css-loader/lib/css-base.js","webpack:///./~/rxjs/Subject.js","webpack:///./~/@angular/platform-browser/bundles/platform-browser.umd.js","webpack:///./~/rxjs/OuterSubscriber.js","webpack:///./~/rxjs/Subscription.js","webpack:///./~/rxjs/symbol/iterator.js","webpack:///./~/rxjs/symbol/observable.js","webpack:///./~/rxjs/symbol/rxSubscriber.js","webpack:///./~/rxjs/util/EmptyError.js","webpack:///./~/rxjs/util/isArray.js","webpack:///./~/rxjs/util/subscribeToResult.js","webpack:///./~/@angular/router/bundles/router.umd.js","webpack:///./~/@angular/common/bundles/common.umd.js","webpack:///./~/@angular/http/bundles/http.umd.js","webpack:///./~/rxjs/observable/ArrayObservable.js","webpack:///./~/rxjs/observable/EmptyObservable.js","webpack:///./~/rxjs/observable/PromiseObservable.js","webpack:///./~/rxjs/observable/ScalarObservable.js","webpack:///./~/rxjs/operator/mergeAll.js","webpack:///./~/rxjs/operator/mergeMap.js","webpack:///./~/rxjs/util/ObjectUnsubscribedError.js","webpack:///./~/rxjs/util/errorObject.js","webpack:///./~/rxjs/util/isFunction.js","webpack:///./~/rxjs/util/isPromise.js","webpack:///./~/rxjs/observable/fromPromise.js","webpack:///./~/rxjs/operator/map.js","webpack:///./~/@angular/compiler/bundles/compiler.umd.js","webpack:///./~/@angular/platform-browser-dynamic/bundles/platform-browser-dynamic.umd.js","webpack:///./src/app/components/area-chart/area-chart.ts","webpack:///./src/app/components/bar-chart/bar-chart.ts","webpack:///./src/app/components/donut-chart/donut-chart.ts","webpack:///./src/app/components/line-chart/line-chart.ts","webpack:///./src/app/components/percent-area-chart/percent-area-chart.ts","webpack:///./src/app/components/percent-bar-chart/percent-bar-chart.ts","webpack:///./src/app/components/pie-chart/pie-chart.ts","webpack:///./src/app/components/polar-area-chart/polar-area-chart.ts","webpack:///./src/app/components/stacked-area-chart/stacked-area-chart.ts","webpack:///./src/app/components/stacked-bar-chart/stacked-bar-chart.ts","webpack:///./src/app/components/stepup-bar-chart/stepup-bar-chart.ts","webpack:///./src/app/components/waterfall-chart/waterfall-chart.ts","webpack:///./~/rxjs/BehaviorSubject.js","webpack:///./~/rxjs/InnerSubscriber.js","webpack:///./~/rxjs/Notification.js","webpack:///./~/rxjs/Observer.js","webpack:///./~/rxjs/SubjectSubscription.js","webpack:///./~/rxjs/observable/ArrayLikeObservable.js","webpack:///./~/rxjs/observable/FromObservable.js","webpack:///./~/rxjs/observable/IteratorObservable.js","webpack:///./~/rxjs/observable/from.js","webpack:///./~/rxjs/observable/of.js","webpack:///./~/rxjs/operator/catch.js","webpack:///./~/rxjs/operator/concatAll.js","webpack:///./~/rxjs/operator/concatMap.js","webpack:///./~/rxjs/operator/every.js","webpack:///./~/rxjs/operator/filter.js","webpack:///./~/rxjs/operator/first.js","webpack:///./~/rxjs/operator/last.js","webpack:///./~/rxjs/operator/observeOn.js","webpack:///./~/rxjs/operator/reduce.js","webpack:///./~/rxjs/util/UnsubscriptionError.js","webpack:///./~/rxjs/util/isObject.js","webpack:///./~/rxjs/util/isScheduler.js","webpack:///./~/rxjs/util/toSubscriber.js","webpack:///./~/rxjs/util/tryCatch.js","webpack:///./src/app/components/dashboard/dashboard.ts","webpack:///./~/@angular/forms/bundles/forms.umd.js","webpack:///./src/app/app.module.ts","webpack:///./src/app/app.routes.ts","webpack:///./src/app/app.ts","webpack:///./src/app/components/chart-details/entry-components.ts","webpack:///./src/app/components/stacked-area-chart/stacked-area-chart.service.ts","webpack:///./src/app/components/area-chart/area-chart.css","webpack:///./src/app/components/dashboard/dashboard.css","webpack:///./src/app/components/line-chart/line-chart.css","webpack:///./src/app/components/percent-area-chart/percent-area-chart.css","webpack:///./src/app/components/percent-bar-chart/percent-bar-chart.css","webpack:///./src/app/components/pie-chart/pie-chart.css","webpack:///./src/app/components/stacked-area-chart/stacked-area-chart.css","webpack:///./src/app/components/stacked-bar-chart/stacked-bar-chart.css","webpack:///./src/app/app.html","webpack:///./src/app/components/dashboard/dashboard.html","webpack:///./~/rxjs/add/operator/map.js","webpack:///./~/rxjs/operator/toPromise.js","webpack:///./src/app/components/area-chart/area-chart.css?0a36","webpack:///./src/app/components/dashboard/dashboard.css?8554","webpack:///./src/app/components/line-chart/line-chart.css?6754","webpack:///./src/app/components/percent-area-chart/percent-area-chart.css?fea4","webpack:///./src/app/components/percent-bar-chart/percent-bar-chart.css?21d5","webpack:///./src/app/components/pie-chart/pie-chart.css?fe6e","webpack:///./src/app/components/stacked-area-chart/stacked-area-chart.css?aed4","webpack:///./src/app/components/stacked-bar-chart/stacked-bar-chart.css?dd21","webpack:///./src/app/components/dashboard/dashboard.module.ts"],"sourcesContent":[" \t// install a JSONP callback for chunk loading\n \tvar parentJsonpFunction = window[\"webpackJsonp\"];\n \twindow[\"webpackJsonp\"] = function webpackJsonpCallback(chunkIds, moreModules) {\n \t\t// add \"moreModules\" to the modules object,\n \t\t// then flag all \"chunkIds\" as loaded and fire callback\n \t\tvar moduleId, chunkId, i = 0, callbacks = [];\n \t\tfor(;i < chunkIds.length; i++) {\n \t\t\tchunkId = chunkIds[i];\n \t\t\tif(installedChunks[chunkId])\n \t\t\t\tcallbacks.push.apply(callbacks, installedChunks[chunkId]);\n \t\t\tinstalledChunks[chunkId] = 0;\n \t\t}\n \t\tfor(moduleId in moreModules) {\n \t\t\tmodules[moduleId] = moreModules[moduleId];\n \t\t}\n \t\tif(parentJsonpFunction) parentJsonpFunction(chunkIds, moreModules);\n \t\twhile(callbacks.length)\n \t\t\tcallbacks.shift().call(null, __webpack_require__);\n\n \t};\n\n \t// The module cache\n \tvar installedModules = {};\n\n \t// object to store loaded and loading chunks\n \t// \"0\" means \"already loaded\"\n \t// Array means \"loading\", array contains callbacks\n \tvar installedChunks = {\n \t\t1:0\n \t};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n \t// This file contains only the entry chunk.\n \t// The chunk loading function for additional chunks\n \t__webpack_require__.e = function requireEnsure(chunkId, callback) {\n \t\t// \"0\" is the signal for \"already loaded\"\n \t\tif(installedChunks[chunkId] === 0)\n \t\t\treturn callback.call(null, __webpack_require__);\n\n \t\t// an array means \"currently loading\".\n \t\tif(installedChunks[chunkId] !== undefined) {\n \t\t\tinstalledChunks[chunkId].push(callback);\n \t\t} else {\n \t\t\t// start chunk loading\n \t\t\tinstalledChunks[chunkId] = [callback];\n \t\t\tvar head = document.getElementsByTagName('head')[0];\n \t\t\tvar script = document.createElement('script');\n \t\t\tscript.type = 'text/javascript';\n \t\t\tscript.charset = 'utf-8';\n \t\t\tscript.async = true;\n\n \t\t\tscript.src = __webpack_require__.p + \"\" + chunkId + \".chunk.js\";\n \t\t\thead.appendChild(script);\n \t\t}\n \t};\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 0aba3212edf22837662c","import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';\r\nimport { AppModule } from './app/app.module';\r\n\r\nplatformBrowserDynamic().bootstrapModule(AppModule)\r\n    .catch(err => console.error(err));\r\n\n\n\n// WEBPACK FOOTER //\n// node_modules/angular2-template-loader!./~/angular2-router-loader/src!./src/main.ts","/**\n * @license Angular v2.1.2\n * (c) 2010-2016 Google, Inc. https://angular.io/\n * License: MIT\n */\n(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs/Subject'), require('rxjs/Observable')) :\n    typeof define === 'function' && define.amd ? define(['exports', 'rxjs/Subject', 'rxjs/Observable'], factory) :\n    (factory((global.ng = global.ng || {}, global.ng.core = global.ng.core || {}),global.Rx,global.Rx));\n}(this, function (exports,rxjs_Subject,rxjs_Observable) { 'use strict';\n\n    /**\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    var globalScope;\n    if (typeof window === 'undefined') {\n        if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {\n            // TODO: Replace any with WorkerGlobalScope from lib.webworker.d.ts #3492\n            globalScope = self;\n        }\n        else {\n            globalScope = global;\n        }\n    }\n    else {\n        globalScope = window;\n    }\n    function scheduleMicroTask(fn) {\n        Zone.current.scheduleMicroTask('scheduleMicrotask', fn);\n    }\n    // Need to declare a new variable for global here since TypeScript\n    // exports the original value of the symbol.\n    var global$1 = globalScope;\n    function getTypeNameForDebugging(type) {\n        return type['name'] || typeof type;\n    }\n    // TODO: remove calls to assert in production environment\n    // Note: Can't just export this and import in in other files\n    // as `assert` is a reserved keyword in Dart\n    global$1.assert = function assert(condition) {\n        // TODO: to be fixed properly via #2830, noop for now\n    };\n    function isPresent(obj) {\n        return obj != null;\n    }\n    function isBlank(obj) {\n        return obj == null;\n    }\n    function stringify(token) {\n        if (typeof token === 'string') {\n            return token;\n        }\n        if (token === undefined || token === null) {\n            return '' + token;\n        }\n        if (token.overriddenName) {\n            return token.overriddenName;\n        }\n        if (token.name) {\n            return token.name;\n        }\n        var res = token.toString();\n        var newLineIndex = res.indexOf('\\n');\n        return newLineIndex === -1 ? res : res.substring(0, newLineIndex);\n    }\n    // JS has NaN !== NaN\n    function looseIdentical(a, b) {\n        return a === b || typeof a === 'number' && typeof b === 'number' && isNaN(a) && isNaN(b);\n    }\n    function isJsObject(o) {\n        return o !== null && (typeof o === 'function' || typeof o === 'object');\n    }\n    function print(obj) {\n        console.log(obj);\n    }\n    function warn(obj) {\n        console.warn(obj);\n    }\n    var _symbolIterator = null;\n    function getSymbolIterator() {\n        if (!_symbolIterator) {\n            if (globalScope.Symbol && Symbol.iterator) {\n                _symbolIterator = Symbol.iterator;\n            }\n            else {\n                // es6-shim specific logic\n                var keys = Object.getOwnPropertyNames(Map.prototype);\n                for (var i = 0; i < keys.length; ++i) {\n                    var key = keys[i];\n                    if (key !== 'entries' && key !== 'size' &&\n                        Map.prototype[key] === Map.prototype['entries']) {\n                        _symbolIterator = key;\n                    }\n                }\n            }\n        }\n        return _symbolIterator;\n    }\n    function isPrimitive(obj) {\n        return !isJsObject(obj);\n    }\n\n    var _nextClassId = 0;\n    var Reflect = global$1.Reflect;\n    function extractAnnotation(annotation) {\n        if (typeof annotation === 'function' && annotation.hasOwnProperty('annotation')) {\n            // it is a decorator, extract annotation\n            annotation = annotation.annotation;\n        }\n        return annotation;\n    }\n    function applyParams(fnOrArray, key) {\n        if (fnOrArray === Object || fnOrArray === String || fnOrArray === Function ||\n            fnOrArray === Number || fnOrArray === Array) {\n            throw new Error(\"Can not use native \" + stringify(fnOrArray) + \" as constructor\");\n        }\n        if (typeof fnOrArray === 'function') {\n            return fnOrArray;\n        }\n        if (Array.isArray(fnOrArray)) {\n            var annotations = fnOrArray;\n            var annoLength = annotations.length - 1;\n            var fn = fnOrArray[annoLength];\n            if (typeof fn !== 'function') {\n                throw new Error(\"Last position of Class method array must be Function in key \" + key + \" was '\" + stringify(fn) + \"'\");\n            }\n            if (annoLength != fn.length) {\n                throw new Error(\"Number of annotations (\" + annoLength + \") does not match number of arguments (\" + fn.length + \") in the function: \" + stringify(fn));\n            }\n            var paramsAnnotations = [];\n            for (var i = 0, ii = annotations.length - 1; i < ii; i++) {\n                var paramAnnotations = [];\n                paramsAnnotations.push(paramAnnotations);\n                var annotation = annotations[i];\n                if (Array.isArray(annotation)) {\n                    for (var j = 0; j < annotation.length; j++) {\n                        paramAnnotations.push(extractAnnotation(annotation[j]));\n                    }\n                }\n                else if (typeof annotation === 'function') {\n                    paramAnnotations.push(extractAnnotation(annotation));\n                }\n                else {\n                    paramAnnotations.push(annotation);\n                }\n            }\n            Reflect.defineMetadata('parameters', paramsAnnotations, fn);\n            return fn;\n        }\n        throw new Error(\"Only Function or Array is supported in Class definition for key '\" + key + \"' is '\" + stringify(fnOrArray) + \"'\");\n    }\n    /**\n     * Provides a way for expressing ES6 classes with parameter annotations in ES5.\n     *\n     * ## Basic Example\n     *\n     * ```\n     * var Greeter = ng.Class({\n     *   constructor: function(name) {\n     *     this.name = name;\n     *   },\n     *\n     *   greet: function() {\n     *     alert('Hello ' + this.name + '!');\n     *   }\n     * });\n     * ```\n     *\n     * is equivalent to ES6:\n     *\n     * ```\n     * class Greeter {\n     *   constructor(name) {\n     *     this.name = name;\n     *   }\n     *\n     *   greet() {\n     *     alert('Hello ' + this.name + '!');\n     *   }\n     * }\n     * ```\n     *\n     * or equivalent to ES5:\n     *\n     * ```\n     * var Greeter = function (name) {\n     *   this.name = name;\n     * }\n     *\n     * Greeter.prototype.greet = function () {\n     *   alert('Hello ' + this.name + '!');\n     * }\n     * ```\n     *\n     * ### Example with parameter annotations\n     *\n     * ```\n     * var MyService = ng.Class({\n     *   constructor: [String, [new Optional(), Service], function(name, myService) {\n     *     ...\n     *   }]\n     * });\n     * ```\n     *\n     * is equivalent to ES6:\n     *\n     * ```\n     * class MyService {\n     *   constructor(name: string, @Optional() myService: Service) {\n     *     ...\n     *   }\n     * }\n     * ```\n     *\n     * ### Example with inheritance\n     *\n     * ```\n     * var Shape = ng.Class({\n     *   constructor: (color) {\n     *     this.color = color;\n     *   }\n     * });\n     *\n     * var Square = ng.Class({\n     *   extends: Shape,\n     *   constructor: function(color, size) {\n     *     Shape.call(this, color);\n     *     this.size = size;\n     *   }\n     * });\n     * ```\n     * @stable\n     */\n    function Class(clsDef) {\n        var constructor = applyParams(clsDef.hasOwnProperty('constructor') ? clsDef.constructor : undefined, 'constructor');\n        var proto = constructor.prototype;\n        if (clsDef.hasOwnProperty('extends')) {\n            if (typeof clsDef.extends === 'function') {\n                constructor.prototype = proto =\n                    Object.create(clsDef.extends.prototype);\n            }\n            else {\n                throw new Error(\"Class definition 'extends' property must be a constructor function was: \" + stringify(clsDef.extends));\n            }\n        }\n        for (var key in clsDef) {\n            if (key !== 'extends' && key !== 'prototype' && clsDef.hasOwnProperty(key)) {\n                proto[key] = applyParams(clsDef[key], key);\n            }\n        }\n        if (this && this.annotations instanceof Array) {\n            Reflect.defineMetadata('annotations', this.annotations, constructor);\n        }\n        var constructorName = constructor['name'];\n        if (!constructorName || constructorName === 'constructor') {\n            constructor['overriddenName'] = \"class\" + _nextClassId++;\n        }\n        return constructor;\n    }\n    function makeDecorator(name, props, parentClass, chainFn) {\n        if (chainFn === void 0) { chainFn = null; }\n        var metaCtor = makeMetadataCtor([props]);\n        function DecoratorFactory(objOrType) {\n            if (!(Reflect && Reflect.getMetadata)) {\n                throw 'reflect-metadata shim is required when using class decorators';\n            }\n            if (this instanceof DecoratorFactory) {\n                metaCtor.call(this, objOrType);\n                return this;\n            }\n            var annotationInstance = new DecoratorFactory(objOrType);\n            var chainAnnotation = typeof this === 'function' && Array.isArray(this.annotations) ? this.annotations : [];\n            chainAnnotation.push(annotationInstance);\n            var TypeDecorator = function TypeDecorator(cls) {\n                var annotations = Reflect.getOwnMetadata('annotations', cls) || [];\n                annotations.push(annotationInstance);\n                Reflect.defineMetadata('annotations', annotations, cls);\n                return cls;\n            };\n            TypeDecorator.annotations = chainAnnotation;\n            TypeDecorator.Class = Class;\n            if (chainFn)\n                chainFn(TypeDecorator);\n            return TypeDecorator;\n        }\n        if (parentClass) {\n            DecoratorFactory.prototype = Object.create(parentClass.prototype);\n        }\n        DecoratorFactory.prototype.toString = function () { return (\"@\" + name); };\n        DecoratorFactory.annotationCls = DecoratorFactory;\n        return DecoratorFactory;\n    }\n    function makeMetadataCtor(props) {\n        return function ctor() {\n            var _this = this;\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i - 0] = arguments[_i];\n            }\n            props.forEach(function (prop, i) {\n                var argVal = args[i];\n                if (Array.isArray(prop)) {\n                    // plain parameter\n                    _this[prop[0]] = argVal === undefined ? prop[1] : argVal;\n                }\n                else {\n                    for (var propName in prop) {\n                        _this[propName] =\n                            argVal && argVal.hasOwnProperty(propName) ? argVal[propName] : prop[propName];\n                    }\n                }\n            });\n        };\n    }\n    function makeParamDecorator(name, props, parentClass) {\n        var metaCtor = makeMetadataCtor(props);\n        function ParamDecoratorFactory() {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i - 0] = arguments[_i];\n            }\n            if (this instanceof ParamDecoratorFactory) {\n                metaCtor.apply(this, args);\n                return this;\n            }\n            var annotationInstance = new ((_a = ParamDecoratorFactory).bind.apply(_a, [void 0].concat(args)))();\n            ParamDecorator.annotation = annotationInstance;\n            return ParamDecorator;\n            function ParamDecorator(cls, unusedKey, index) {\n                var parameters = Reflect.getMetadata('parameters', cls) || [];\n                // there might be gaps if some in between parameters do not have annotations.\n                // we pad with nulls.\n                while (parameters.length <= index) {\n                    parameters.push(null);\n                }\n                parameters[index] = parameters[index] || [];\n                parameters[index].push(annotationInstance);\n                Reflect.defineMetadata('parameters', parameters, cls);\n                return cls;\n            }\n            var _a;\n        }\n        if (parentClass) {\n            ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);\n        }\n        ParamDecoratorFactory.prototype.toString = function () { return (\"@\" + name); };\n        ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;\n        return ParamDecoratorFactory;\n    }\n    function makePropDecorator(name, props, parentClass) {\n        var metaCtor = makeMetadataCtor(props);\n        function PropDecoratorFactory() {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i - 0] = arguments[_i];\n            }\n            if (this instanceof PropDecoratorFactory) {\n                metaCtor.apply(this, args);\n                return this;\n            }\n            var decoratorInstance = new ((_a = PropDecoratorFactory).bind.apply(_a, [void 0].concat(args)))();\n            return function PropDecorator(target, name) {\n                var meta = Reflect.getOwnMetadata('propMetadata', target.constructor) || {};\n                meta[name] = meta.hasOwnProperty(name) && meta[name] || [];\n                meta[name].unshift(decoratorInstance);\n                Reflect.defineMetadata('propMetadata', meta, target.constructor);\n            };\n            var _a;\n        }\n        if (parentClass) {\n            PropDecoratorFactory.prototype = Object.create(parentClass.prototype);\n        }\n        PropDecoratorFactory.prototype.toString = function () { return (\"@\" + name); };\n        PropDecoratorFactory.annotationCls = PropDecoratorFactory;\n        return PropDecoratorFactory;\n    }\n\n    /**\n     * Inject decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var Inject = makeParamDecorator('Inject', [['token', undefined]]);\n    /**\n     * Optional decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var Optional = makeParamDecorator('Optional', []);\n    /**\n     * Injectable decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var Injectable = makeParamDecorator('Injectable', []);\n    /**\n     * Self decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var Self = makeParamDecorator('Self', []);\n    /**\n     * SkipSelf decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var SkipSelf = makeParamDecorator('SkipSelf', []);\n    /**\n     * Host decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var Host = makeParamDecorator('Host', []);\n\n    /**\n     * Creates a token that can be used in a DI Provider.\n     *\n     * ### Example ([live demo](http://plnkr.co/edit/Ys9ezXpj2Mnoy3Uc8KBp?p=preview))\n     *\n     * ```typescript\n     * var t = new OpaqueToken(\"value\");\n     *\n     * var injector = Injector.resolveAndCreate([\n     *   {provide: t, useValue: \"bindingValue\"}\n     * ]);\n     *\n     * expect(injector.get(t)).toEqual(\"bindingValue\");\n     * ```\n     *\n     * Using an `OpaqueToken` is preferable to using strings as tokens because of possible collisions\n     * caused by multiple providers using the same string as two different tokens.\n     *\n     * Using an `OpaqueToken` is preferable to using an `Object` as tokens because it provides better\n     * error messages.\n     * @stable\n     */\n    // so that metadata is gathered for this class\n    var OpaqueToken = (function () {\n        function OpaqueToken(_desc) {\n            this._desc = _desc;\n        }\n        OpaqueToken.prototype.toString = function () { return \"Token \" + this._desc; };\n        OpaqueToken.decorators = [\n            { type: Injectable },\n        ];\n        /** @nocollapse */\n        OpaqueToken.ctorParameters = [\n            null,\n        ];\n        return OpaqueToken;\n    }());\n\n    /**\n     * This token can be used to create a virtual provider that will populate the\n     * `entryComponents` fields of components and ng modules based on its `useValue`.\n     * All components that are referenced in the `useValue` value (either directly\n     * or in a nested array or map) will be added to the `entryComponents` property.\n     *\n     * ### Example\n     * The following example shows how the router can populate the `entryComponents`\n     * field of an NgModule based on the router configuration which refers\n     * to components.\n     *\n     * ```typescript\n     * // helper function inside the router\n     * function provideRoutes(routes) {\n     *   return [\n     *     {provide: ROUTES, useValue: routes},\n     *     {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}\n     *   ];\n     * }\n     *\n     * // user code\n     * let routes = [\n     *   {path: '/root', component: RootComp},\n     *   {path: '/teams', component: TeamsComp}\n     * ];\n     *\n     * @NgModule({\n     *   providers: [provideRoutes(routes)]\n     * })\n     * class ModuleWithRoutes {}\n     * ```\n     *\n     * @experimental\n     */\n    var ANALYZE_FOR_ENTRY_COMPONENTS = new OpaqueToken('AnalyzeForEntryComponents');\n    /**\n     * Attribute decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var Attribute = makeParamDecorator('Attribute', [['attributeName', undefined]]);\n    /**\n     * Base class for query metadata.\n     *\n     * See {@link ContentChildren}, {@link ContentChild}, {@link ViewChildren}, {@link ViewChild} for\n     * more information.\n     *\n     * @stable\n     */\n    var Query = (function () {\n        function Query() {\n        }\n        return Query;\n    }());\n    /**\n     * ContentChildren decorator and metadata.\n     *\n     *  @stable\n     *  @Annotation\n     */\n    var ContentChildren = makePropDecorator('ContentChildren', [\n        ['selector', undefined], {\n            first: false,\n            isViewQuery: false,\n            descendants: false,\n            read: undefined,\n        }\n    ], Query);\n    /**\n     * @whatItDoes Configures a content query.\n     *\n     * @howToUse\n     *\n     * {@example core/di/ts/contentChild/content_child_howto.ts region='HowTo'}\n     *\n     * @description\n     *\n     * You can use ContentChild to get the first element or the directive matching the selector from the\n     * content DOM. If the content DOM changes, and a new child matches the selector,\n     * the property will be updated.\n     *\n     * Content queries are set before the `ngAfterContentInit` callback is called.\n     *\n     * **Metadata Properties**:\n     *\n     * * **selector** - the directive type or the name used for querying.\n     * * **read** - read a different token from the queried element.\n     *\n     * Let's look at an example:\n     *\n     * {@example core/di/ts/contentChild/content_child_example.ts region='Component'}\n     *\n     * **npm package**: `@angular/core`\n     *\n     * @stable\n     * @Annotation\n     */\n    var ContentChild = makePropDecorator('ContentChild', [\n        ['selector', undefined], {\n            first: true,\n            isViewQuery: false,\n            descendants: true,\n            read: undefined,\n        }\n    ], Query);\n    /**\n     * @whatItDoes Configures a view query.\n     *\n     * @howToUse\n     *\n     * {@example core/di/ts/viewChildren/view_children_howto.ts region='HowTo'}\n     *\n     * @description\n     *\n     * You can use ViewChildren to get the {@link QueryList} of elements or directives from the\n     * view DOM. Any time a child element is added, removed, or moved, the query list will be updated,\n     * and the changes observable of the query list will emit a new value.\n     *\n     * View queries are set before the `ngAfterViewInit` callback is called.\n     *\n     * **Metadata Properties**:\n     *\n     * * **selector** - the directive type or the name used for querying.\n     * * **read** - read a different token from the queried elements.\n     *\n     * Let's look at an example:\n     *\n     * {@example core/di/ts/viewChildren/view_children_example.ts region='Component'}\n     *\n     * **npm package**: `@angular/core`\n     *\n     * @stable\n     * @Annotation\n     */\n    var ViewChildren = makePropDecorator('ViewChildren', [\n        ['selector', undefined], {\n            first: false,\n            isViewQuery: true,\n            descendants: true,\n            read: undefined,\n        }\n    ], Query);\n    /**\n     * ViewChild decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var ViewChild = makePropDecorator('ViewChild', [\n        ['selector', undefined], {\n            first: true,\n            isViewQuery: true,\n            descendants: true,\n            read: undefined,\n        }\n    ], Query);\n\n    /**\n     * Describes within the change detector which strategy will be used the next time change\n     * detection is triggered.\n     * @stable\n     */\n    exports.ChangeDetectionStrategy;\n    (function (ChangeDetectionStrategy) {\n        /**\n         * `OnPush` means that the change detector's mode will be set to `CheckOnce` during hydration.\n         */\n        ChangeDetectionStrategy[ChangeDetectionStrategy[\"OnPush\"] = 0] = \"OnPush\";\n        /**\n         * `Default` means that the change detector's mode will be set to `CheckAlways` during hydration.\n         */\n        ChangeDetectionStrategy[ChangeDetectionStrategy[\"Default\"] = 1] = \"Default\";\n    })(exports.ChangeDetectionStrategy || (exports.ChangeDetectionStrategy = {}));\n    /**\n     * Describes the status of the detector.\n     */\n    var ChangeDetectorStatus;\n    (function (ChangeDetectorStatus) {\n        /**\n         * `CheckedOnce` means that after calling detectChanges the mode of the change detector\n         * will become `Checked`.\n         */\n        ChangeDetectorStatus[ChangeDetectorStatus[\"CheckOnce\"] = 0] = \"CheckOnce\";\n        /**\n         * `Checked` means that the change detector should be skipped until its mode changes to\n         * `CheckOnce`.\n         */\n        ChangeDetectorStatus[ChangeDetectorStatus[\"Checked\"] = 1] = \"Checked\";\n        /**\n         * `CheckAlways` means that after calling detectChanges the mode of the change detector\n         * will remain `CheckAlways`.\n         */\n        ChangeDetectorStatus[ChangeDetectorStatus[\"CheckAlways\"] = 2] = \"CheckAlways\";\n        /**\n         * `Detached` means that the change detector sub tree is not a part of the main tree and\n         * should be skipped.\n         */\n        ChangeDetectorStatus[ChangeDetectorStatus[\"Detached\"] = 3] = \"Detached\";\n        /**\n         * `Errored` means that the change detector encountered an error checking a binding\n         * or calling a directive lifecycle method and is now in an inconsistent state. Change\n         * detectors in this state will no longer detect changes.\n         */\n        ChangeDetectorStatus[ChangeDetectorStatus[\"Errored\"] = 4] = \"Errored\";\n        /**\n         * `Destroyed` means that the change detector is destroyed.\n         */\n        ChangeDetectorStatus[ChangeDetectorStatus[\"Destroyed\"] = 5] = \"Destroyed\";\n    })(ChangeDetectorStatus || (ChangeDetectorStatus = {}));\n    function isDefaultChangeDetectionStrategy(changeDetectionStrategy) {\n        return isBlank(changeDetectionStrategy) ||\n            changeDetectionStrategy === exports.ChangeDetectionStrategy.Default;\n    }\n\n    /**\n     * Directive decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var Directive = makeDecorator('Directive', {\n        selector: undefined,\n        inputs: undefined,\n        outputs: undefined,\n        host: undefined,\n        providers: undefined,\n        exportAs: undefined,\n        queries: undefined\n    });\n    /**\n     * Component decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var Component = makeDecorator('Component', {\n        selector: undefined,\n        inputs: undefined,\n        outputs: undefined,\n        host: undefined,\n        exportAs: undefined,\n        moduleId: undefined,\n        providers: undefined,\n        viewProviders: undefined,\n        changeDetection: exports.ChangeDetectionStrategy.Default,\n        queries: undefined,\n        templateUrl: undefined,\n        template: undefined,\n        styleUrls: undefined,\n        styles: undefined,\n        animations: undefined,\n        encapsulation: undefined,\n        interpolation: undefined,\n        entryComponents: undefined\n    }, Directive);\n    /**\n     * Pipe decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var Pipe = makeDecorator('Pipe', {\n        name: undefined,\n        pure: true,\n    });\n    /**\n     * Input decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var Input = makePropDecorator('Input', [['bindingPropertyName', undefined]]);\n    /**\n     * Output decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var Output = makePropDecorator('Output', [['bindingPropertyName', undefined]]);\n    /**\n     * HostBinding decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var HostBinding = makePropDecorator('HostBinding', [['hostPropertyName', undefined]]);\n    /**\n     * HostBinding decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var HostListener = makePropDecorator('HostListener', [['eventName', undefined], ['args', []]]);\n\n    /**\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    /**\n     * @stable\n     */\n    var LifecycleHooks;\n    (function (LifecycleHooks) {\n        LifecycleHooks[LifecycleHooks[\"OnInit\"] = 0] = \"OnInit\";\n        LifecycleHooks[LifecycleHooks[\"OnDestroy\"] = 1] = \"OnDestroy\";\n        LifecycleHooks[LifecycleHooks[\"DoCheck\"] = 2] = \"DoCheck\";\n        LifecycleHooks[LifecycleHooks[\"OnChanges\"] = 3] = \"OnChanges\";\n        LifecycleHooks[LifecycleHooks[\"AfterContentInit\"] = 4] = \"AfterContentInit\";\n        LifecycleHooks[LifecycleHooks[\"AfterContentChecked\"] = 5] = \"AfterContentChecked\";\n        LifecycleHooks[LifecycleHooks[\"AfterViewInit\"] = 6] = \"AfterViewInit\";\n        LifecycleHooks[LifecycleHooks[\"AfterViewChecked\"] = 7] = \"AfterViewChecked\";\n    })(LifecycleHooks || (LifecycleHooks = {}));\n    var LIFECYCLE_HOOKS_VALUES = [\n        LifecycleHooks.OnInit, LifecycleHooks.OnDestroy, LifecycleHooks.DoCheck, LifecycleHooks.OnChanges,\n        LifecycleHooks.AfterContentInit, LifecycleHooks.AfterContentChecked, LifecycleHooks.AfterViewInit,\n        LifecycleHooks.AfterViewChecked\n    ];\n    /**\n     * @whatItDoes Lifecycle hook that is called when any data-bound property of a directive changes.\n     * @howToUse\n     * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='OnChanges'}\n     *\n     * @description\n     * `ngOnChanges` is called right after the data-bound properties have been checked and before view\n     * and content children are checked if at least one of them has changed.\n     * The `changes` parameter contains the changed properties.\n     *\n     * See {@linkDocs guide/lifecycle-hooks#onchanges \"Lifecycle Hooks Guide\"}.\n     *\n     * @stable\n     */\n    var OnChanges = (function () {\n        function OnChanges() {\n        }\n        return OnChanges;\n    }());\n    /**\n     * @whatItDoes Lifecycle hook that is called after data-bound properties of a directive are\n     * initialized.\n     * @howToUse\n     * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='OnInit'}\n     *\n     * @description\n     * `ngOnInit` is called right after the directive's data-bound properties have been checked for the\n     * first time, and before any of its children have been checked. It is invoked only once when the\n     * directive is instantiated.\n     *\n     * See {@linkDocs guide/lifecycle-hooks \"Lifecycle Hooks Guide\"}.\n     *\n     * @stable\n     */\n    var OnInit = (function () {\n        function OnInit() {\n        }\n        return OnInit;\n    }());\n    /**\n     * @whatItDoes Lifecycle hook that is called when Angular dirty checks a directive.\n     * @howToUse\n     * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='DoCheck'}\n     *\n     * @description\n     * `ngDoCheck` gets called to check the changes in the directives in addition to the default\n     * algorithm. The default change detection algorithm looks for differences by comparing\n     * bound-property values by reference across change detection runs.\n     *\n     * Note that a directive typically should not use both `DoCheck` and {@link OnChanges} to respond to\n     * changes on the same input, as `ngOnChanges` will continue to be called when the default change\n     * detector detects changes.\n     *\n     * See {@link KeyValueDiffers} and {@link IterableDiffers} for implementing custom dirty checking\n     * for collections.\n     *\n     * See {@linkDocs guide/lifecycle-hooks#docheck \"Lifecycle Hooks Guide\"}.\n     *\n     * @stable\n     */\n    var DoCheck = (function () {\n        function DoCheck() {\n        }\n        return DoCheck;\n    }());\n    /**\n     * @whatItDoes Lifecycle hook that is called when a directive or pipe is destroyed.\n     * @howToUse\n     * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='OnDestroy'}\n     *\n     * @description\n     * `ngOnDestroy` callback is typically used for any custom cleanup that needs to occur when the\n     * instance is destroyed.\n     *\n     * See {@linkDocs guide/lifecycle-hooks \"Lifecycle Hooks Guide\"}.\n     *\n     * @stable\n     */\n    var OnDestroy = (function () {\n        function OnDestroy() {\n        }\n        return OnDestroy;\n    }());\n    /**\n     *\n     * @whatItDoes Lifecycle hook that is called after a directive's content has been fully\n     * initialized.\n     * @howToUse\n     * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='AfterContentInit'}\n     *\n     * @description\n     * See {@linkDocs guide/lifecycle-hooks#aftercontent \"Lifecycle Hooks Guide\"}.\n     *\n     * @stable\n     */\n    var AfterContentInit = (function () {\n        function AfterContentInit() {\n        }\n        return AfterContentInit;\n    }());\n    /**\n     * @whatItDoes Lifecycle hook that is called after every check of a directive's content.\n     * @howToUse\n     * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='AfterContentChecked'}\n     *\n     * @description\n     * See {@linkDocs guide/lifecycle-hooks#aftercontent \"Lifecycle Hooks Guide\"}.\n     *\n     * @stable\n     */\n    var AfterContentChecked = (function () {\n        function AfterContentChecked() {\n        }\n        return AfterContentChecked;\n    }());\n    /**\n     * @whatItDoes Lifecycle hook that is called after a component's view has been fully\n     * initialized.\n     * @howToUse\n     * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='AfterViewInit'}\n     *\n     * @description\n     * See {@linkDocs guide/lifecycle-hooks#afterview \"Lifecycle Hooks Guide\"}.\n     *\n     * @stable\n     */\n    var AfterViewInit = (function () {\n        function AfterViewInit() {\n        }\n        return AfterViewInit;\n    }());\n    /**\n     * @whatItDoes Lifecycle hook that is called after every check of a component's view.\n     * @howToUse\n     * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='AfterViewChecked'}\n     *\n     * @description\n     * See {@linkDocs guide/lifecycle-hooks#afterview \"Lifecycle Hooks Guide\"}.\n     *\n     * @stable\n     */\n    var AfterViewChecked = (function () {\n        function AfterViewChecked() {\n        }\n        return AfterViewChecked;\n    }());\n\n    /**\n     * Defines a schema that will allow:\n     * - any non-Angular elements with a `-` in their name,\n     * - any properties on elements with a `-` in their name which is the common rule for custom\n     * elements.\n     *\n     * @stable\n     */\n    var CUSTOM_ELEMENTS_SCHEMA = {\n        name: 'custom-elements'\n    };\n    /**\n     * Defines a schema that will allow any property on any element.\n     *\n     * @experimental\n     */\n    var NO_ERRORS_SCHEMA = {\n        name: 'no-errors-schema'\n    };\n    /**\n     * NgModule decorator and metadata.\n     *\n     * @stable\n     * @Annotation\n     */\n    var NgModule = makeDecorator('NgModule', {\n        providers: undefined,\n        declarations: undefined,\n        imports: undefined,\n        exports: undefined,\n        entryComponents: undefined,\n        bootstrap: undefined,\n        schemas: undefined,\n        id: undefined,\n    });\n\n    /**\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    /**\n     * Defines template and style encapsulation options available for Component's {@link Component}.\n     *\n     * See {@link ViewMetadata#encapsulation}.\n     * @stable\n     */\n    exports.ViewEncapsulation;\n    (function (ViewEncapsulation) {\n        /**\n         * Emulate `Native` scoping of styles by adding an attribute containing surrogate id to the Host\n         * Element and pre-processing the style rules provided via\n         * {@link ViewMetadata#styles} or {@link ViewMetadata#stylesUrls}, and adding the new Host Element\n         * attribute to all selectors.\n         *\n         * This is the default option.\n         */\n        ViewEncapsulation[ViewEncapsulation[\"Emulated\"] = 0] = \"Emulated\";\n        /**\n         * Use the native encapsulation mechanism of the renderer.\n         *\n         * For the DOM this means using [Shadow DOM](https://w3c.github.io/webcomponents/spec/shadow/) and\n         * creating a ShadowRoot for Component's Host Element.\n         */\n        ViewEncapsulation[ViewEncapsulation[\"Native\"] = 1] = \"Native\";\n        /**\n         * Don't provide any template or style encapsulation.\n         */\n        ViewEncapsulation[ViewEncapsulation[\"None\"] = 2] = \"None\";\n    })(exports.ViewEncapsulation || (exports.ViewEncapsulation = {}));\n    /**\n     * Metadata properties available for configuring Views.\n     *\n     * For details on the `@Component` annotation, see {@link Component}.\n     *\n     * ### Example\n     *\n     * ```\n     * @Component({\n     *   selector: 'greet',\n     *   template: 'Hello {{name}}!',\n     * })\n     * class Greet {\n     *   name: string;\n     *\n     *   constructor() {\n     *     this.name = 'World';\n     *   }\n     * }\n     * ```\n     *\n     * @deprecated Use Component instead.\n     *\n     * {@link Component}\n     */\n    var ViewMetadata = (function () {\n        function ViewMetadata(_a) {\n            var _b = _a === void 0 ? {} : _a, templateUrl = _b.templateUrl, template = _b.template, encapsulation = _b.encapsulation, styles = _b.styles, styleUrls = _b.styleUrls, animations = _b.animations, interpolation = _b.interpolation;\n            this.templateUrl = templateUrl;\n            this.template = template;\n            this.styleUrls = styleUrls;\n            this.styles = styles;\n            this.encapsulation = encapsulation;\n            this.animations = animations;\n            this.interpolation = interpolation;\n        }\n        return ViewMetadata;\n    }());\n\n    /**\n     * Allows to refer to references which are not yet defined.\n     *\n     * For instance, `forwardRef` is used when the `token` which we need to refer to for the purposes of\n     * DI is declared,\n     * but not yet defined. It is also used when the `token` which we use when creating a query is not\n     * yet defined.\n     *\n     * ### Example\n     * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref'}\n     * @experimental\n     */\n    function forwardRef(forwardRefFn) {\n        forwardRefFn.__forward_ref__ = forwardRef;\n        forwardRefFn.toString = function () { return stringify(this()); };\n        return forwardRefFn;\n    }\n    /**\n     * Lazily retrieves the reference value from a forwardRef.\n     *\n     * Acts as the identity function when given a non-forward-ref value.\n     *\n     * ### Example ([live demo](http://plnkr.co/edit/GU72mJrk1fiodChcmiDR?p=preview))\n     *\n     * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}\n     *\n     * See: {@link forwardRef}\n     * @experimental\n     */\n    function resolveForwardRef(type) {\n        if (typeof type === 'function' && type.hasOwnProperty('__forward_ref__') &&\n            type.__forward_ref__ === forwardRef) {\n            return type();\n        }\n        else {\n            return type;\n        }\n    }\n\n    /**\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    var __extends = (this && this.__extends) || function (d, b) {\n        for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n    function unimplemented() {\n        throw new Error('unimplemented');\n    }\n    /**\n     * @stable\n     */\n    var BaseError = (function (_super) {\n        __extends(BaseError, _super);\n        function BaseError(message) {\n            // Errors don't use current this, instead they create a new instance.\n            // We have to do forward all of our api to the nativeInstance.\n            var nativeError = _super.call(this, message);\n            this._nativeError = nativeError;\n        }\n        Object.defineProperty(BaseError.prototype, \"message\", {\n            get: function () { return this._nativeError.message; },\n            set: function (message) { this._nativeError.message = message; },\n            enumerable: true,\n            configurable: true\n        });\n        Object.defineProperty(BaseError.prototype, \"name\", {\n            get: function () { return this._nativeError.name; },\n            enumerable: true,\n            configurable: true\n        });\n        Object.defineProperty(BaseError.prototype, \"stack\", {\n            get: function () { return this._nativeError.stack; },\n            set: function (value) { this._nativeError.stack = value; },\n            enumerable: true,\n            configurable: true\n        });\n        BaseError.prototype.toString = function () { return this._nativeError.toString(); };\n        return BaseError;\n    }(Error));\n    /**\n     * @stable\n     */\n    var WrappedError = (function (_super) {\n        __extends(WrappedError, _super);\n        function WrappedError(message, error) {\n            _super.call(this, message + \" caused by: \" + (error instanceof Error ? error.message : error));\n            this.originalError = error;\n        }\n        Object.defineProperty(WrappedError.prototype, \"stack\", {\n            get: function () {\n                return (this.originalError instanceof Error ? this.originalError : this._nativeError)\n                    .stack;\n            },\n            enumerable: true,\n            configurable: true\n        });\n        return WrappedError;\n    }(BaseError));\n\n    var _THROW_IF_NOT_FOUND = new Object();\n    var THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\n    var _NullInjector = (function () {\n        function _NullInjector() {\n        }\n        _NullInjector.prototype.get = function (token, notFoundValue) {\n            if (notFoundValue === void 0) { notFoundValue = _THROW_IF_NOT_FOUND; }\n            if (notFoundValue === _THROW_IF_NOT_FOUND) {\n                throw new Error(\"No provider for \" + stringify(token) + \"!\");\n            }