` or any other element with the\n * `tooltip` selector,\n * like so:\n *\n * ```\n *
\n * ```\n *\n * Directives can also control the instantiation, destruction, and positioning of inline template\n * elements:\n *\n * A directive uses a {@link ViewContainerRef} to instantiate, insert, move, and destroy views at\n * runtime.\n * The {@link ViewContainerRef} is created as a result of `
` element, and represents a\n * location in the current view\n * where these actions are performed.\n *\n * Views are always created as children of the current {@link ViewMetadata}, and as siblings of the\n * `` element. Thus a\n * directive in a child view cannot inject the directive that created it.\n *\n * Since directives that create views via ViewContainers are common in Angular, and using the full\n * `` element syntax is wordy, Angular\n * also supports a shorthand notation: `` and `` are\n * equivalent.\n *\n * Thus,\n *\n * ```\n * \n * ```\n *\n * Expands in use to:\n *\n * ```\n * \n * ```\n *\n * Notice that although the shorthand places `*foo=\"bar\"` within the `` element, the binding for\n * the directive\n * controller is correctly instantiated on the `` element rather than the `` element.\n *\n * ## Lifecycle hooks\n *\n * When the directive class implements some {@link ../../guide/lifecycle-hooks.html} the callbacks\n * are called by the change detection at defined points in time during the life of the directive.\n *\n * ### Example\n *\n * Let's suppose we want to implement the `unless` behavior, to conditionally include a template.\n *\n * Here is a simple directive that triggers on an `unless` selector:\n *\n * ```\n * @Directive({\n * selector: '[unless]',\n * inputs: ['unless']\n * })\n * export class Unless {\n * viewContainer: ViewContainerRef;\n * templateRef: TemplateRef;\n * prevCondition: boolean;\n *\n * constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef) {\n * this.viewContainer = viewContainer;\n * this.templateRef = templateRef;\n * this.prevCondition = null;\n * }\n *\n * set unless(newCondition) {\n * if (newCondition && (isBlank(this.prevCondition) || !this.prevCondition)) {\n * this.prevCondition = true;\n * this.viewContainer.clear();\n * } else if (!newCondition && (isBlank(this.prevCondition) || this.prevCondition)) {\n * this.prevCondition = false;\n * this.viewContainer.create(this.templateRef);\n * }\n * }\n * }\n * ```\n *\n * We can then use this `unless` selector in a template:\n * ```\n * \n * ```\n *\n * Once the directive instantiates the child view, the shorthand notation for the template expands\n * and the result is:\n *\n * ```\n * \n * ```\n *\n * Note also that although the `` template still exists inside the ``,\n * the instantiated\n * view occurs on the second `` which is a sibling to the `` element.\n * @ts2dart_const\n */\nvar DirectiveMetadata = (function (_super) {\n __extends(DirectiveMetadata, _super);\n function DirectiveMetadata(_a) {\n var _b = _a === void 0 ? {} : _a, selector = _b.selector, inputs = _b.inputs, outputs = _b.outputs, properties = _b.properties, events = _b.events, host = _b.host, bindings = _b.bindings, providers = _b.providers, exportAs = _b.exportAs, queries = _b.queries;\n _super.call(this);\n this.selector = selector;\n this._inputs = inputs;\n this._properties = properties;\n this._outputs = outputs;\n this._events = events;\n this.host = host;\n this.exportAs = exportAs;\n this.queries = queries;\n this._providers = providers;\n this._bindings = bindings;\n }\n Object.defineProperty(DirectiveMetadata.prototype, \"inputs\", {\n /**\n * Enumerates the set of data-bound input properties for a directive\n *\n * Angular automatically updates input properties during change detection.\n *\n * The `inputs` property defines a set of `directiveProperty` to `bindingProperty`\n * configuration:\n *\n * - `directiveProperty` specifies the component property where the value is written.\n * - `bindingProperty` specifies the DOM property where the value is read from.\n *\n * When `bindingProperty` is not provided, it is assumed to be equal to `directiveProperty`.\n *\n * ### Example ([live demo](http://plnkr.co/edit/ivhfXY?p=preview))\n *\n * The following example creates a component with two data-bound properties.\n *\n * ```typescript\n * @Component({\n * selector: 'bank-account',\n * inputs: ['bankName', 'id: account-id'],\n * template: `\n * Bank Name: {{bankName}}\n * Account Id: {{id}}\n * `\n * })\n * class BankAccount {\n * bankName: string;\n * id: string;\n *\n * // this property is not bound, and won't be automatically updated by Angular\n * normalizedBankName: string;\n * }\n *\n * @Component({\n * selector: 'app',\n * template: `\n * \n * `,\n * directives: [BankAccount]\n * })\n * class App {}\n *\n * bootstrap(App);\n * ```\n *\n */\n get: function () {\n return lang_1.isPresent(this._properties) && this._properties.length > 0 ? this._properties :\n this._inputs;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DirectiveMetadata.prototype, \"properties\", {\n get: function () { return this.inputs; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DirectiveMetadata.prototype, \"outputs\", {\n /**\n * Enumerates the set of event-bound output properties.\n *\n * When an output property emits an event, an event handler attached to that event\n * the template is invoked.\n *\n * The `outputs` property defines a set of `directiveProperty` to `bindingProperty`\n * configuration:\n *\n * - `directiveProperty` specifies the component property that emits events.\n * - `bindingProperty` specifies the DOM property the event handler is attached to.\n *\n * ### Example ([live demo](http://plnkr.co/edit/d5CNq7?p=preview))\n *\n * ```typescript\n * @Directive({\n * selector: 'interval-dir',\n * outputs: ['everySecond', 'five5Secs: everyFiveSeconds']\n * })\n * class IntervalDir {\n * everySecond = new EventEmitter();\n * five5Secs = new EventEmitter();\n *\n * constructor() {\n * setInterval(() => this.everySecond.emit(\"event\"), 1000);\n * setInterval(() => this.five5Secs.emit(\"event\"), 5000);\n * }\n * }\n *\n * @Component({\n * selector: 'app',\n * template: `\n * \n * \n * `,\n * directives: [IntervalDir]\n * })\n * class App {\n * everySecond() { console.log('second'); }\n * everyFiveSeconds() { console.log('five seconds'); }\n * }\n * bootstrap(App);\n * ```\n *\n */\n get: function () {\n return lang_1.isPresent(this._events) && this._events.length > 0 ? this._events : this._outputs;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DirectiveMetadata.prototype, \"events\", {\n get: function () { return this.outputs; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DirectiveMetadata.prototype, \"providers\", {\n /**\n * Defines the set of injectable objects that are visible to a Directive and its light DOM\n * children.\n *\n * ## Simple Example\n *\n * Here is an example of a class that can be injected:\n *\n * ```\n * class Greeter {\n * greet(name:string) {\n * return 'Hello ' + name + '!';\n * }\n * }\n *\n * @Directive({\n * selector: 'greet',\n * bindings: [\n * Greeter\n * ]\n * })\n * class HelloWorld {\n * greeter:Greeter;\n *\n * constructor(greeter:Greeter) {\n * this.greeter = greeter;\n * }\n * }\n * ```\n */\n get: function () {\n return lang_1.isPresent(this._bindings) && this._bindings.length > 0 ? this._bindings :\n this._providers;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DirectiveMetadata.prototype, \"bindings\", {\n /** @deprecated */\n get: function () { return this.providers; },\n enumerable: true,\n configurable: true\n });\n return DirectiveMetadata;\n}(metadata_1.InjectableMetadata));\nexports.DirectiveMetadata = DirectiveMetadata;\n/**\n * Declare reusable UI building blocks for an application.\n *\n * Each Angular component requires a single `@Component` annotation. The\n * `@Component`\n * annotation specifies when a component is instantiated, and which properties and hostListeners it\n * binds to.\n *\n * When a component is instantiated, Angular\n * - creates a shadow DOM for the component.\n * - loads the selected template into the shadow DOM.\n * - creates all the injectable objects configured with `providers` and `viewProviders`.\n *\n * All template expressions and statements are then evaluated against the component instance.\n *\n * For details on the `@View` annotation, see {@link ViewMetadata}.\n *\n * ## Lifecycle hooks\n *\n * When the component class implements some {@link ../../guide/lifecycle-hooks.html} the callbacks\n * are called by the change detection at defined points in time during the life of the component.\n *\n * ### Example\n *\n * {@example core/ts/metadata/metadata.ts region='component'}\n * @ts2dart_const\n */\nvar ComponentMetadata = (function (_super) {\n __extends(ComponentMetadata, _super);\n function ComponentMetadata(_a) {\n var _b = _a === void 0 ? {} : _a, selector = _b.selector, inputs = _b.inputs, outputs = _b.outputs, properties = _b.properties, events = _b.events, host = _b.host, exportAs = _b.exportAs, moduleId = _b.moduleId, bindings = _b.bindings, providers = _b.providers, viewBindings = _b.viewBindings, viewProviders = _b.viewProviders, _c = _b.changeDetection, changeDetection = _c === void 0 ? constants_1.ChangeDetectionStrategy.Default : _c, queries = _b.queries, templateUrl = _b.templateUrl, template = _b.template, styleUrls = _b.styleUrls, styles = _b.styles, directives = _b.directives, pipes = _b.pipes, encapsulation = _b.encapsulation;\n _super.call(this, {\n selector: selector,\n inputs: inputs,\n outputs: outputs,\n properties: properties,\n events: events,\n host: host,\n exportAs: exportAs,\n bindings: bindings,\n providers: providers,\n queries: queries\n });\n this.changeDetection = changeDetection;\n this._viewProviders = viewProviders;\n this._viewBindings = viewBindings;\n this.templateUrl = templateUrl;\n this.template = template;\n this.styleUrls = styleUrls;\n this.styles = styles;\n this.directives = directives;\n this.pipes = pipes;\n this.encapsulation = encapsulation;\n this.moduleId = moduleId;\n }\n Object.defineProperty(ComponentMetadata.prototype, \"viewProviders\", {\n /**\n * Defines the set of injectable objects that are visible to its view DOM children.\n *\n * ## Simple Example\n *\n * Here is an example of a class that can be injected:\n *\n * ```\n * class Greeter {\n * greet(name:string) {\n * return 'Hello ' + name + '!';\n * }\n * }\n *\n * @Directive({\n * selector: 'needs-greeter'\n * })\n * class NeedsGreeter {\n * greeter:Greeter;\n *\n * constructor(greeter:Greeter) {\n * this.greeter = greeter;\n * }\n * }\n *\n * @Component({\n * selector: 'greet',\n * viewProviders: [\n * Greeter\n * ],\n * template: ``,\n * directives: [NeedsGreeter]\n * })\n * class HelloWorld {\n * }\n *\n * ```\n */\n get: function () {\n return lang_1.isPresent(this._viewBindings) && this._viewBindings.length > 0 ? this._viewBindings :\n this._viewProviders;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ComponentMetadata.prototype, \"viewBindings\", {\n get: function () { return this.viewProviders; },\n enumerable: true,\n configurable: true\n });\n return ComponentMetadata;\n}(DirectiveMetadata));\nexports.ComponentMetadata = ComponentMetadata;\n/**\n * Declare reusable pipe function.\n *\n * A \"pure\" pipe is only re-evaluated when either the input or any of the arguments change.\n *\n * When not specified, pipes default to being pure.\n *\n * ### Example\n *\n * {@example core/ts/metadata/metadata.ts region='pipe'}\n * @ts2dart_const\n */\nvar PipeMetadata = (function (_super) {\n __extends(PipeMetadata, _super);\n function PipeMetadata(_a) {\n var name = _a.name, pure = _a.pure;\n _super.call(this);\n this.name = name;\n this._pure = pure;\n }\n Object.defineProperty(PipeMetadata.prototype, \"pure\", {\n get: function () { return lang_1.isPresent(this._pure) ? this._pure : true; },\n enumerable: true,\n configurable: true\n });\n return PipeMetadata;\n}(metadata_1.InjectableMetadata));\nexports.PipeMetadata = PipeMetadata;\n/**\n * Declares a data-bound input property.\n *\n * Angular automatically updates data-bound properties during change detection.\n *\n * `InputMetadata` takes an optional parameter that specifies the name\n * used when instantiating a component in the template. When not provided,\n * the name of the decorated property is used.\n *\n * ### Example\n *\n * The following example creates a component with two input properties.\n *\n * ```typescript\n * @Component({\n * selector: 'bank-account',\n * template: `\n * Bank Name: {{bankName}}\n * Account Id: {{id}}\n * `\n * })\n * class BankAccount {\n * @Input() bankName: string;\n * @Input('account-id') id: string;\n *\n * // this property is not bound, and won't be automatically updated by Angular\n * normalizedBankName: string;\n * }\n *\n * @Component({\n * selector: 'app',\n * template: `\n * \n * `,\n * directives: [BankAccount]\n * })\n * class App {}\n *\n * bootstrap(App);\n * ```\n * @ts2dart_const\n */\nvar InputMetadata = (function () {\n function InputMetadata(\n /**\n * Name used when instantiating a component in the template.\n */\n bindingPropertyName) {\n this.bindingPropertyName = bindingPropertyName;\n }\n return InputMetadata;\n}());\nexports.InputMetadata = InputMetadata;\n/**\n * Declares an event-bound output property.\n *\n * When an output property emits an event, an event handler attached to that event\n * the template is invoked.\n *\n * `OutputMetadata` takes an optional parameter that specifies the name\n * used when instantiating a component in the template. When not provided,\n * the name of the decorated property is used.\n *\n * ### Example\n *\n * ```typescript\n * @Directive({\n * selector: 'interval-dir',\n * })\n * class IntervalDir {\n * @Output() everySecond = new EventEmitter();\n * @Output('everyFiveSeconds') five5Secs = new EventEmitter();\n *\n * constructor() {\n * setInterval(() => this.everySecond.emit(\"event\"), 1000);\n * setInterval(() => this.five5Secs.emit(\"event\"), 5000);\n * }\n * }\n *\n * @Component({\n * selector: 'app',\n * template: `\n * \n * \n * `,\n * directives: [IntervalDir]\n * })\n * class App {\n * everySecond() { console.log('second'); }\n * everyFiveSeconds() { console.log('five seconds'); }\n * }\n * bootstrap(App);\n * ```\n * @ts2dart_const\n */\nvar OutputMetadata = (function () {\n function OutputMetadata(bindingPropertyName) {\n this.bindingPropertyName = bindingPropertyName;\n }\n return OutputMetadata;\n}());\nexports.OutputMetadata = OutputMetadata;\n/**\n * Declares a host property binding.\n *\n * Angular automatically checks host property bindings during change detection.\n * If a binding changes, it will update the host element of the directive.\n *\n * `HostBindingMetadata` takes an optional parameter that specifies the property\n * name of the host element that will be updated. When not provided,\n * the class property name is used.\n *\n * ### Example\n *\n * The following example creates a directive that sets the `valid` and `invalid` classes\n * on the DOM element that has ngModel directive on it.\n *\n * ```typescript\n * @Directive({selector: '[ngModel]'})\n * class NgModelStatus {\n * constructor(public control:NgModel) {}\n * @HostBinding('class.valid') get valid { return this.control.valid; }\n * @HostBinding('class.invalid') get invalid { return this.control.invalid; }\n * }\n *\n * @Component({\n * selector: 'app',\n * template: ``,\n * directives: [FORM_DIRECTIVES, NgModelStatus]\n * })\n * class App {\n * prop;\n * }\n *\n * bootstrap(App);\n * ```\n * @ts2dart_const\n */\nvar HostBindingMetadata = (function () {\n function HostBindingMetadata(hostPropertyName) {\n this.hostPropertyName = hostPropertyName;\n }\n return HostBindingMetadata;\n}());\nexports.HostBindingMetadata = HostBindingMetadata;\n/**\n * Declares a host listener.\n *\n * Angular will invoke the decorated method when the host element emits the specified event.\n *\n * If the decorated method returns `false`, then `preventDefault` is applied on the DOM\n * event.\n *\n * ### Example\n *\n * The following example declares a directive that attaches a click listener to the button and\n * counts clicks.\n *\n * ```typescript\n * @Directive({selector: 'button[counting]'})\n * class CountClicks {\n * numberOfClicks = 0;\n *\n * @HostListener('click', ['$event.target'])\n * onClick(btn) {\n * console.log(\"button\", btn, \"number of clicks:\", this.numberOfClicks++);\n * }\n * }\n *\n * @Component({\n * selector: 'app',\n * template: ``,\n * directives: [CountClicks]\n * })\n * class App {}\n *\n * bootstrap(App);\n * ```\n * @ts2dart_const\n */\nvar HostListenerMetadata = (function () {\n function HostListenerMetadata(eventName, args) {\n this.eventName = eventName;\n this.args = args;\n }\n return HostListenerMetadata;\n}());\nexports.HostListenerMetadata = HostListenerMetadata;\n//# sourceMappingURL=directives.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/metadata/directives.js\n ** module id = 196\n ** module chunks = 0\n **/","\"use strict\";\nvar lang_1 = require('../../src/facade/lang');\nvar exceptions_1 = require('../../src/facade/exceptions');\nvar ReflectionCapabilities = (function () {\n function ReflectionCapabilities(reflect) {\n this._reflect = lang_1.isPresent(reflect) ? reflect : lang_1.global.Reflect;\n }\n ReflectionCapabilities.prototype.isReflectionEnabled = function () { return true; };\n ReflectionCapabilities.prototype.factory = function (t) {\n switch (t.length) {\n case 0:\n return function () { return new t(); };\n case 1:\n return function (a1) { return new t(a1); };\n case 2:\n return function (a1, a2) { return new t(a1, a2); };\n case 3:\n return function (a1, a2, a3) { return new t(a1, a2, a3); };\n case 4:\n return function (a1, a2, a3, a4) { return new t(a1, a2, a3, a4); };\n case 5:\n return function (a1, a2, a3, a4, a5) { return new t(a1, a2, a3, a4, a5); };\n case 6:\n return function (a1, a2, a3, a4, a5, a6) {\n return new t(a1, a2, a3, a4, a5, a6);\n };\n case 7:\n return function (a1, a2, a3, a4, a5, a6, a7) {\n return new t(a1, a2, a3, a4, a5, a6, a7);\n };\n case 8:\n return function (a1, a2, a3, a4, a5, a6, a7, a8) {\n return new t(a1, a2, a3, a4, a5, a6, a7, a8);\n };\n case 9:\n return function (a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9);\n };\n case 10:\n return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {\n return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);\n };\n case 11:\n return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {\n return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);\n };\n case 12:\n return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) {\n return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);\n };\n case 13:\n return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) {\n return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);\n };\n case 14:\n return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) {\n return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);\n };\n case 15:\n return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) {\n return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);\n };\n case 16:\n return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) {\n return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16);\n };\n case 17:\n return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) {\n return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17);\n };\n case 18:\n return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) {\n return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18);\n };\n case 19:\n return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) {\n return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19);\n };\n case 20:\n return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) {\n return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);\n };\n }\n ;\n throw new Error(\"Cannot create a factory for '\" + lang_1.stringify(t) + \"' because its constructor has more than 20 arguments\");\n };\n /** @internal */\n ReflectionCapabilities.prototype._zipTypesAndAnnotations = function (paramTypes, paramAnnotations) {\n var result;\n if (typeof paramTypes === 'undefined') {\n result = new Array(paramAnnotations.length);\n }\n else {\n result = new Array(paramTypes.length);\n }\n for (var i = 0; i < result.length; i++) {\n // TS outputs Object for parameters without types, while Traceur omits\n // the annotations. For now we preserve the Traceur behavior to aid\n // migration, but this can be revisited.\n if (typeof paramTypes === 'undefined') {\n result[i] = [];\n }\n else if (paramTypes[i] != Object) {\n result[i] = [paramTypes[i]];\n }\n else {\n result[i] = [];\n }\n if (lang_1.isPresent(paramAnnotations) && lang_1.isPresent(paramAnnotations[i])) {\n result[i] = result[i].concat(paramAnnotations[i]);\n }\n }\n return result;\n };\n ReflectionCapabilities.prototype.parameters = function (typeOrFunc) {\n // Prefer the direct API.\n if (lang_1.isPresent(typeOrFunc.parameters)) {\n return typeOrFunc.parameters;\n }\n // API of tsickle for lowering decorators to properties on the class.\n if (lang_1.isPresent(typeOrFunc.ctorParameters)) {\n var ctorParameters = typeOrFunc.ctorParameters;\n var paramTypes_1 = ctorParameters.map(function (ctorParam) { return ctorParam && ctorParam.type; });\n var paramAnnotations_1 = ctorParameters.map(function (ctorParam) { return ctorParam && convertTsickleDecoratorIntoMetadata(ctorParam.decorators); });\n return this._zipTypesAndAnnotations(paramTypes_1, paramAnnotations_1);\n }\n // API for metadata created by invoking the decorators.\n if (lang_1.isPresent(this._reflect) && lang_1.isPresent(this._reflect.getMetadata)) {\n var paramAnnotations = this._reflect.getMetadata('parameters', typeOrFunc);\n var paramTypes = this._reflect.getMetadata('design:paramtypes', typeOrFunc);\n if (lang_1.isPresent(paramTypes) || lang_1.isPresent(paramAnnotations)) {\n return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);\n }\n }\n // The array has to be filled with `undefined` because holes would be skipped by `some`\n var parameters = new Array(typeOrFunc.length);\n parameters.fill(undefined);\n return parameters;\n };\n ReflectionCapabilities.prototype.annotations = function (typeOrFunc) {\n // Prefer the direct API.\n if (lang_1.isPresent(typeOrFunc.annotations)) {\n var annotations = typeOrFunc.annotations;\n if (lang_1.isFunction(annotations) && annotations.annotations) {\n annotations = annotations.annotations;\n }\n return annotations;\n }\n // API of tsickle for lowering decorators to properties on the class.\n if (lang_1.isPresent(typeOrFunc.decorators)) {\n return convertTsickleDecoratorIntoMetadata(typeOrFunc.decorators);\n }\n // API for metadata created by invoking the decorators.\n if (lang_1.isPresent(this._reflect) && lang_1.isPresent(this._reflect.getMetadata)) {\n var annotations = this._reflect.getMetadata('annotations', typeOrFunc);\n if (lang_1.isPresent(annotations))\n return annotations;\n }\n return [];\n };\n ReflectionCapabilities.prototype.propMetadata = function (typeOrFunc) {\n // Prefer the direct API.\n if (lang_1.isPresent(typeOrFunc.propMetadata)) {\n var propMetadata = typeOrFunc.propMetadata;\n if (lang_1.isFunction(propMetadata) && propMetadata.propMetadata) {\n propMetadata = propMetadata.propMetadata;\n }\n return propMetadata;\n }\n // API of tsickle for lowering decorators to properties on the class.\n if (lang_1.isPresent(typeOrFunc.propDecorators)) {\n var propDecorators_1 = typeOrFunc.propDecorators;\n var propMetadata_1 = {};\n Object.keys(propDecorators_1)\n .forEach(function (prop) {\n propMetadata_1[prop] = convertTsickleDecoratorIntoMetadata(propDecorators_1[prop]);\n });\n return propMetadata_1;\n }\n // API for metadata created by invoking the decorators.\n if (lang_1.isPresent(this._reflect) && lang_1.isPresent(this._reflect.getMetadata)) {\n var propMetadata = this._reflect.getMetadata('propMetadata', typeOrFunc);\n if (lang_1.isPresent(propMetadata))\n return propMetadata;\n }\n return {};\n };\n ReflectionCapabilities.prototype.interfaces = function (type) {\n throw new exceptions_1.BaseException(\"JavaScript does not support interfaces\");\n };\n ReflectionCapabilities.prototype.getter = function (name) { return new Function('o', 'return o.' + name + ';'); };\n ReflectionCapabilities.prototype.setter = function (name) {\n return new Function('o', 'v', 'return o.' + name + ' = v;');\n };\n ReflectionCapabilities.prototype.method = function (name) {\n var functionBody = \"if (!o.\" + name + \") throw new Error('\\\"\" + name + \"\\\" is undefined');\\n return o.\" + name + \".apply(o, args);\";\n return new Function('o', 'args', functionBody);\n };\n // There is not a concept of import uri in Js, but this is useful in developing Dart applications.\n ReflectionCapabilities.prototype.importUri = function (type) { return \"./\" + lang_1.stringify(type); };\n return ReflectionCapabilities;\n}());\nexports.ReflectionCapabilities = ReflectionCapabilities;\nfunction convertTsickleDecoratorIntoMetadata(decoratorInvocations) {\n if (!decoratorInvocations) {\n return [];\n }\n return decoratorInvocations.map(function (decoratorInvocation) {\n var decoratorType = decoratorInvocation.type;\n var annotationCls = decoratorType.annotationCls;\n var annotationArgs = decoratorInvocation.args ? decoratorInvocation.args : [];\n var annotation = Object.create(annotationCls.prototype);\n annotationCls.apply(annotation, annotationArgs);\n return annotation;\n });\n}\n//# sourceMappingURL=reflection_capabilities.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/reflection/reflection_capabilities.js\n ** module id = 197\n ** module chunks = 0\n **/","\"use strict\";\nvar __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};\nvar lang_1 = require('../../src/facade/lang');\nvar exceptions_1 = require('../../src/facade/exceptions');\nvar collection_1 = require('../../src/facade/collection');\nvar reflector_reader_1 = require('./reflector_reader');\n/**\n * Reflective information about a symbol, including annotations, interfaces, and other metadata.\n */\nvar ReflectionInfo = (function () {\n function ReflectionInfo(annotations, parameters, factory, interfaces, propMetadata) {\n this.annotations = annotations;\n this.parameters = parameters;\n this.factory = factory;\n this.interfaces = interfaces;\n this.propMetadata = propMetadata;\n }\n return ReflectionInfo;\n}());\nexports.ReflectionInfo = ReflectionInfo;\n/**\n * Provides access to reflection data about symbols. Used internally by Angular\n * to power dependency injection and compilation.\n */\nvar Reflector = (function (_super) {\n __extends(Reflector, _super);\n function Reflector(reflectionCapabilities) {\n _super.call(this);\n /** @internal */\n this._injectableInfo = new collection_1.Map();\n /** @internal */\n this._getters = new collection_1.Map();\n /** @internal */\n this._setters = new collection_1.Map();\n /** @internal */\n this._methods = new collection_1.Map();\n this._usedKeys = null;\n this.reflectionCapabilities = reflectionCapabilities;\n }\n Reflector.prototype.isReflectionEnabled = function () { return this.reflectionCapabilities.isReflectionEnabled(); };\n /**\n * Causes `this` reflector to track keys used to access\n * {@link ReflectionInfo} objects.\n */\n Reflector.prototype.trackUsage = function () { this._usedKeys = new collection_1.Set(); };\n /**\n * Lists types for which reflection information was not requested since\n * {@link #trackUsage} was called. This list could later be audited as\n * potential dead code.\n */\n Reflector.prototype.listUnusedKeys = function () {\n var _this = this;\n if (this._usedKeys == null) {\n throw new exceptions_1.BaseException('Usage tracking is disabled');\n }\n var allTypes = collection_1.MapWrapper.keys(this._injectableInfo);\n return allTypes.filter(function (key) { return !collection_1.SetWrapper.has(_this._usedKeys, key); });\n };\n Reflector.prototype.registerFunction = function (func, funcInfo) {\n this._injectableInfo.set(func, funcInfo);\n };\n Reflector.prototype.registerType = function (type, typeInfo) {\n this._injectableInfo.set(type, typeInfo);\n };\n Reflector.prototype.registerGetters = function (getters) { _mergeMaps(this._getters, getters); };\n Reflector.prototype.registerSetters = function (setters) { _mergeMaps(this._setters, setters); };\n Reflector.prototype.registerMethods = function (methods) { _mergeMaps(this._methods, methods); };\n Reflector.prototype.factory = function (type) {\n if (this._containsReflectionInfo(type)) {\n var res = this._getReflectionInfo(type).factory;\n return lang_1.isPresent(res) ? res : null;\n }\n else {\n return this.reflectionCapabilities.factory(type);\n }\n };\n Reflector.prototype.parameters = function (typeOrFunc) {\n if (this._injectableInfo.has(typeOrFunc)) {\n var res = this._getReflectionInfo(typeOrFunc).parameters;\n return lang_1.isPresent(res) ? res : [];\n }\n else {\n return this.reflectionCapabilities.parameters(typeOrFunc);\n }\n };\n Reflector.prototype.annotations = function (typeOrFunc) {\n if (this._injectableInfo.has(typeOrFunc)) {\n var res = this._getReflectionInfo(typeOrFunc).annotations;\n return lang_1.isPresent(res) ? res : [];\n }\n else {\n return this.reflectionCapabilities.annotations(typeOrFunc);\n }\n };\n Reflector.prototype.propMetadata = function (typeOrFunc) {\n if (this._injectableInfo.has(typeOrFunc)) {\n var res = this._getReflectionInfo(typeOrFunc).propMetadata;\n return lang_1.isPresent(res) ? res : {};\n }\n else {\n return this.reflectionCapabilities.propMetadata(typeOrFunc);\n }\n };\n Reflector.prototype.interfaces = function (type) {\n if (this._injectableInfo.has(type)) {\n var res = this._getReflectionInfo(type).interfaces;\n return lang_1.isPresent(res) ? res : [];\n }\n else {\n return this.reflectionCapabilities.interfaces(type);\n }\n };\n Reflector.prototype.getter = function (name) {\n if (this._getters.has(name)) {\n return this._getters.get(name);\n }\n else {\n return this.reflectionCapabilities.getter(name);\n }\n };\n Reflector.prototype.setter = function (name) {\n if (this._setters.has(name)) {\n return this._setters.get(name);\n }\n else {\n return this.reflectionCapabilities.setter(name);\n }\n };\n Reflector.prototype.method = function (name) {\n if (this._methods.has(name)) {\n return this._methods.get(name);\n }\n else {\n return this.reflectionCapabilities.method(name);\n }\n };\n /** @internal */\n Reflector.prototype._getReflectionInfo = function (typeOrFunc) {\n if (lang_1.isPresent(this._usedKeys)) {\n this._usedKeys.add(typeOrFunc);\n }\n return this._injectableInfo.get(typeOrFunc);\n };\n /** @internal */\n Reflector.prototype._containsReflectionInfo = function (typeOrFunc) { return this._injectableInfo.has(typeOrFunc); };\n Reflector.prototype.importUri = function (type) { return this.reflectionCapabilities.importUri(type); };\n return Reflector;\n}(reflector_reader_1.ReflectorReader));\nexports.Reflector = Reflector;\nfunction _mergeMaps(target, config) {\n collection_1.StringMapWrapper.forEach(config, function (v, k) { return target.set(k, v); });\n}\n//# sourceMappingURL=reflector.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/reflection/reflector.js\n ** module id = 198\n ** module chunks = 0\n **/","\"use strict\";\n/**\n* A SecurityContext marks a location that has dangerous security implications, e.g. a DOM property\n* like `innerHTML` that could cause Cross Site Scripting (XSS) security bugs when improperly\n* handled.\n*\n* See DomSanitizationService for more details on security in Angular applications.\n*/\n(function (SecurityContext) {\n SecurityContext[SecurityContext[\"NONE\"] = 0] = \"NONE\";\n SecurityContext[SecurityContext[\"HTML\"] = 1] = \"HTML\";\n SecurityContext[SecurityContext[\"STYLE\"] = 2] = \"STYLE\";\n SecurityContext[SecurityContext[\"SCRIPT\"] = 3] = \"SCRIPT\";\n SecurityContext[SecurityContext[\"URL\"] = 4] = \"URL\";\n SecurityContext[SecurityContext[\"RESOURCE_URL\"] = 5] = \"RESOURCE_URL\";\n})(exports.SecurityContext || (exports.SecurityContext = {}));\nvar SecurityContext = exports.SecurityContext;\n/**\n * SanitizationService is used by the views to sanitize potentially dangerous values. This is a\n * private API, use code should only refer to DomSanitizationService.\n */\nvar SanitizationService = (function () {\n function SanitizationService() {\n }\n return SanitizationService;\n}());\nexports.SanitizationService = SanitizationService;\n//# sourceMappingURL=security.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/security.js\n ** module id = 199\n ** module chunks = 0\n **/","\"use strict\";\n/**\n* Stores error information; delivered via [NgZone.onError] stream.\n*/\nvar NgZoneError = (function () {\n function NgZoneError(error, stackTrace) {\n this.error = error;\n this.stackTrace = stackTrace;\n }\n return NgZoneError;\n}());\nexports.NgZoneError = NgZoneError;\nvar NgZoneImpl = (function () {\n function NgZoneImpl(_a) {\n var _this = this;\n var trace = _a.trace, onEnter = _a.onEnter, onLeave = _a.onLeave, setMicrotask = _a.setMicrotask, setMacrotask = _a.setMacrotask, onError = _a.onError;\n this.onEnter = onEnter;\n this.onLeave = onLeave;\n this.setMicrotask = setMicrotask;\n this.setMacrotask = setMacrotask;\n this.onError = onError;\n if (Zone) {\n this.outer = this.inner = Zone.current;\n if (Zone['wtfZoneSpec']) {\n this.inner = this.inner.fork(Zone['wtfZoneSpec']);\n }\n if (trace && Zone['longStackTraceZoneSpec']) {\n this.inner = this.inner.fork(Zone['longStackTraceZoneSpec']);\n }\n this.inner = this.inner.fork({\n name: 'angular',\n properties: { 'isAngularZone': true },\n onInvokeTask: function (delegate, current, target, task, applyThis, applyArgs) {\n try {\n _this.onEnter();\n return delegate.invokeTask(target, task, applyThis, applyArgs);\n }\n finally {\n _this.onLeave();\n }\n },\n onInvoke: function (delegate, current, target, callback, applyThis, applyArgs, source) {\n try {\n _this.onEnter();\n return delegate.invoke(target, callback, applyThis, applyArgs, source);\n }\n finally {\n _this.onLeave();\n }\n },\n onHasTask: function (delegate, current, target, hasTaskState) {\n delegate.hasTask(target, hasTaskState);\n if (current == target) {\n // We are only interested in hasTask events which originate from our zone\n // (A child hasTask event is not interesting to us)\n if (hasTaskState.change == 'microTask') {\n _this.setMicrotask(hasTaskState.microTask);\n }\n else if (hasTaskState.change == 'macroTask') {\n _this.setMacrotask(hasTaskState.macroTask);\n }\n }\n },\n onHandleError: function (delegate, current, target, error) {\n delegate.handleError(target, error);\n _this.onError(new NgZoneError(error, error.stack));\n return false;\n }\n });\n }\n else {\n throw new Error('Angular requires Zone.js polyfill.');\n }\n }\n NgZoneImpl.isInAngularZone = function () { return Zone.current.get('isAngularZone') === true; };\n NgZoneImpl.prototype.runInner = function (fn) { return this.inner.run(fn); };\n ;\n NgZoneImpl.prototype.runInnerGuarded = function (fn) { return this.inner.runGuarded(fn); };\n ;\n NgZoneImpl.prototype.runOuter = function (fn) { return this.outer.run(fn); };\n ;\n return NgZoneImpl;\n}());\nexports.NgZoneImpl = NgZoneImpl;\n//# sourceMappingURL=ng_zone_impl.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/zone/ng_zone_impl.js\n ** module id = 200\n ** module chunks = 0\n **/","\"use strict\";\nvar __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};\nvar isFunction_1 = require('./util/isFunction');\nvar Subscription_1 = require('./Subscription');\nvar rxSubscriber_1 = require('./symbol/rxSubscriber');\nvar Observer_1 = require('./Observer');\n/**\n * Implements the {@link Observer} interface and extends the\n * {@link Subscription} class. While the {@link Observer} is the public API for\n * consuming the values of an {@link Observable}, all Observers get converted to\n * a Subscriber, in order to provide Subscription-like capabilities such as\n * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for\n * implementing operators, but it is rarely used as a public API.\n *\n * @class Subscriber\n */\nvar Subscriber = (function (_super) {\n __extends(Subscriber, _super);\n /**\n * @param {Observer|function(value: T): void} [destinationOrNext] A partially\n * defined Observer or a `next` callback function.\n * @param {function(e: ?any): void} [error] The `error` callback of an\n * Observer.\n * @param {function(): void} [complete] The `complete` callback of an\n * Observer.\n */\n function Subscriber(destinationOrNext, error, complete) {\n _super.call(this);\n this.syncErrorValue = null;\n this.syncErrorThrown = false;\n this.syncErrorThrowable = false;\n this.isStopped = false;\n switch (arguments.length) {\n case 0:\n this.destination = Observer_1.empty;\n break;\n case 1:\n if (!destinationOrNext) {\n this.destination = Observer_1.empty;\n break;\n }\n if (typeof destinationOrNext === 'object') {\n if (destinationOrNext instanceof Subscriber) {\n this.destination = destinationOrNext;\n this.destination.add(this);\n }\n else {\n this.syncErrorThrowable = true;\n this.destination = new SafeSubscriber(this, destinationOrNext);\n }\n break;\n }\n default:\n this.syncErrorThrowable = true;\n this.destination = new SafeSubscriber(this, destinationOrNext, error, complete);\n break;\n }\n }\n /**\n * A static factory for a Subscriber, given a (potentially partial) definition\n * of an Observer.\n * @param {function(x: ?T): void} [next] The `next` callback of an Observer.\n * @param {function(e: ?any): void} [error] The `error` callback of an\n * Observer.\n * @param {function(): void} [complete] The `complete` callback of an\n * Observer.\n * @return {Subscriber} A Subscriber wrapping the (partially defined)\n * Observer represented by the given arguments.\n */\n Subscriber.create = function (next, error, complete) {\n var subscriber = new Subscriber(next, error, complete);\n subscriber.syncErrorThrowable = false;\n return subscriber;\n };\n /**\n * The {@link Observer} callback to receive notifications of type `next` from\n * the Observable, with a value. The Observable may call this method 0 or more\n * times.\n * @param {T} [value] The `next` value.\n * @return {void}\n */\n Subscriber.prototype.next = function (value) {\n if (!this.isStopped) {\n this._next(value);\n }\n };\n /**\n * The {@link Observer} callback to receive notifications of type `error` from\n * the Observable, with an attached {@link Error}. Notifies the Observer that\n * the Observable has experienced an error condition.\n * @param {any} [err] The `error` exception.\n * @return {void}\n */\n Subscriber.prototype.error = function (err) {\n if (!this.isStopped) {\n this.isStopped = true;\n this._error(err);\n }\n };\n /**\n * The {@link Observer} callback to receive a valueless notification of type\n * `complete` from the Observable. Notifies the Observer that the Observable\n * has finished sending push-based notifications.\n * @return {void}\n */\n Subscriber.prototype.complete = function () {\n if (!this.isStopped) {\n this.isStopped = true;\n this._complete();\n }\n };\n Subscriber.prototype.unsubscribe = function () {\n if (this.isUnsubscribed) {\n return;\n }\n this.isStopped = true;\n _super.prototype.unsubscribe.call(this);\n };\n Subscriber.prototype._next = function (value) {\n this.destination.next(value);\n };\n Subscriber.prototype._error = function (err) {\n this.destination.error(err);\n this.unsubscribe();\n };\n Subscriber.prototype._complete = function () {\n this.destination.complete();\n this.unsubscribe();\n };\n Subscriber.prototype[rxSubscriber_1.$$rxSubscriber] = function () {\n return this;\n };\n return Subscriber;\n}(Subscription_1.Subscription));\nexports.Subscriber = Subscriber;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SafeSubscriber = (function (_super) {\n __extends(SafeSubscriber, _super);\n function SafeSubscriber(_parent, observerOrNext, error, complete) {\n _super.call(this);\n this._parent = _parent;\n var next;\n var context = this;\n if (isFunction_1.isFunction(observerOrNext)) {\n next = observerOrNext;\n }\n else if (observerOrNext) {\n context = observerOrNext;\n next = observerOrNext.next;\n error = observerOrNext.error;\n complete = observerOrNext.complete;\n if (isFunction_1.isFunction(context.unsubscribe)) {\n this.add(context.unsubscribe.bind(context));\n }\n context.unsubscribe = this.unsubscribe.bind(this);\n }\n this._context = context;\n this._next = next;\n this._error = error;\n this._complete = complete;\n }\n SafeSubscriber.prototype.next = function (value) {\n if (!this.isStopped && this._next) {\n var _parent = this._parent;\n if (!_parent.syncErrorThrowable) {\n this.__tryOrUnsub(this._next, value);\n }\n else if (this.__tryOrSetError(_parent, this._next, value)) {\n this.unsubscribe();\n }\n }\n };\n SafeSubscriber.prototype.error = function (err) {\n if (!this.isStopped) {\n var _parent = this._parent;\n if (this._error) {\n if (!_parent.syncErrorThrowable) {\n this.__tryOrUnsub(this._error, err);\n this.unsubscribe();\n }\n else {\n this.__tryOrSetError(_parent, this._error, err);\n this.unsubscribe();\n }\n }\n else if (!_parent.syncErrorThrowable) {\n this.unsubscribe();\n throw err;\n }\n else {\n _parent.syncErrorValue = err;\n _parent.syncErrorThrown = true;\n this.unsubscribe();\n }\n }\n };\n SafeSubscriber.prototype.complete = function () {\n if (!this.isStopped) {\n var _parent = this._parent;\n if (this._complete) {\n if (!_parent.syncErrorThrowable) {\n this.__tryOrUnsub(this._complete);\n this.unsubscribe();\n }\n else {\n this.__tryOrSetError(_parent, this._complete);\n this.unsubscribe();\n }\n }\n else {\n this.unsubscribe();\n }\n }\n };\n SafeSubscriber.prototype.__tryOrUnsub = function (fn, value) {\n try {\n fn.call(this._context, value);\n }\n catch (err) {\n this.unsubscribe();\n throw err;\n }\n };\n SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) {\n try {\n fn.call(this._context, value);\n }\n catch (err) {\n parent.syncErrorValue = err;\n parent.syncErrorThrown = true;\n return true;\n }\n return false;\n };\n SafeSubscriber.prototype._unsubscribe = function () {\n var _parent = this._parent;\n this._context = null;\n this._parent = null;\n _parent.unsubscribe();\n };\n return SafeSubscriber;\n}(Subscriber));\n//# sourceMappingURL=Subscriber.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/rxjs/Subscriber.js\n ** module id = 343\n ** module chunks = 0\n **/","\"use strict\";\n// typeof any so that it we don't have to cast when comparing a result to the error object\nexports.errorObject = { e: {} };\n//# sourceMappingURL=errorObject.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/rxjs/util/errorObject.js\n ** module id = 344\n ** module chunks = 0\n **/","\"use strict\";\nfunction isFunction(x) {\n return typeof x === 'function';\n}\nexports.isFunction = isFunction;\n//# sourceMappingURL=isFunction.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/rxjs/util/isFunction.js\n ** module id = 345\n ** module chunks = 0\n **/","\"use strict\";\nvar forms_1 = require('./forms');\nvar directives_1 = require('./directives');\n/**\n * A collection of Angular core directives that are likely to be used in each and every Angular\n * application. This includes core directives (e.g., NgIf and NgFor), and forms directives (e.g.,\n * NgModel).\n *\n * This collection can be used to quickly enumerate all the built-in directives in the `directives`\n * property of the `@Component` decorator.\n *\n * ### Example\n *\n * Instead of writing:\n *\n * ```typescript\n * import {NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault, NgModel, NgForm} from\n * '@angular/common';\n * import {OtherDirective} from './myDirectives';\n *\n * @Component({\n * selector: 'my-component',\n * templateUrl: 'myComponent.html',\n * directives: [NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault, NgModel, NgForm,\n * OtherDirective]\n * })\n * export class MyComponent {\n * ...\n * }\n * ```\n * one could import all the common directives at once:\n *\n * ```typescript\n * import {COMMON_DIRECTIVES} from '@angular/common';\n * import {OtherDirective} from './myDirectives';\n *\n * @Component({\n * selector: 'my-component',\n * templateUrl: 'myComponent.html',\n * directives: [COMMON_DIRECTIVES, OtherDirective]\n * })\n * export class MyComponent {\n * ...\n * }\n * ```\n */\nexports.COMMON_DIRECTIVES = [directives_1.CORE_DIRECTIVES, forms_1.FORM_DIRECTIVES];\n//# sourceMappingURL=common_directives.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/common/src/common_directives.js\n ** module id = 346\n ** module chunks = 0\n **/","\"use strict\";\nvar ng_class_1 = require('./ng_class');\nvar ng_for_1 = require('./ng_for');\nvar ng_if_1 = require('./ng_if');\nvar ng_template_outlet_1 = require('./ng_template_outlet');\nvar ng_style_1 = require('./ng_style');\nvar ng_switch_1 = require('./ng_switch');\nvar ng_plural_1 = require('./ng_plural');\n/**\n * A collection of Angular core directives that are likely to be used in each and every Angular\n * application.\n *\n * This collection can be used to quickly enumerate all the built-in directives in the `directives`\n * property of the `@Component` annotation.\n *\n * ### Example ([live demo](http://plnkr.co/edit/yakGwpCdUkg0qfzX5m8g?p=preview))\n *\n * Instead of writing:\n *\n * ```typescript\n * import {NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault} from '@angular/common';\n * import {OtherDirective} from './myDirectives';\n *\n * @Component({\n * selector: 'my-component',\n * templateUrl: 'myComponent.html',\n * directives: [NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault, OtherDirective]\n * })\n * export class MyComponent {\n * ...\n * }\n * ```\n * one could import all the core directives at once:\n *\n * ```typescript\n * import {CORE_DIRECTIVES} from '@angular/common';\n * import {OtherDirective} from './myDirectives';\n *\n * @Component({\n * selector: 'my-component',\n * templateUrl: 'myComponent.html',\n * directives: [CORE_DIRECTIVES, OtherDirective]\n * })\n * export class MyComponent {\n * ...\n * }\n * ```\n */\nexports.CORE_DIRECTIVES = [\n ng_class_1.NgClass,\n ng_for_1.NgFor,\n ng_if_1.NgIf,\n ng_template_outlet_1.NgTemplateOutlet,\n ng_style_1.NgStyle,\n ng_switch_1.NgSwitch,\n ng_switch_1.NgSwitchWhen,\n ng_switch_1.NgSwitchDefault,\n ng_plural_1.NgPlural,\n ng_plural_1.NgPluralCase\n];\n//# sourceMappingURL=core_directives.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/common/src/directives/core_directives.js\n ** module id = 347\n ** module chunks = 0\n **/","\"use strict\";\n//# sourceMappingURL=observable_list_diff.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/common/src/directives/observable_list_diff.js\n ** module id = 348\n ** module chunks = 0\n **/","\"use strict\";\nvar ng_control_name_1 = require('./directives/ng_control_name');\nvar ng_form_control_1 = require('./directives/ng_form_control');\nvar ng_model_1 = require('./directives/ng_model');\nvar ng_control_group_1 = require('./directives/ng_control_group');\nvar ng_form_model_1 = require('./directives/ng_form_model');\nvar ng_form_1 = require('./directives/ng_form');\nvar default_value_accessor_1 = require('./directives/default_value_accessor');\nvar checkbox_value_accessor_1 = require('./directives/checkbox_value_accessor');\nvar number_value_accessor_1 = require('./directives/number_value_accessor');\nvar radio_control_value_accessor_1 = require('./directives/radio_control_value_accessor');\nvar ng_control_status_1 = require('./directives/ng_control_status');\nvar select_control_value_accessor_1 = require('./directives/select_control_value_accessor');\nvar validators_1 = require('./directives/validators');\nvar ng_control_name_2 = require('./directives/ng_control_name');\nexports.NgControlName = ng_control_name_2.NgControlName;\nvar ng_form_control_2 = require('./directives/ng_form_control');\nexports.NgFormControl = ng_form_control_2.NgFormControl;\nvar ng_model_2 = require('./directives/ng_model');\nexports.NgModel = ng_model_2.NgModel;\nvar ng_control_group_2 = require('./directives/ng_control_group');\nexports.NgControlGroup = ng_control_group_2.NgControlGroup;\nvar ng_form_model_2 = require('./directives/ng_form_model');\nexports.NgFormModel = ng_form_model_2.NgFormModel;\nvar ng_form_2 = require('./directives/ng_form');\nexports.NgForm = ng_form_2.NgForm;\nvar default_value_accessor_2 = require('./directives/default_value_accessor');\nexports.DefaultValueAccessor = default_value_accessor_2.DefaultValueAccessor;\nvar checkbox_value_accessor_2 = require('./directives/checkbox_value_accessor');\nexports.CheckboxControlValueAccessor = checkbox_value_accessor_2.CheckboxControlValueAccessor;\nvar radio_control_value_accessor_2 = require('./directives/radio_control_value_accessor');\nexports.RadioControlValueAccessor = radio_control_value_accessor_2.RadioControlValueAccessor;\nexports.RadioButtonState = radio_control_value_accessor_2.RadioButtonState;\nvar number_value_accessor_2 = require('./directives/number_value_accessor');\nexports.NumberValueAccessor = number_value_accessor_2.NumberValueAccessor;\nvar ng_control_status_2 = require('./directives/ng_control_status');\nexports.NgControlStatus = ng_control_status_2.NgControlStatus;\nvar select_control_value_accessor_2 = require('./directives/select_control_value_accessor');\nexports.SelectControlValueAccessor = select_control_value_accessor_2.SelectControlValueAccessor;\nexports.NgSelectOption = select_control_value_accessor_2.NgSelectOption;\nvar validators_2 = require('./directives/validators');\nexports.RequiredValidator = validators_2.RequiredValidator;\nexports.MinLengthValidator = validators_2.MinLengthValidator;\nexports.MaxLengthValidator = validators_2.MaxLengthValidator;\nexports.PatternValidator = validators_2.PatternValidator;\nvar ng_control_1 = require('./directives/ng_control');\nexports.NgControl = ng_control_1.NgControl;\n/**\n *\n * A list of all the form directives used as part of a `@Component` annotation.\n *\n * This is a shorthand for importing them each individually.\n *\n * ### Example\n *\n * ```typescript\n * @Component({\n * selector: 'my-app',\n * directives: [FORM_DIRECTIVES]\n * })\n * class MyApp {}\n * ```\n */\nexports.FORM_DIRECTIVES = [\n ng_control_name_1.NgControlName,\n ng_control_group_1.NgControlGroup,\n ng_form_control_1.NgFormControl,\n ng_model_1.NgModel,\n ng_form_model_1.NgFormModel,\n ng_form_1.NgForm,\n select_control_value_accessor_1.NgSelectOption,\n default_value_accessor_1.DefaultValueAccessor,\n number_value_accessor_1.NumberValueAccessor,\n checkbox_value_accessor_1.CheckboxControlValueAccessor,\n select_control_value_accessor_1.SelectControlValueAccessor,\n radio_control_value_accessor_1.RadioControlValueAccessor,\n ng_control_status_1.NgControlStatus,\n validators_1.RequiredValidator,\n validators_1.MinLengthValidator,\n validators_1.MaxLengthValidator,\n validators_1.PatternValidator\n];\n//# sourceMappingURL=directives.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/common/src/forms/directives.js\n ** module id = 349\n ** module chunks = 0\n **/","\"use strict\";\nfunction normalizeValidator(validator) {\n if (validator.validate !== undefined) {\n return function (c) { return validator.validate(c); };\n }\n else {\n return validator;\n }\n}\nexports.normalizeValidator = normalizeValidator;\nfunction normalizeAsyncValidator(validator) {\n if (validator.validate !== undefined) {\n return function (c) { return Promise.resolve(validator.validate(c)); };\n }\n else {\n return validator;\n }\n}\nexports.normalizeAsyncValidator = normalizeAsyncValidator;\n//# sourceMappingURL=normalize_validator.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/common/src/forms/directives/normalize_validator.js\n ** module id = 350\n ** module chunks = 0\n **/","\"use strict\";\nfunction __export(m) {\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\n__export(require('./location/platform_location'));\n__export(require('./location/location_strategy'));\n__export(require('./location/hash_location_strategy'));\n__export(require('./location/path_location_strategy'));\n__export(require('./location/location'));\n//# sourceMappingURL=location.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/common/src/location.js\n ** module id = 351\n ** module chunks = 0\n **/","\"use strict\";\nvar __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};\nvar core_1 = require('@angular/core');\nvar lang_1 = require('../../src/facade/lang');\nvar location_strategy_1 = require('./location_strategy');\nvar location_1 = require('./location');\nvar platform_location_1 = require('./platform_location');\nvar HashLocationStrategy = (function (_super) {\n __extends(HashLocationStrategy, _super);\n function HashLocationStrategy(_platformLocation, _baseHref) {\n _super.call(this);\n this._platformLocation = _platformLocation;\n this._baseHref = '';\n if (lang_1.isPresent(_baseHref)) {\n this._baseHref = _baseHref;\n }\n }\n HashLocationStrategy.prototype.onPopState = function (fn) {\n this._platformLocation.onPopState(fn);\n this._platformLocation.onHashChange(fn);\n };\n HashLocationStrategy.prototype.getBaseHref = function () { return this._baseHref; };\n HashLocationStrategy.prototype.path = function () {\n // the hash value is always prefixed with a `#`\n // and if it is empty then it will stay empty\n var path = this._platformLocation.hash;\n if (!lang_1.isPresent(path))\n path = '#';\n // Dart will complain if a call to substring is\n // executed with a position value that extends the\n // length of string.\n return (path.length > 0 ? path.substring(1) : path);\n };\n HashLocationStrategy.prototype.prepareExternalUrl = function (internal) {\n var url = location_1.Location.joinWithSlash(this._baseHref, internal);\n return url.length > 0 ? ('#' + url) : url;\n };\n HashLocationStrategy.prototype.pushState = function (state, title, path, queryParams) {\n var url = this.prepareExternalUrl(path + location_1.Location.normalizeQueryParams(queryParams));\n if (url.length == 0) {\n url = this._platformLocation.pathname;\n }\n this._platformLocation.pushState(state, title, url);\n };\n HashLocationStrategy.prototype.replaceState = function (state, title, path, queryParams) {\n var url = this.prepareExternalUrl(path + location_1.Location.normalizeQueryParams(queryParams));\n if (url.length == 0) {\n url = this._platformLocation.pathname;\n }\n this._platformLocation.replaceState(state, title, url);\n };\n HashLocationStrategy.prototype.forward = function () { this._platformLocation.forward(); };\n HashLocationStrategy.prototype.back = function () { this._platformLocation.back(); };\n HashLocationStrategy.decorators = [\n { type: core_1.Injectable },\n ];\n HashLocationStrategy.ctorParameters = [\n { type: platform_location_1.PlatformLocation, },\n { type: undefined, decorators: [{ type: core_1.Optional }, { type: core_1.Inject, args: [location_strategy_1.APP_BASE_HREF,] },] },\n ];\n return HashLocationStrategy;\n}(location_strategy_1.LocationStrategy));\nexports.HashLocationStrategy = HashLocationStrategy;\n//# sourceMappingURL=hash_location_strategy.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/common/src/location/hash_location_strategy.js\n ** module id = 352\n ** module chunks = 0\n **/","\"use strict\";\nvar __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};\nvar core_1 = require('@angular/core');\nvar lang_1 = require('../../src/facade/lang');\nvar exceptions_1 = require('../../src/facade/exceptions');\nvar platform_location_1 = require('./platform_location');\nvar location_strategy_1 = require('./location_strategy');\nvar location_1 = require('./location');\nvar PathLocationStrategy = (function (_super) {\n __extends(PathLocationStrategy, _super);\n function PathLocationStrategy(_platformLocation, href) {\n _super.call(this);\n this._platformLocation = _platformLocation;\n if (lang_1.isBlank(href)) {\n href = this._platformLocation.getBaseHrefFromDOM();\n }\n if (lang_1.isBlank(href)) {\n throw new exceptions_1.BaseException(\"No base href set. Please provide a value for the APP_BASE_HREF token or add a base element to the document.\");\n }\n this._baseHref = href;\n }\n PathLocationStrategy.prototype.onPopState = function (fn) {\n this._platformLocation.onPopState(fn);\n this._platformLocation.onHashChange(fn);\n };\n PathLocationStrategy.prototype.getBaseHref = function () { return this._baseHref; };\n PathLocationStrategy.prototype.prepareExternalUrl = function (internal) {\n return location_1.Location.joinWithSlash(this._baseHref, internal);\n };\n PathLocationStrategy.prototype.path = function () {\n return this._platformLocation.pathname +\n location_1.Location.normalizeQueryParams(this._platformLocation.search);\n };\n PathLocationStrategy.prototype.pushState = function (state, title, url, queryParams) {\n var externalUrl = this.prepareExternalUrl(url + location_1.Location.normalizeQueryParams(queryParams));\n this._platformLocation.pushState(state, title, externalUrl);\n };\n PathLocationStrategy.prototype.replaceState = function (state, title, url, queryParams) {\n var externalUrl = this.prepareExternalUrl(url + location_1.Location.normalizeQueryParams(queryParams));\n this._platformLocation.replaceState(state, title, externalUrl);\n };\n PathLocationStrategy.prototype.forward = function () { this._platformLocation.forward(); };\n PathLocationStrategy.prototype.back = function () { this._platformLocation.back(); };\n PathLocationStrategy.decorators = [\n { type: core_1.Injectable },\n ];\n PathLocationStrategy.ctorParameters = [\n { type: platform_location_1.PlatformLocation, },\n { type: undefined, decorators: [{ type: core_1.Optional }, { type: core_1.Inject, args: [location_strategy_1.APP_BASE_HREF,] },] },\n ];\n return PathLocationStrategy;\n}(location_strategy_1.LocationStrategy));\nexports.PathLocationStrategy = PathLocationStrategy;\n//# sourceMappingURL=path_location_strategy.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/common/src/location/path_location_strategy.js\n ** module id = 353\n ** module chunks = 0\n **/","\"use strict\";\n/**\n* @module\n* @description\n* This module provides a set of common Pipes.\n*/\nvar async_pipe_1 = require('./pipes/async_pipe');\nexports.AsyncPipe = async_pipe_1.AsyncPipe;\nvar date_pipe_1 = require('./pipes/date_pipe');\nexports.DatePipe = date_pipe_1.DatePipe;\nvar json_pipe_1 = require('./pipes/json_pipe');\nexports.JsonPipe = json_pipe_1.JsonPipe;\nvar slice_pipe_1 = require('./pipes/slice_pipe');\nexports.SlicePipe = slice_pipe_1.SlicePipe;\nvar lowercase_pipe_1 = require('./pipes/lowercase_pipe');\nexports.LowerCasePipe = lowercase_pipe_1.LowerCasePipe;\nvar number_pipe_1 = require('./pipes/number_pipe');\nexports.NumberPipe = number_pipe_1.NumberPipe;\nexports.DecimalPipe = number_pipe_1.DecimalPipe;\nexports.PercentPipe = number_pipe_1.PercentPipe;\nexports.CurrencyPipe = number_pipe_1.CurrencyPipe;\nvar uppercase_pipe_1 = require('./pipes/uppercase_pipe');\nexports.UpperCasePipe = uppercase_pipe_1.UpperCasePipe;\nvar replace_pipe_1 = require('./pipes/replace_pipe');\nexports.ReplacePipe = replace_pipe_1.ReplacePipe;\nvar i18n_plural_pipe_1 = require('./pipes/i18n_plural_pipe');\nexports.I18nPluralPipe = i18n_plural_pipe_1.I18nPluralPipe;\nvar i18n_select_pipe_1 = require('./pipes/i18n_select_pipe');\nexports.I18nSelectPipe = i18n_select_pipe_1.I18nSelectPipe;\nvar common_pipes_1 = require('./pipes/common_pipes');\nexports.COMMON_PIPES = common_pipes_1.COMMON_PIPES;\n//# sourceMappingURL=pipes.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/common/src/pipes.js\n ** module id = 354\n ** module chunks = 0\n **/","\"use strict\";\n/**\n* @module\n* @description\n* This module provides a set of common Pipes.\n*/\nvar async_pipe_1 = require('./async_pipe');\nvar uppercase_pipe_1 = require('./uppercase_pipe');\nvar lowercase_pipe_1 = require('./lowercase_pipe');\nvar json_pipe_1 = require('./json_pipe');\nvar slice_pipe_1 = require('./slice_pipe');\nvar date_pipe_1 = require('./date_pipe');\nvar number_pipe_1 = require('./number_pipe');\nvar replace_pipe_1 = require('./replace_pipe');\nvar i18n_plural_pipe_1 = require('./i18n_plural_pipe');\nvar i18n_select_pipe_1 = require('./i18n_select_pipe');\n/**\n * A collection of Angular core pipes that are likely to be used in each and every\n * application.\n *\n * This collection can be used to quickly enumerate all the built-in pipes in the `pipes`\n * property of the `@Component` decorator.\n */\nexports.COMMON_PIPES = [\n async_pipe_1.AsyncPipe,\n uppercase_pipe_1.UpperCasePipe,\n lowercase_pipe_1.LowerCasePipe,\n json_pipe_1.JsonPipe,\n slice_pipe_1.SlicePipe,\n number_pipe_1.DecimalPipe,\n number_pipe_1.PercentPipe,\n number_pipe_1.CurrencyPipe,\n date_pipe_1.DatePipe,\n replace_pipe_1.ReplacePipe,\n i18n_plural_pipe_1.I18nPluralPipe,\n i18n_select_pipe_1.I18nSelectPipe\n];\n//# sourceMappingURL=common_pipes.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/common/src/pipes/common_pipes.js\n ** module id = 355\n ** module chunks = 0\n **/","\"use strict\";\nvar constants = require('./src/change_detection/constants');\nvar security = require('./src/security');\nvar reflective_provider = require('./src/di/reflective_provider');\nvar lifecycle_hooks = require('./src/metadata/lifecycle_hooks');\nvar reflector_reader = require('./src/reflection/reflector_reader');\nvar component_resolver = require('./src/linker/component_resolver');\nvar element = require('./src/linker/element');\nvar view = require('./src/linker/view');\nvar view_type = require('./src/linker/view_type');\nvar view_utils = require('./src/linker/view_utils');\nvar metadata_view = require('./src/metadata/view');\nvar debug_context = require('./src/linker/debug_context');\nvar change_detection_util = require('./src/change_detection/change_detection_util');\nvar api = require('./src/render/api');\nvar template_ref = require('./src/linker/template_ref');\nvar wtf_init = require('./src/profile/wtf_init');\nvar reflection_capabilities = require('./src/reflection/reflection_capabilities');\nvar decorators = require('./src/util/decorators');\nvar debug = require('./src/debug/debug_renderer');\nvar provider_util = require('./src/di/provider_util');\nvar console = require('./src/console');\nexports.__core_private__ = {\n isDefaultChangeDetectionStrategy: constants.isDefaultChangeDetectionStrategy,\n ChangeDetectorState: constants.ChangeDetectorState,\n CHANGE_DETECTION_STRATEGY_VALUES: constants.CHANGE_DETECTION_STRATEGY_VALUES,\n constructDependencies: reflective_provider.constructDependencies,\n LifecycleHooks: lifecycle_hooks.LifecycleHooks,\n LIFECYCLE_HOOKS_VALUES: lifecycle_hooks.LIFECYCLE_HOOKS_VALUES,\n ReflectorReader: reflector_reader.ReflectorReader,\n ReflectorComponentResolver: component_resolver.ReflectorComponentResolver,\n AppElement: element.AppElement,\n AppView: view.AppView,\n DebugAppView: view.DebugAppView,\n ViewType: view_type.ViewType,\n MAX_INTERPOLATION_VALUES: view_utils.MAX_INTERPOLATION_VALUES,\n checkBinding: view_utils.checkBinding,\n flattenNestedViewRenderNodes: view_utils.flattenNestedViewRenderNodes,\n interpolate: view_utils.interpolate,\n ViewUtils: view_utils.ViewUtils,\n VIEW_ENCAPSULATION_VALUES: metadata_view.VIEW_ENCAPSULATION_VALUES,\n DebugContext: debug_context.DebugContext,\n StaticNodeDebugInfo: debug_context.StaticNodeDebugInfo,\n devModeEqual: change_detection_util.devModeEqual,\n uninitialized: change_detection_util.uninitialized,\n ValueUnwrapper: change_detection_util.ValueUnwrapper,\n RenderDebugInfo: api.RenderDebugInfo,\n SecurityContext: security.SecurityContext,\n SanitizationService: security.SanitizationService,\n TemplateRef_: template_ref.TemplateRef_,\n wtfInit: wtf_init.wtfInit,\n ReflectionCapabilities: reflection_capabilities.ReflectionCapabilities,\n makeDecorator: decorators.makeDecorator,\n DebugDomRootRenderer: debug.DebugDomRootRenderer,\n createProvider: provider_util.createProvider,\n isProviderLiteral: provider_util.isProviderLiteral,\n EMPTY_ARRAY: view_utils.EMPTY_ARRAY,\n EMPTY_MAP: view_utils.EMPTY_MAP,\n pureProxy1: view_utils.pureProxy1,\n pureProxy2: view_utils.pureProxy2,\n pureProxy3: view_utils.pureProxy3,\n pureProxy4: view_utils.pureProxy4,\n pureProxy5: view_utils.pureProxy5,\n pureProxy6: view_utils.pureProxy6,\n pureProxy7: view_utils.pureProxy7,\n pureProxy8: view_utils.pureProxy8,\n pureProxy9: view_utils.pureProxy9,\n pureProxy10: view_utils.pureProxy10,\n castByValue: view_utils.castByValue,\n Console: console.Console,\n};\n//# sourceMappingURL=private_export.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/private_export.js\n ** module id = 380\n ** module chunks = 0\n **/","\"use strict\";\nvar application_tokens_1 = require('./application_tokens');\nvar application_ref_1 = require('./application_ref');\nvar change_detection_1 = require('./change_detection/change_detection');\nvar view_utils_1 = require('./linker/view_utils');\nvar component_resolver_1 = require('./linker/component_resolver');\nvar dynamic_component_loader_1 = require('./linker/dynamic_component_loader');\nvar __unused; // avoid unused import when Type union types are erased\n/**\n * A default set of providers which should be included in any Angular\n * application, regardless of the platform it runs onto.\n */\nexports.APPLICATION_COMMON_PROVIDERS = \n/*@ts2dart_const*/ [\n application_ref_1.APPLICATION_CORE_PROVIDERS,\n /* @ts2dart_Provider */ { provide: component_resolver_1.ComponentResolver, useClass: component_resolver_1.ReflectorComponentResolver },\n application_tokens_1.APP_ID_RANDOM_PROVIDER,\n view_utils_1.ViewUtils,\n /* @ts2dart_Provider */ { provide: change_detection_1.IterableDiffers, useValue: change_detection_1.defaultIterableDiffers },\n /* @ts2dart_Provider */ { provide: change_detection_1.KeyValueDiffers, useValue: change_detection_1.defaultKeyValueDiffers },\n /* @ts2dart_Provider */ { provide: dynamic_component_loader_1.DynamicComponentLoader, useClass: dynamic_component_loader_1.DynamicComponentLoader_ }\n];\n//# sourceMappingURL=application_common_providers.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/application_common_providers.js\n ** module id = 381\n ** module chunks = 0\n **/","\"use strict\";\n/**\n* @module\n* @description\n* Change detection enables data binding in Angular.\n*/\nvar change_detection_1 = require('./change_detection/change_detection');\nexports.ChangeDetectionStrategy = change_detection_1.ChangeDetectionStrategy;\nexports.ChangeDetectorRef = change_detection_1.ChangeDetectorRef;\nexports.WrappedValue = change_detection_1.WrappedValue;\nexports.SimpleChange = change_detection_1.SimpleChange;\nexports.DefaultIterableDiffer = change_detection_1.DefaultIterableDiffer;\nexports.IterableDiffers = change_detection_1.IterableDiffers;\nexports.KeyValueDiffers = change_detection_1.KeyValueDiffers;\nexports.CollectionChangeRecord = change_detection_1.CollectionChangeRecord;\nexports.KeyValueChangeRecord = change_detection_1.KeyValueChangeRecord;\n//# sourceMappingURL=change_detection.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/change_detection.js\n ** module id = 382\n ** module chunks = 0\n **/","\"use strict\";\nvar ChangeDetectorRef = (function () {\n function ChangeDetectorRef() {\n }\n return ChangeDetectorRef;\n}());\nexports.ChangeDetectorRef = ChangeDetectorRef;\n//# sourceMappingURL=change_detector_ref.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/change_detection/change_detector_ref.js\n ** module id = 383\n ** module chunks = 0\n **/","\"use strict\";\nvar lang_1 = require('../../src/facade/lang');\nvar debug_node_1 = require('./debug_node');\nvar DebugDomRootRenderer = (function () {\n function DebugDomRootRenderer(_delegate) {\n this._delegate = _delegate;\n }\n DebugDomRootRenderer.prototype.renderComponent = function (componentProto) {\n return new DebugDomRenderer(this._delegate.renderComponent(componentProto));\n };\n return DebugDomRootRenderer;\n}());\nexports.DebugDomRootRenderer = DebugDomRootRenderer;\nvar DebugDomRenderer = (function () {\n function DebugDomRenderer(_delegate) {\n this._delegate = _delegate;\n }\n DebugDomRenderer.prototype.selectRootElement = function (selectorOrNode, debugInfo) {\n var nativeEl = this._delegate.selectRootElement(selectorOrNode, debugInfo);\n var debugEl = new debug_node_1.DebugElement(nativeEl, null, debugInfo);\n debug_node_1.indexDebugNode(debugEl);\n return nativeEl;\n };\n DebugDomRenderer.prototype.createElement = function (parentElement, name, debugInfo) {\n var nativeEl = this._delegate.createElement(parentElement, name, debugInfo);\n var debugEl = new debug_node_1.DebugElement(nativeEl, debug_node_1.getDebugNode(parentElement), debugInfo);\n debugEl.name = name;\n debug_node_1.indexDebugNode(debugEl);\n return nativeEl;\n };\n DebugDomRenderer.prototype.createViewRoot = function (hostElement) { return this._delegate.createViewRoot(hostElement); };\n DebugDomRenderer.prototype.createTemplateAnchor = function (parentElement, debugInfo) {\n var comment = this._delegate.createTemplateAnchor(parentElement, debugInfo);\n var debugEl = new debug_node_1.DebugNode(comment, debug_node_1.getDebugNode(parentElement), debugInfo);\n debug_node_1.indexDebugNode(debugEl);\n return comment;\n };\n DebugDomRenderer.prototype.createText = function (parentElement, value, debugInfo) {\n var text = this._delegate.createText(parentElement, value, debugInfo);\n var debugEl = new debug_node_1.DebugNode(text, debug_node_1.getDebugNode(parentElement), debugInfo);\n debug_node_1.indexDebugNode(debugEl);\n return text;\n };\n DebugDomRenderer.prototype.projectNodes = function (parentElement, nodes) {\n var debugParent = debug_node_1.getDebugNode(parentElement);\n if (lang_1.isPresent(debugParent) && debugParent instanceof debug_node_1.DebugElement) {\n var debugElement_1 = debugParent;\n nodes.forEach(function (node) { debugElement_1.addChild(debug_node_1.getDebugNode(node)); });\n }\n this._delegate.projectNodes(parentElement, nodes);\n };\n DebugDomRenderer.prototype.attachViewAfter = function (node, viewRootNodes) {\n var debugNode = debug_node_1.getDebugNode(node);\n if (lang_1.isPresent(debugNode)) {\n var debugParent = debugNode.parent;\n if (viewRootNodes.length > 0 && lang_1.isPresent(debugParent)) {\n var debugViewRootNodes = [];\n viewRootNodes.forEach(function (rootNode) { return debugViewRootNodes.push(debug_node_1.getDebugNode(rootNode)); });\n debugParent.insertChildrenAfter(debugNode, debugViewRootNodes);\n }\n }\n this._delegate.attachViewAfter(node, viewRootNodes);\n };\n DebugDomRenderer.prototype.detachView = function (viewRootNodes) {\n viewRootNodes.forEach(function (node) {\n var debugNode = debug_node_1.getDebugNode(node);\n if (lang_1.isPresent(debugNode) && lang_1.isPresent(debugNode.parent)) {\n debugNode.parent.removeChild(debugNode);\n }\n });\n this._delegate.detachView(viewRootNodes);\n };\n DebugDomRenderer.prototype.destroyView = function (hostElement, viewAllNodes) {\n viewAllNodes.forEach(function (node) { debug_node_1.removeDebugNodeFromIndex(debug_node_1.getDebugNode(node)); });\n this._delegate.destroyView(hostElement, viewAllNodes);\n };\n DebugDomRenderer.prototype.listen = function (renderElement, name, callback) {\n var debugEl = debug_node_1.getDebugNode(renderElement);\n if (lang_1.isPresent(debugEl)) {\n debugEl.listeners.push(new debug_node_1.EventListener(name, callback));\n }\n return this._delegate.listen(renderElement, name, callback);\n };\n DebugDomRenderer.prototype.listenGlobal = function (target, name, callback) {\n return this._delegate.listenGlobal(target, name, callback);\n };\n DebugDomRenderer.prototype.setElementProperty = function (renderElement, propertyName, propertyValue) {\n var debugEl = debug_node_1.getDebugNode(renderElement);\n if (lang_1.isPresent(debugEl) && debugEl instanceof debug_node_1.DebugElement) {\n debugEl.properties[propertyName] = propertyValue;\n }\n this._delegate.setElementProperty(renderElement, propertyName, propertyValue);\n };\n DebugDomRenderer.prototype.setElementAttribute = function (renderElement, attributeName, attributeValue) {\n var debugEl = debug_node_1.getDebugNode(renderElement);\n if (lang_1.isPresent(debugEl) && debugEl instanceof debug_node_1.DebugElement) {\n debugEl.attributes[attributeName] = attributeValue;\n }\n this._delegate.setElementAttribute(renderElement, attributeName, attributeValue);\n };\n DebugDomRenderer.prototype.setBindingDebugInfo = function (renderElement, propertyName, propertyValue) {\n this._delegate.setBindingDebugInfo(renderElement, propertyName, propertyValue);\n };\n DebugDomRenderer.prototype.setElementClass = function (renderElement, className, isAdd) {\n this._delegate.setElementClass(renderElement, className, isAdd);\n };\n DebugDomRenderer.prototype.setElementStyle = function (renderElement, styleName, styleValue) {\n this._delegate.setElementStyle(renderElement, styleName, styleValue);\n };\n DebugDomRenderer.prototype.invokeElementMethod = function (renderElement, methodName, args) {\n this._delegate.invokeElementMethod(renderElement, methodName, args);\n };\n DebugDomRenderer.prototype.setText = function (renderNode, text) { this._delegate.setText(renderNode, text); };\n return DebugDomRenderer;\n}());\nexports.DebugDomRenderer = DebugDomRenderer;\n//# sourceMappingURL=debug_renderer.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/debug/debug_renderer.js\n ** module id = 384\n ** module chunks = 0\n **/","\"use strict\";\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* @ts2dart_const\n*/\nvar OpaqueToken = (function () {\n function OpaqueToken(_desc) {\n this._desc = _desc;\n }\n OpaqueToken.prototype.toString = function () { return \"Token \" + this._desc; };\n return OpaqueToken;\n}());\nexports.OpaqueToken = OpaqueToken;\n//# sourceMappingURL=opaque_token.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/di/opaque_token.js\n ** module id = 385\n ** module chunks = 0\n **/","\"use strict\";\n// Public API for compiler\nvar component_resolver_1 = require('./linker/component_resolver');\nexports.ComponentResolver = component_resolver_1.ComponentResolver;\nvar query_list_1 = require('./linker/query_list');\nexports.QueryList = query_list_1.QueryList;\nvar dynamic_component_loader_1 = require('./linker/dynamic_component_loader');\nexports.DynamicComponentLoader = dynamic_component_loader_1.DynamicComponentLoader;\nvar element_ref_1 = require('./linker/element_ref');\nexports.ElementRef = element_ref_1.ElementRef;\nvar template_ref_1 = require('./linker/template_ref');\nexports.TemplateRef = template_ref_1.TemplateRef;\nvar view_ref_1 = require('./linker/view_ref');\nexports.EmbeddedViewRef = view_ref_1.EmbeddedViewRef;\nexports.ViewRef = view_ref_1.ViewRef;\nvar view_container_ref_1 = require('./linker/view_container_ref');\nexports.ViewContainerRef = view_container_ref_1.ViewContainerRef;\nvar component_factory_1 = require('./linker/component_factory');\nexports.ComponentRef = component_factory_1.ComponentRef;\nexports.ComponentFactory = component_factory_1.ComponentFactory;\nvar exceptions_1 = require('./linker/exceptions');\nexports.ExpressionChangedAfterItHasBeenCheckedException = exceptions_1.ExpressionChangedAfterItHasBeenCheckedException;\n//# sourceMappingURL=linker.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/linker.js\n ** module id = 387\n ** module chunks = 0\n **/","\"use strict\";\nvar __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};\nvar injector_1 = require('../di/injector');\nvar _UNDEFINED = new Object();\nvar ElementInjector = (function (_super) {\n __extends(ElementInjector, _super);\n function ElementInjector(_view, _nodeIndex) {\n _super.call(this);\n this._view = _view;\n this._nodeIndex = _nodeIndex;\n }\n ElementInjector.prototype.get = function (token, notFoundValue) {\n if (notFoundValue === void 0) { notFoundValue = injector_1.THROW_IF_NOT_FOUND; }\n var result = _UNDEFINED;\n if (result === _UNDEFINED) {\n result = this._view.injectorGet(token, this._nodeIndex, _UNDEFINED);\n }\n if (result === _UNDEFINED) {\n result = this._view.parentInjector.get(token, notFoundValue);\n }\n return result;\n };\n return ElementInjector;\n}(injector_1.Injector));\nexports.ElementInjector = ElementInjector;\n//# sourceMappingURL=element_injector.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/linker/element_injector.js\n ** module id = 388\n ** module chunks = 0\n **/","\"use strict\";\nvar collection_1 = require('../../src/facade/collection');\nvar lang_1 = require('../../src/facade/lang');\nvar async_1 = require('../../src/facade/async');\n/**\n * An unmodifiable list of items that Angular keeps up to date when the state\n * of the application changes.\n *\n * The type of object that {@link QueryMetadata} and {@link ViewQueryMetadata} provide.\n *\n * Implements an iterable interface, therefore it can be used in both ES6\n * javascript `for (var i of items)` loops as well as in Angular templates with\n * `*ngFor=\"let i of myList\"`.\n *\n * Changes can be observed by subscribing to the changes `Observable`.\n *\n * NOTE: In the future this class will implement an `Observable` interface.\n *\n * ### Example ([live demo](http://plnkr.co/edit/RX8sJnQYl9FWuSCWme5z?p=preview))\n * ```typescript\n * @Component({...})\n * class Container {\n * constructor(@Query(Item) items: QueryList- ) {\n * items.changes.subscribe(_ => console.log(items.length));\n * }\n * }\n * ```\n */\nvar QueryList = (function () {\n function QueryList() {\n this._dirty = true;\n this._results = [];\n this._emitter = new async_1.EventEmitter();\n }\n Object.defineProperty(QueryList.prototype, \"changes\", {\n get: function () { return this._emitter; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(QueryList.prototype, \"length\", {\n get: function () { return this._results.length; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(QueryList.prototype, \"first\", {\n get: function () { return collection_1.ListWrapper.first(this._results); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(QueryList.prototype, \"last\", {\n get: function () { return collection_1.ListWrapper.last(this._results); },\n enumerable: true,\n configurable: true\n });\n /**\n * returns a new array with the passed in function applied to each element.\n */\n QueryList.prototype.map = function (fn) { return this._results.map(fn); };\n /**\n * returns a filtered array.\n */\n QueryList.prototype.filter = function (fn) { return this._results.filter(fn); };\n /**\n * returns a reduced value.\n */\n QueryList.prototype.reduce = function (fn, init) { return this._results.reduce(fn, init); };\n /**\n * executes function for each element in a query.\n */\n QueryList.prototype.forEach = function (fn) { this._results.forEach(fn); };\n /**\n * converts QueryList into an array\n */\n QueryList.prototype.toArray = function () { return collection_1.ListWrapper.clone(this._results); };\n QueryList.prototype[lang_1.getSymbolIterator()] = function () { return this._results[lang_1.getSymbolIterator()](); };\n QueryList.prototype.toString = function () { return this._results.toString(); };\n /**\n * @internal\n */\n QueryList.prototype.reset = function (res) {\n this._results = collection_1.ListWrapper.flatten(res);\n this._dirty = false;\n };\n /** @internal */\n QueryList.prototype.notifyOnChanges = function () { this._emitter.emit(this); };\n /** internal */\n QueryList.prototype.setDirty = function () { this._dirty = true; };\n Object.defineProperty(QueryList.prototype, \"dirty\", {\n /** internal */\n get: function () { return this._dirty; },\n enumerable: true,\n configurable: true\n });\n return QueryList;\n}());\nexports.QueryList = QueryList;\n//# sourceMappingURL=query_list.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/linker/query_list.js\n ** module id = 389\n ** module chunks = 0\n **/","\"use strict\";\nvar __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};\nvar collection_1 = require('../../src/facade/collection');\nvar element_1 = require('./element');\nvar lang_1 = require('../../src/facade/lang');\nvar async_1 = require('../../src/facade/async');\nvar view_ref_1 = require('./view_ref');\nvar view_type_1 = require('./view_type');\nvar view_utils_1 = require('./view_utils');\nvar change_detection_1 = require('../change_detection/change_detection');\nvar profile_1 = require('../profile/profile');\nvar exceptions_1 = require('./exceptions');\nvar debug_context_1 = require('./debug_context');\nvar element_injector_1 = require('./element_injector');\nvar _scope_check = profile_1.wtfCreateScope(\"AppView#check(ascii id)\");\n/**\n * Cost of making objects: http://jsperf.com/instantiate-size-of-object\n *\n */\nvar AppView = (function () {\n function AppView(clazz, componentType, type, viewUtils, parentInjector, declarationAppElement, cdMode) {\n this.clazz = clazz;\n this.componentType = componentType;\n this.type = type;\n this.viewUtils = viewUtils;\n this.parentInjector = parentInjector;\n this.declarationAppElement = declarationAppElement;\n this.cdMode = cdMode;\n this.contentChildren = [];\n this.viewChildren = [];\n this.viewContainerElement = null;\n // The names of the below fields must be kept in sync with codegen_name_util.ts or\n // change detection will fail.\n this.cdState = change_detection_1.ChangeDetectorState.NeverChecked;\n this.destroyed = false;\n this.ref = new view_ref_1.ViewRef_(this);\n if (type === view_type_1.ViewType.COMPONENT || type === view_type_1.ViewType.HOST) {\n this.renderer = viewUtils.renderComponent(componentType);\n }\n else {\n this.renderer = declarationAppElement.parentView.renderer;\n }\n }\n AppView.prototype.create = function (context, givenProjectableNodes, rootSelectorOrNode) {\n this.context = context;\n var projectableNodes;\n switch (this.type) {\n case view_type_1.ViewType.COMPONENT:\n projectableNodes = view_utils_1.ensureSlotCount(givenProjectableNodes, this.componentType.slotCount);\n break;\n case view_type_1.ViewType.EMBEDDED:\n projectableNodes = this.declarationAppElement.parentView.projectableNodes;\n break;\n case view_type_1.ViewType.HOST:\n // Note: Don't ensure the slot count for the projectableNodes as we store\n // them only for the contained component view (which will later check the slot count...)\n projectableNodes = givenProjectableNodes;\n break;\n }\n this._hasExternalHostElement = lang_1.isPresent(rootSelectorOrNode);\n this.projectableNodes = projectableNodes;\n return this.createInternal(rootSelectorOrNode);\n };\n /**\n * Overwritten by implementations.\n * Returns the AppElement for the host element for ViewType.HOST.\n */\n AppView.prototype.createInternal = function (rootSelectorOrNode) { return null; };\n AppView.prototype.init = function (rootNodesOrAppElements, allNodes, disposables, subscriptions) {\n this.rootNodesOrAppElements = rootNodesOrAppElements;\n this.allNodes = allNodes;\n this.disposables = disposables;\n this.subscriptions = subscriptions;\n if (this.type === view_type_1.ViewType.COMPONENT) {\n // Note: the render nodes have been attached to their host element\n // in the ViewFactory already.\n this.declarationAppElement.parentView.viewChildren.push(this);\n this.dirtyParentQueriesInternal();\n }\n };\n AppView.prototype.selectOrCreateHostElement = function (elementName, rootSelectorOrNode, debugInfo) {\n var hostElement;\n if (lang_1.isPresent(rootSelectorOrNode)) {\n hostElement = this.renderer.selectRootElement(rootSelectorOrNode, debugInfo);\n }\n else {\n hostElement = this.renderer.createElement(null, elementName, debugInfo);\n }\n return hostElement;\n };\n AppView.prototype.injectorGet = function (token, nodeIndex, notFoundResult) {\n return this.injectorGetInternal(token, nodeIndex, notFoundResult);\n };\n /**\n * Overwritten by implementations\n */\n AppView.prototype.injectorGetInternal = function (token, nodeIndex, notFoundResult) {\n return notFoundResult;\n };\n AppView.prototype.injector = function (nodeIndex) {\n if (lang_1.isPresent(nodeIndex)) {\n return new element_injector_1.ElementInjector(this, nodeIndex);\n }\n else {\n return this.parentInjector;\n }\n };\n AppView.prototype.destroy = function () {\n if (this._hasExternalHostElement) {\n this.renderer.detachView(this.flatRootNodes);\n }\n else if (lang_1.isPresent(this.viewContainerElement)) {\n this.viewContainerElement.detachView(this.viewContainerElement.nestedViews.indexOf(this));\n }\n this._destroyRecurse();\n };\n AppView.prototype._destroyRecurse = function () {\n if (this.destroyed) {\n return;\n }\n var children = this.contentChildren;\n for (var i = 0; i < children.length; i++) {\n children[i]._destroyRecurse();\n }\n children = this.viewChildren;\n for (var i = 0; i < children.length; i++) {\n children[i]._destroyRecurse();\n }\n this.destroyLocal();\n this.destroyed = true;\n };\n AppView.prototype.destroyLocal = function () {\n var hostElement = this.type === view_type_1.ViewType.COMPONENT ? this.declarationAppElement.nativeElement : null;\n for (var i = 0; i < this.disposables.length; i++) {\n this.disposables[i]();\n }\n for (var i = 0; i < this.subscriptions.length; i++) {\n async_1.ObservableWrapper.dispose(this.subscriptions[i]);\n }\n this.destroyInternal();\n if (this._hasExternalHostElement) {\n this.renderer.detachView(this.flatRootNodes);\n }\n else if (lang_1.isPresent(this.viewContainerElement)) {\n this.viewContainerElement.detachView(this.viewContainerElement.nestedViews.indexOf(this));\n }\n else {\n this.dirtyParentQueriesInternal();\n }\n this.renderer.destroyView(hostElement, this.allNodes);\n };\n /**\n * Overwritten by implementations\n */\n AppView.prototype.destroyInternal = function () { };\n Object.defineProperty(AppView.prototype, \"changeDetectorRef\", {\n get: function () { return this.ref; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(AppView.prototype, \"parent\", {\n get: function () {\n return lang_1.isPresent(this.declarationAppElement) ? this.declarationAppElement.parentView : null;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(AppView.prototype, \"flatRootNodes\", {\n get: function () { return view_utils_1.flattenNestedViewRenderNodes(this.rootNodesOrAppElements); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(AppView.prototype, \"lastRootNode\", {\n get: function () {\n var lastNode = this.rootNodesOrAppElements.length > 0 ?\n this.rootNodesOrAppElements[this.rootNodesOrAppElements.length - 1] :\n null;\n return _findLastRenderNode(lastNode);\n },\n enumerable: true,\n configurable: true\n });\n /**\n * Overwritten by implementations\n */\n AppView.prototype.dirtyParentQueriesInternal = function () { };\n AppView.prototype.detectChanges = function (throwOnChange) {\n var s = _scope_check(this.clazz);\n if (this.cdMode === change_detection_1.ChangeDetectionStrategy.Detached ||\n this.cdMode === change_detection_1.ChangeDetectionStrategy.Checked ||\n this.cdState === change_detection_1.ChangeDetectorState.Errored)\n return;\n if (this.destroyed) {\n this.throwDestroyedError('detectChanges');\n }\n this.detectChangesInternal(throwOnChange);\n if (this.cdMode === change_detection_1.ChangeDetectionStrategy.CheckOnce)\n this.cdMode = change_detection_1.ChangeDetectionStrategy.Checked;\n this.cdState = change_detection_1.ChangeDetectorState.CheckedBefore;\n profile_1.wtfLeave(s);\n };\n /**\n * Overwritten by implementations\n */\n AppView.prototype.detectChangesInternal = function (throwOnChange) {\n this.detectContentChildrenChanges(throwOnChange);\n this.detectViewChildrenChanges(throwOnChange);\n };\n AppView.prototype.detectContentChildrenChanges = function (throwOnChange) {\n for (var i = 0; i < this.contentChildren.length; ++i) {\n this.contentChildren[i].detectChanges(throwOnChange);\n }\n };\n AppView.prototype.detectViewChildrenChanges = function (throwOnChange) {\n for (var i = 0; i < this.viewChildren.length; ++i) {\n this.viewChildren[i].detectChanges(throwOnChange);\n }\n };\n AppView.prototype.addToContentChildren = function (renderAppElement) {\n renderAppElement.parentView.contentChildren.push(this);\n this.viewContainerElement = renderAppElement;\n this.dirtyParentQueriesInternal();\n };\n AppView.prototype.removeFromContentChildren = function (renderAppElement) {\n collection_1.ListWrapper.remove(renderAppElement.parentView.contentChildren, this);\n this.dirtyParentQueriesInternal();\n this.viewContainerElement = null;\n };\n AppView.prototype.markAsCheckOnce = function () { this.cdMode = change_detection_1.ChangeDetectionStrategy.CheckOnce; };\n AppView.prototype.markPathToRootAsCheckOnce = function () {\n var c = this;\n while (lang_1.isPresent(c) && c.cdMode !== change_detection_1.ChangeDetectionStrategy.Detached) {\n if (c.cdMode === change_detection_1.ChangeDetectionStrategy.Checked) {\n c.cdMode = change_detection_1.ChangeDetectionStrategy.CheckOnce;\n }\n var parentEl = c.type === view_type_1.ViewType.COMPONENT ? c.declarationAppElement : c.viewContainerElement;\n c = lang_1.isPresent(parentEl) ? parentEl.parentView : null;\n }\n };\n AppView.prototype.eventHandler = function (cb) { return cb; };\n AppView.prototype.throwDestroyedError = function (details) { throw new exceptions_1.ViewDestroyedException(details); };\n return AppView;\n}());\nexports.AppView = AppView;\nvar DebugAppView = (function (_super) {\n __extends(DebugAppView, _super);\n function DebugAppView(clazz, componentType, type, viewUtils, parentInjector, declarationAppElement, cdMode, staticNodeDebugInfos) {\n _super.call(this, clazz, componentType, type, viewUtils, parentInjector, declarationAppElement, cdMode);\n this.staticNodeDebugInfos = staticNodeDebugInfos;\n this._currentDebugContext = null;\n }\n DebugAppView.prototype.create = function (context, givenProjectableNodes, rootSelectorOrNode) {\n this._resetDebug();\n try {\n return _super.prototype.create.call(this, context, givenProjectableNodes, rootSelectorOrNode);\n }\n catch (e) {\n this._rethrowWithContext(e, e.stack);\n throw e;\n }\n };\n DebugAppView.prototype.injectorGet = function (token, nodeIndex, notFoundResult) {\n this._resetDebug();\n try {\n return _super.prototype.injectorGet.call(this, token, nodeIndex, notFoundResult);\n }\n catch (e) {\n this._rethrowWithContext(e, e.stack);\n throw e;\n }\n };\n DebugAppView.prototype.destroyLocal = function () {\n this._resetDebug();\n try {\n _super.prototype.destroyLocal.call(this);\n }\n catch (e) {\n this._rethrowWithContext(e, e.stack);\n throw e;\n }\n };\n DebugAppView.prototype.detectChanges = function (throwOnChange) {\n this._resetDebug();\n try {\n _super.prototype.detectChanges.call(this, throwOnChange);\n }\n catch (e) {\n this._rethrowWithContext(e, e.stack);\n throw e;\n }\n };\n DebugAppView.prototype._resetDebug = function () { this._currentDebugContext = null; };\n DebugAppView.prototype.debug = function (nodeIndex, rowNum, colNum) {\n return this._currentDebugContext = new debug_context_1.DebugContext(this, nodeIndex, rowNum, colNum);\n };\n DebugAppView.prototype._rethrowWithContext = function (e, stack) {\n if (!(e instanceof exceptions_1.ViewWrappedException)) {\n if (!(e instanceof exceptions_1.ExpressionChangedAfterItHasBeenCheckedException)) {\n this.cdState = change_detection_1.ChangeDetectorState.Errored;\n }\n if (lang_1.isPresent(this._currentDebugContext)) {\n throw new exceptions_1.ViewWrappedException(e, stack, this._currentDebugContext);\n }\n }\n };\n DebugAppView.prototype.eventHandler = function (cb) {\n var _this = this;\n var superHandler = _super.prototype.eventHandler.call(this, cb);\n return function (event) {\n _this._resetDebug();\n try {\n return superHandler(event);\n }\n catch (e) {\n _this._rethrowWithContext(e, e.stack);\n throw e;\n }\n };\n };\n return DebugAppView;\n}(AppView));\nexports.DebugAppView = DebugAppView;\nfunction _findLastRenderNode(node) {\n var lastNode;\n if (node instanceof element_1.AppElement) {\n var appEl = node;\n lastNode = appEl.nativeElement;\n if (lang_1.isPresent(appEl.nestedViews)) {\n // Note: Views might have no root nodes at all!\n for (var i = appEl.nestedViews.length - 1; i >= 0; i--) {\n var nestedView = appEl.nestedViews[i];\n if (nestedView.rootNodesOrAppElements.length > 0) {\n lastNode = _findLastRenderNode(nestedView.rootNodesOrAppElements[nestedView.rootNodesOrAppElements.length - 1]);\n }\n }\n }\n }\n else {\n lastNode = node;\n }\n return lastNode;\n}\n//# sourceMappingURL=view.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/linker/view.js\n ** module id = 390\n ** module chunks = 0\n **/","\"use strict\";\n/**\n* This indirection is needed to free up Component, etc symbols in the public API\n* to be used by the decorator versions of these annotations.\n*/\nvar di_1 = require('./metadata/di');\nexports.QueryMetadata = di_1.QueryMetadata;\nexports.ContentChildrenMetadata = di_1.ContentChildrenMetadata;\nexports.ContentChildMetadata = di_1.ContentChildMetadata;\nexports.ViewChildrenMetadata = di_1.ViewChildrenMetadata;\nexports.ViewQueryMetadata = di_1.ViewQueryMetadata;\nexports.ViewChildMetadata = di_1.ViewChildMetadata;\nexports.AttributeMetadata = di_1.AttributeMetadata;\nvar directives_1 = require('./metadata/directives');\nexports.ComponentMetadata = directives_1.ComponentMetadata;\nexports.DirectiveMetadata = directives_1.DirectiveMetadata;\nexports.PipeMetadata = directives_1.PipeMetadata;\nexports.InputMetadata = directives_1.InputMetadata;\nexports.OutputMetadata = directives_1.OutputMetadata;\nexports.HostBindingMetadata = directives_1.HostBindingMetadata;\nexports.HostListenerMetadata = directives_1.HostListenerMetadata;\nvar view_1 = require('./metadata/view');\nexports.ViewMetadata = view_1.ViewMetadata;\nexports.ViewEncapsulation = view_1.ViewEncapsulation;\nvar di_2 = require('./metadata/di');\nvar directives_2 = require('./metadata/directives');\nvar view_2 = require('./metadata/view');\nvar decorators_1 = require('./util/decorators');\n// TODO(alexeagle): remove the duplication of this doc. It is copied from ComponentMetadata.\n/**\n * Declare reusable UI building blocks for an application.\n *\n * Each Angular component requires a single `@Component` annotation. The `@Component`\n * annotation specifies when a component is instantiated, and which properties and hostListeners it\n * binds to.\n *\n * When a component is instantiated, Angular\n * - creates a shadow DOM for the component.\n * - loads the selected template into the shadow DOM.\n * - creates all the injectable objects configured with `providers` and `viewProviders`.\n *\n * All template expressions and statements are then evaluated against the component instance.\n *\n * ## Lifecycle hooks\n *\n * When the component class implements some {@link ../../guide/lifecycle-hooks.html} the callbacks\n * are called by the change detection at defined points in time during the life of the component.\n *\n * ### Example\n *\n * {@example core/ts/metadata/metadata.ts region='component'}\n */\nexports.Component = decorators_1.makeDecorator(directives_2.ComponentMetadata, function (fn) { return fn.View = View; });\n// TODO(alexeagle): remove the duplication of this doc. It is copied from DirectiveMetadata.\n/**\n * Directives allow you to attach behavior to elements in the DOM.\n *\n * {@link DirectiveMetadata}s with an embedded view are called {@link ComponentMetadata}s.\n *\n * A directive consists of a single directive annotation and a controller class. When the\n * directive's `selector` matches\n * elements in the DOM, the following steps occur:\n *\n * 1. For each directive, the `ElementInjector` attempts to resolve the directive's constructor\n * arguments.\n * 2. Angular instantiates directives for each matched element using `ElementInjector` in a\n * depth-first order,\n * as declared in the HTML.\n *\n * ## Understanding How Injection Works\n *\n * There are three stages of injection resolution.\n * - *Pre-existing Injectors*:\n * - The terminal {@link Injector} cannot resolve dependencies. It either throws an error or, if\n * the dependency was\n * specified as `@Optional`, returns `null`.\n * - The platform injector resolves browser singleton resources, such as: cookies, title,\n * location, and others.\n * - *Component Injectors*: Each component instance has its own {@link Injector}, and they follow\n * the same parent-child hierarchy\n * as the component instances in the DOM.\n * - *Element Injectors*: Each component instance has a Shadow DOM. Within the Shadow DOM each\n * element has an `ElementInjector`\n * which follow the same parent-child hierarchy as the DOM elements themselves.\n *\n * When a template is instantiated, it also must instantiate the corresponding directives in a\n * depth-first order. The\n * current `ElementInjector` resolves the constructor dependencies for each directive.\n *\n * Angular then resolves dependencies as follows, according to the order in which they appear in the\n * {@link ViewMetadata}:\n *\n * 1. Dependencies on the current element\n * 2. Dependencies on element injectors and their parents until it encounters a Shadow DOM boundary\n * 3. Dependencies on component injectors and their parents until it encounters the root component\n * 4. Dependencies on pre-existing injectors\n *\n *\n * The `ElementInjector` can inject other directives, element-specific special objects, or it can\n * delegate to the parent\n * injector.\n *\n * To inject other directives, declare the constructor parameter as:\n * - `directive:DirectiveType`: a directive on the current element only\n * - `@Host() directive:DirectiveType`: any directive that matches the type between the current\n * element and the\n * Shadow DOM root.\n * - `@Query(DirectiveType) query:QueryList`: A live collection of direct child\n * directives.\n * - `@QueryDescendants(DirectiveType) query:QueryList`: A live collection of any\n * child directives.\n *\n * To inject element-specific special objects, declare the constructor parameter as:\n * - `element: ElementRef` to obtain a reference to logical element in the view.\n * - `viewContainer: ViewContainerRef` to control child template instantiation, for\n * {@link DirectiveMetadata} directives only\n * - `bindingPropagation: BindingPropagation` to control change detection in a more granular way.\n *\n * ### Example\n *\n * The following example demonstrates how dependency injection resolves constructor arguments in\n * practice.\n *\n *\n * Assume this HTML template:\n *\n * ```\n * \n * ```\n *\n * With the following `dependency` decorator and `SomeService` injectable class.\n *\n * ```\n * @Injectable()\n * class SomeService {\n * }\n *\n * @Directive({\n * selector: '[dependency]',\n * inputs: [\n * 'id: dependency'\n * ]\n * })\n * class Dependency {\n * id:string;\n * }\n * ```\n *\n * Let's step through the different ways in which `MyDirective` could be declared...\n *\n *\n * ### No injection\n *\n * Here the constructor is declared with no arguments, therefore nothing is injected into\n * `MyDirective`.\n *\n * ```\n * @Directive({ selector: '[my-directive]' })\n * class MyDirective {\n * constructor() {\n * }\n * }\n * ```\n *\n * This directive would be instantiated with no dependencies.\n *\n *\n * ### Component-level injection\n *\n * Directives can inject any injectable instance from the closest component injector or any of its\n * parents.\n *\n * Here, the constructor declares a parameter, `someService`, and injects the `SomeService` type\n * from the parent\n * component's injector.\n * ```\n * @Directive({ selector: '[my-directive]' })\n * class MyDirective {\n * constructor(someService: SomeService) {\n * }\n * }\n * ```\n *\n * This directive would be instantiated with a dependency on `SomeService`.\n *\n *\n * ### Injecting a directive from the current element\n *\n * Directives can inject other directives declared on the current element.\n *\n * ```\n * @Directive({ selector: '[my-directive]' })\n * class MyDirective {\n * constructor(dependency: Dependency) {\n * expect(dependency.id).toEqual(3);\n * }\n * }\n * ```\n * This directive would be instantiated with `Dependency` declared at the same element, in this case\n * `dependency=\"3\"`.\n *\n * ### Injecting a directive from any ancestor elements\n *\n * Directives can inject other directives declared on any ancestor element (in the current Shadow\n * DOM), i.e. on the current element, the\n * parent element, or its parents.\n * ```\n * @Directive({ selector: '[my-directive]' })\n * class MyDirective {\n * constructor(@Host() dependency: Dependency) {\n * expect(dependency.id).toEqual(2);\n * }\n * }\n * ```\n *\n * `@Host` checks the current element, the parent, as well as its parents recursively. If\n * `dependency=\"2\"` didn't\n * exist on the direct parent, this injection would\n * have returned\n * `dependency=\"1\"`.\n *\n *\n * ### Injecting a live collection of direct child directives\n *\n *\n * A directive can also query for other child directives. Since parent directives are instantiated\n * before child directives, a directive can't simply inject the list of child directives. Instead,\n * the directive injects a {@link QueryList}, which updates its contents as children are added,\n * removed, or moved by a directive that uses a {@link ViewContainerRef} such as a `ngFor`, an\n * `ngIf`, or an `ngSwitch`.\n *\n * ```\n * @Directive({ selector: '[my-directive]' })\n * class MyDirective {\n * constructor(@Query(Dependency) dependencies:QueryList) {\n * }\n * }\n * ```\n *\n * This directive would be instantiated with a {@link QueryList} which contains `Dependency` 4 and\n * 6. Here, `Dependency` 5 would not be included, because it is not a direct child.\n *\n * ### Injecting a live collection of descendant directives\n *\n * By passing the descendant flag to `@Query` above, we can include the children of the child\n * elements.\n *\n * ```\n * @Directive({ selector: '[my-directive]' })\n * class MyDirective {\n * constructor(@Query(Dependency, {descendants: true}) dependencies:QueryList) {\n * }\n * }\n * ```\n *\n * This directive would be instantiated with a Query which would contain `Dependency` 4, 5 and 6.\n *\n * ### Optional injection\n *\n * The normal behavior of directives is to return an error when a specified dependency cannot be\n * resolved. If you\n * would like to inject `null` on unresolved dependency instead, you can annotate that dependency\n * with `@Optional()`.\n * This explicitly permits the author of a template to treat some of the surrounding directives as\n * optional.\n *\n * ```\n * @Directive({ selector: '[my-directive]' })\n * class MyDirective {\n * constructor(@Optional() dependency:Dependency) {\n * }\n * }\n * ```\n *\n * This directive would be instantiated with a `Dependency` directive found on the current element.\n * If none can be\n * found, the injector supplies `null` instead of throwing an error.\n *\n * ### Example\n *\n * Here we use a decorator directive to simply define basic tool-tip behavior.\n *\n * ```\n * @Directive({\n * selector: '[tooltip]',\n * inputs: [\n * 'text: tooltip'\n * ],\n * host: {\n * '(mouseenter)': 'onMouseEnter()',\n * '(mouseleave)': 'onMouseLeave()'\n * }\n * })\n * class Tooltip{\n * text:string;\n * overlay:Overlay; // NOT YET IMPLEMENTED\n * overlayManager:OverlayManager; // NOT YET IMPLEMENTED\n *\n * constructor(overlayManager:OverlayManager) {\n * this.overlay = overlay;\n * }\n *\n * onMouseEnter() {\n * // exact signature to be determined\n * this.overlay = this.overlayManager.open(text, ...);\n * }\n *\n * onMouseLeave() {\n * this.overlay.close();\n * this.overlay = null;\n * }\n * }\n * ```\n * In our HTML template, we can then add this behavior to a `
` or any other element with the\n * `tooltip` selector,\n * like so:\n *\n * ```\n *
\n * ```\n *\n * Directives can also control the instantiation, destruction, and positioning of inline template\n * elements:\n *\n * A directive uses a {@link ViewContainerRef} to instantiate, insert, move, and destroy views at\n * runtime.\n * The {@link ViewContainerRef} is created as a result of `
` element, and represents a\n * location in the current view\n * where these actions are performed.\n *\n * Views are always created as children of the current {@link ViewMetadata}, and as siblings of the\n * `` element. Thus a\n * directive in a child view cannot inject the directive that created it.\n *\n * Since directives that create views via ViewContainers are common in Angular, and using the full\n * `` element syntax is wordy, Angular\n * also supports a shorthand notation: `` and `` are\n * equivalent.\n *\n * Thus,\n *\n * ```\n * \n * ```\n *\n * Expands in use to:\n *\n * ```\n * \n * ```\n *\n * Notice that although the shorthand places `*foo=\"bar\"` within the `` element, the binding for\n * the directive\n * controller is correctly instantiated on the `` element rather than the `` element.\n *\n * ## Lifecycle hooks\n *\n * When the directive class implements some {@link ../../guide/lifecycle-hooks.html} the callbacks\n * are called by the change detection at defined points in time during the life of the directive.\n *\n * ### Example\n *\n * Let's suppose we want to implement the `unless` behavior, to conditionally include a template.\n *\n * Here is a simple directive that triggers on an `unless` selector:\n *\n * ```\n * @Directive({\n * selector: '[unless]',\n * inputs: ['unless']\n * })\n * export class Unless {\n * viewContainer: ViewContainerRef;\n * templateRef: TemplateRef;\n * prevCondition: boolean;\n *\n * constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef) {\n * this.viewContainer = viewContainer;\n * this.templateRef = templateRef;\n * this.prevCondition = null;\n * }\n *\n * set unless(newCondition) {\n * if (newCondition && (isBlank(this.prevCondition) || !this.prevCondition)) {\n * this.prevCondition = true;\n * this.viewContainer.clear();\n * } else if (!newCondition && (isBlank(this.prevCondition) || this.prevCondition)) {\n * this.prevCondition = false;\n * this.viewContainer.create(this.templateRef);\n * }\n * }\n * }\n * ```\n *\n * We can then use this `unless` selector in a template:\n * ```\n * \n * ```\n *\n * Once the directive instantiates the child view, the shorthand notation for the template expands\n * and the result is:\n *\n * ```\n * \n * ```\n *\n * Note also that although the `` template still exists inside the ``,\n * the instantiated\n * view occurs on the second `` which is a sibling to the `` element.\n */\nexports.Directive = decorators_1.makeDecorator(directives_2.DirectiveMetadata);\n// TODO(alexeagle): remove the duplication of this doc. It is copied from ViewMetadata.\n/**\n * Metadata properties available for configuring Views.\n *\n * Each Angular component requires a single `@Component` and at least one `@View` annotation. The\n * `@View` annotation specifies the HTML template to use, and lists the directives that are active\n * within the template.\n *\n * When a component is instantiated, the template is loaded into the component's shadow root, and\n * the expressions and statements in the template are evaluated against the component.\n *\n * For details on the `@Component` annotation, see {@link ComponentMetadata}.\n *\n * ### Example\n *\n * ```\n * @Component({\n * selector: 'greet',\n * template: 'Hello {{name}}!',\n * directives: [GreetUser, Bold]\n * })\n * class Greet {\n * name: string;\n *\n * constructor() {\n * this.name = 'World';\n * }\n * }\n * ```\n */\nvar View = decorators_1.makeDecorator(view_2.ViewMetadata, function (fn) { return fn.View = View; });\n/**\n * Specifies that a constant attribute value should be injected.\n *\n * The directive can inject constant string literals of host element attributes.\n *\n * ### Example\n *\n * Suppose we have an `` element and want to know its `type`.\n *\n * ```html\n * \n * ```\n *\n * A decorator can inject string literal `text` like so:\n *\n * {@example core/ts/metadata/metadata.ts region='attributeMetadata'}\n */\nexports.Attribute = decorators_1.makeParamDecorator(di_2.AttributeMetadata);\n// TODO(alexeagle): remove the duplication of this doc. It is copied from QueryMetadata.\n/**\n * Declares an injectable parameter to be a live list of directives or variable\n * bindings from the content children of a directive.\n *\n * ### Example ([live demo](http://plnkr.co/edit/lY9m8HLy7z06vDoUaSN2?p=preview))\n *\n * Assume that `` component would like to get a list its children ``\n * components as shown in this example:\n *\n * ```html\n * \n * ...\n * {{o.text}}\n * \n * ```\n *\n * The preferred solution is to query for `Pane` directives using this decorator.\n *\n * ```javascript\n * @Component({\n * selector: 'pane',\n * inputs: ['title']\n * })\n * class Pane {\n * title:string;\n * }\n *\n * @Component({\n * selector: 'tabs',\n * template: `\n * \n * \n * `\n * })\n * class Tabs {\n * panes: QueryList;\n * constructor(@Query(Pane) panes:QueryList) {\n * this.panes = panes;\n * }\n * }\n * ```\n *\n * A query can look for variable bindings by passing in a string with desired binding symbol.\n *\n * ### Example ([live demo](http://plnkr.co/edit/sT2j25cH1dURAyBRCKx1?p=preview))\n * ```html\n * \n * ...
\n * \n *\n * @Component({ selector: 'seeker' })\n * class seeker {\n * constructor(@Query('findme') elList: QueryList) {...}\n * }\n * ```\n *\n * In this case the object that is injected depend on the type of the variable\n * binding. It can be an ElementRef, a directive or a component.\n *\n * Passing in a comma separated list of variable bindings will query for all of them.\n *\n * ```html\n * \n * ...
\n * ...
\n * \n *\n * @Component({\n * selector: 'seeker'\n * })\n * class Seeker {\n * constructor(@Query('findMe, findMeToo') elList: QueryList) {...}\n * }\n * ```\n *\n * Configure whether query looks for direct children or all descendants\n * of the querying element, by using the `descendants` parameter.\n * It is set to `false` by default.\n *\n * ### Example ([live demo](http://plnkr.co/edit/wtGeB977bv7qvA5FTYl9?p=preview))\n * ```html\n * \n * - a
\n * - b
\n * \n * - c
\n * \n * \n * ```\n *\n * When querying for items, the first container will see only `a` and `b` by default,\n * but with `Query(TextDirective, {descendants: true})` it will see `c` too.\n *\n * The queried directives are kept in a depth-first pre-order with respect to their\n * positions in the DOM.\n *\n * Query does not look deep into any subcomponent views.\n *\n * Query is updated as part of the change-detection cycle. Since change detection\n * happens after construction of a directive, QueryList will always be empty when observed in the\n * constructor.\n *\n * The injected object is an unmodifiable live list.\n * See {@link QueryList} for more details.\n */\nexports.Query = decorators_1.makeParamDecorator(di_2.QueryMetadata);\n// TODO(alexeagle): remove the duplication of this doc. It is copied from ContentChildrenMetadata.\n/**\n * Configures a content query.\n *\n * Content queries are set before the `ngAfterContentInit` callback is called.\n *\n * ### Example\n *\n * ```\n * @Directive({\n * selector: 'someDir'\n * })\n * class SomeDir {\n * @ContentChildren(ChildDirective) contentChildren: QueryList;\n *\n * ngAfterContentInit() {\n * // contentChildren is set\n * }\n * }\n * ```\n */\nexports.ContentChildren = decorators_1.makePropDecorator(di_2.ContentChildrenMetadata);\n// TODO(alexeagle): remove the duplication of this doc. It is copied from ContentChildMetadata.\n/**\n * Configures a content query.\n *\n * Content queries are set before the `ngAfterContentInit` callback is called.\n *\n * ### Example\n *\n * ```\n * @Directive({\n * selector: 'someDir'\n * })\n * class SomeDir {\n * @ContentChild(ChildDirective) contentChild;\n *\n * ngAfterContentInit() {\n * // contentChild is set\n * }\n * }\n * ```\n */\nexports.ContentChild = decorators_1.makePropDecorator(di_2.ContentChildMetadata);\n// TODO(alexeagle): remove the duplication of this doc. It is copied from ViewChildrenMetadata.\n/**\n * Declares a list of child element references.\n *\n * Angular automatically updates the list when the DOM is updated.\n *\n * `ViewChildren` takes a argument to select elements.\n *\n * - If the argument is a type, directives or components with the type will be bound.\n *\n * - If the argument is a string, the string is interpreted as a list of comma-separated selectors.\n * For each selector, an element containing the matching template variable (e.g. `#child`) will be\n * bound.\n *\n * View children are set before the `ngAfterViewInit` callback is called.\n *\n * ### Example\n *\n * With type selector:\n *\n * ```\n * @Component({\n * selector: 'child-cmp',\n * template: 'child
'\n * })\n * class ChildCmp {\n * doSomething() {}\n * }\n *\n * @Component({\n * selector: 'some-cmp',\n * template: `\n * \n * \n * \n * `,\n * directives: [ChildCmp]\n * })\n * class SomeCmp {\n * @ViewChildren(ChildCmp) children:QueryList;\n *\n * ngAfterViewInit() {\n * // children are set\n * this.children.toArray().forEach((child)=>child.doSomething());\n * }\n * }\n * ```\n *\n * With string selector:\n *\n * ```\n * @Component({\n * selector: 'child-cmp',\n * template: 'child
'\n * })\n * class ChildCmp {\n * doSomething() {}\n * }\n *\n * @Component({\n * selector: 'some-cmp',\n * template: `\n * \n * \n * \n * `,\n * directives: [ChildCmp]\n * })\n * class SomeCmp {\n * @ViewChildren('child1,child2,child3') children:QueryList;\n *\n * ngAfterViewInit() {\n * // children are set\n * this.children.toArray().forEach((child)=>child.doSomething());\n * }\n * }\n * ```\n *\n * See also: [ViewChildrenMetadata]\n */\nexports.ViewChildren = decorators_1.makePropDecorator(di_2.ViewChildrenMetadata);\n// TODO(alexeagle): remove the duplication of this doc. It is copied from ViewChildMetadata.\n/**\n * Declares a reference to a child element.\n *\n * `ViewChildren` takes a argument to select elements.\n *\n * - If the argument is a type, a directive or a component with the type will be bound.\n *\n * - If the argument is a string, the string is interpreted as a selector. An element containing the\n * matching template variable (e.g. `#child`) will be bound.\n *\n * In either case, `@ViewChild()` assigns the first (looking from above) element if there are\n * multiple matches.\n *\n * View child is set before the `ngAfterViewInit` callback is called.\n *\n * ### Example\n *\n * With type selector:\n *\n * ```\n * @Component({\n * selector: 'child-cmp',\n * template: 'child
'\n * })\n * class ChildCmp {\n * doSomething() {}\n * }\n *\n * @Component({\n * selector: 'some-cmp',\n * template: '',\n * directives: [ChildCmp]\n * })\n * class SomeCmp {\n * @ViewChild(ChildCmp) child:ChildCmp;\n *\n * ngAfterViewInit() {\n * // child is set\n * this.child.doSomething();\n * }\n * }\n * ```\n *\n * With string selector:\n *\n * ```\n * @Component({\n * selector: 'child-cmp',\n * template: 'child
'\n * })\n * class ChildCmp {\n * doSomething() {}\n * }\n *\n * @Component({\n * selector: 'some-cmp',\n * template: '',\n * directives: [ChildCmp]\n * })\n * class SomeCmp {\n * @ViewChild('child') child:ChildCmp;\n *\n * ngAfterViewInit() {\n * // child is set\n * this.child.doSomething();\n * }\n * }\n * ```\n * See also: [ViewChildMetadata]\n */\nexports.ViewChild = decorators_1.makePropDecorator(di_2.ViewChildMetadata);\n// TODO(alexeagle): remove the duplication of this doc. It is copied from ViewQueryMetadata.\n/**\n * Similar to {@link QueryMetadata}, but querying the component view, instead of\n * the content children.\n *\n * ### Example ([live demo](http://plnkr.co/edit/eNsFHDf7YjyM6IzKxM1j?p=preview))\n *\n * ```javascript\n * @Component({\n * ...,\n * template: `\n * - a
\n * - b
\n * - c
\n * `\n * })\n * class MyComponent {\n * shown: boolean;\n *\n * constructor(private @Query(Item) items:QueryList- ) {\n * items.changes.subscribe(() => console.log(items.length));\n * }\n * }\n * ```\n *\n * Supports the same querying parameters as {@link QueryMetadata}, except\n * `descendants`. This always queries the whole view.\n *\n * As `shown` is flipped between true and false, items will contain zero of one\n * items.\n *\n * Specifies that a {@link QueryList} should be injected.\n *\n * The injected object is an iterable and observable live list.\n * See {@link QueryList} for more details.\n */\nexports.ViewQuery = decorators_1.makeParamDecorator(di_2.ViewQueryMetadata);\n// TODO(alexeagle): remove the duplication of this doc. It is copied from PipeMetadata.\n/**\n * Declare reusable pipe function.\n *\n * ### Example\n *\n * {@example core/ts/metadata/metadata.ts region='pipe'}\n */\nexports.Pipe = decorators_1.makeDecorator(directives_2.PipeMetadata);\n// TODO(alexeagle): remove the duplication of this doc. It is copied from InputMetadata.\n/**\n * Declares a data-bound input property.\n *\n * Angular automatically updates data-bound properties during change detection.\n *\n * `InputMetadata` takes an optional parameter that specifies the name\n * used when instantiating a component in the template. When not provided,\n * the name of the decorated property is used.\n *\n * ### Example\n *\n * The following example creates a component with two input properties.\n *\n * ```typescript\n * @Component({\n * selector: 'bank-account',\n * template: `\n * Bank Name: {{bankName}}\n * Account Id: {{id}}\n * `\n * })\n * class BankAccount {\n * @Input() bankName: string;\n * @Input('account-id') id: string;\n *\n * // this property is not bound, and won't be automatically updated by Angular\n * normalizedBankName: string;\n * }\n *\n * @Component({\n * selector: 'app',\n * template: `\n * \n * `,\n * directives: [BankAccount]\n * })\n * class App {}\n *\n * bootstrap(App);\n * ```\n */\nexports.Input = decorators_1.makePropDecorator(directives_2.InputMetadata);\n// TODO(alexeagle): remove the duplication of this doc. It is copied from OutputMetadata.\n/**\n * Declares an event-bound output property.\n *\n * When an output property emits an event, an event handler attached to that event\n * the template is invoked.\n *\n * `OutputMetadata` takes an optional parameter that specifies the name\n * used when instantiating a component in the template. When not provided,\n * the name of the decorated property is used.\n *\n * ### Example\n *\n * ```typescript\n * @Directive({\n * selector: 'interval-dir',\n * })\n * class IntervalDir {\n * @Output() everySecond = new EventEmitter();\n * @Output('everyFiveSeconds') five5Secs = new EventEmitter();\n *\n * constructor() {\n * setInterval(() => this.everySecond.emit(\"event\"), 1000);\n * setInterval(() => this.five5Secs.emit(\"event\"), 5000);\n * }\n * }\n *\n * @Component({\n * selector: 'app',\n * template: `\n * \n * \n * `,\n * directives: [IntervalDir]\n * })\n * class App {\n * everySecond() { console.log('second'); }\n * everyFiveSeconds() { console.log('five seconds'); }\n * }\n * bootstrap(App);\n * ```\n */\nexports.Output = decorators_1.makePropDecorator(directives_2.OutputMetadata);\n// TODO(alexeagle): remove the duplication of this doc. It is copied from HostBindingMetadata.\n/**\n * Declares a host property binding.\n *\n * Angular automatically checks host property bindings during change detection.\n * If a binding changes, it will update the host element of the directive.\n *\n * `HostBindingMetadata` takes an optional parameter that specifies the property\n * name of the host element that will be updated. When not provided,\n * the class property name is used.\n *\n * ### Example\n *\n * The following example creates a directive that sets the `valid` and `invalid` classes\n * on the DOM element that has ngModel directive on it.\n *\n * ```typescript\n * @Directive({selector: '[ngModel]'})\n * class NgModelStatus {\n * constructor(public control:NgModel) {}\n * @HostBinding('[class.valid]') get valid { return this.control.valid; }\n * @HostBinding('[class.invalid]') get invalid { return this.control.invalid; }\n * }\n *\n * @Component({\n * selector: 'app',\n * template: ``,\n * directives: [FORM_DIRECTIVES, NgModelStatus]\n * })\n * class App {\n * prop;\n * }\n *\n * bootstrap(App);\n * ```\n */\nexports.HostBinding = decorators_1.makePropDecorator(directives_2.HostBindingMetadata);\n// TODO(alexeagle): remove the duplication of this doc. It is copied from HostListenerMetadata.\n/**\n * Declares a host listener.\n *\n * Angular will invoke the decorated method when the host element emits the specified event.\n *\n * If the decorated method returns `false`, then `preventDefault` is applied on the DOM\n * event.\n *\n * ### Example\n *\n * The following example declares a directive that attaches a click listener to the button and\n * counts clicks.\n *\n * ```typescript\n * @Directive({selector: 'button[counting]'})\n * class CountClicks {\n * numberOfClicks = 0;\n *\n * @HostListener('click', ['$event.target'])\n * onClick(btn) {\n * console.log(\"button\", btn, \"number of clicks:\", this.numberOfClicks++);\n * }\n * }\n *\n * @Component({\n * selector: 'app',\n * template: ``,\n * directives: [CountClicks]\n * })\n * class App {}\n *\n * bootstrap(App);\n * ```\n */\nexports.HostListener = decorators_1.makePropDecorator(directives_2.HostListenerMetadata);\n//# sourceMappingURL=metadata.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/metadata.js\n ** module id = 391\n ** module chunks = 0\n **/","\"use strict\";\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})(exports.LifecycleHooks || (exports.LifecycleHooks = {}));\nvar LifecycleHooks = exports.LifecycleHooks;\n/**\n * @internal\n */\nexports.LIFECYCLE_HOOKS_VALUES = [\n LifecycleHooks.OnInit,\n LifecycleHooks.OnDestroy,\n LifecycleHooks.DoCheck,\n LifecycleHooks.OnChanges,\n LifecycleHooks.AfterContentInit,\n LifecycleHooks.AfterContentChecked,\n LifecycleHooks.AfterViewInit,\n LifecycleHooks.AfterViewChecked\n];\n//# sourceMappingURL=lifecycle_hooks.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/metadata/lifecycle_hooks.js\n ** module id = 392\n ** module chunks = 0\n **/","\"use strict\";\nvar console_1 = require('./console');\nvar reflection_1 = require('./reflection/reflection');\nvar reflector_reader_1 = require('./reflection/reflector_reader');\nvar testability_1 = require('./testability/testability');\nvar application_ref_1 = require('./application_ref');\nfunction _reflector() {\n return reflection_1.reflector;\n}\nvar __unused; // prevent missing use Dart warning.\n/**\n * A default set of providers which should be included in any Angular platform.\n */\nexports.PLATFORM_COMMON_PROVIDERS = [\n application_ref_1.PLATFORM_CORE_PROVIDERS,\n /*@ts2dart_Provider*/ { provide: reflection_1.Reflector, useFactory: _reflector, deps: [] },\n /*@ts2dart_Provider*/ { provide: reflector_reader_1.ReflectorReader, useExisting: reflection_1.Reflector },\n testability_1.TestabilityRegistry,\n console_1.Console\n];\n//# sourceMappingURL=platform_common_providers.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/platform_common_providers.js\n ** module id = 393\n ** module chunks = 0\n **/","\"use strict\";\nvar di_1 = require('./di');\n/**\n * A token that can be provided when bootstraping an application to make an array of directives\n * available in every component of the application.\n *\n * ### Example\n *\n * ```typescript\n * import {PLATFORM_DIRECTIVES} from '@angular/core';\n * import {OtherDirective} from './myDirectives';\n *\n * @Component({\n * selector: 'my-component',\n * template: `\n * \n * \n * `\n * })\n * export class MyComponent {\n * ...\n * }\n *\n * bootstrap(MyComponent, [provide(PLATFORM_DIRECTIVES, {useValue: [OtherDirective], multi:true})]);\n * ```\n */\nexports.PLATFORM_DIRECTIVES = \n/*@ts2dart_const*/ new di_1.OpaqueToken(\"Platform Directives\");\n/**\n * A token that can be provided when bootstraping an application to make an array of pipes\n * available in every component of the application.\n *\n * ### Example\n *\n * ```typescript\n * import {PLATFORM_PIPES} from '@angular/core';\n * import {OtherPipe} from './myPipe';\n *\n * @Component({\n * selector: 'my-component',\n * template: `\n * {{123 | other-pipe}}\n * `\n * })\n * export class MyComponent {\n * ...\n * }\n *\n * bootstrap(MyComponent, [provide(PLATFORM_PIPES, {useValue: [OtherPipe], multi:true})]);\n * ```\n */\nexports.PLATFORM_PIPES = new di_1.OpaqueToken(\"Platform Pipes\");\n//# sourceMappingURL=platform_directives_and_pipes.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/platform_directives_and_pipes.js\n ** module id = 394\n ** module chunks = 0\n **/","\"use strict\";\nvar lang_1 = require('../../src/facade/lang');\nvar trace;\nvar events;\nfunction detectWTF() {\n var wtf = lang_1.global['wtf'];\n if (wtf) {\n trace = wtf['trace'];\n if (trace) {\n events = trace['events'];\n return true;\n }\n }\n return false;\n}\nexports.detectWTF = detectWTF;\nfunction createScope(signature, flags) {\n if (flags === void 0) { flags = null; }\n return events.createScope(signature, flags);\n}\nexports.createScope = createScope;\nfunction leave(scope, returnValue) {\n trace.leaveScope(scope, returnValue);\n return returnValue;\n}\nexports.leave = leave;\nfunction startTimeRange(rangeType, action) {\n return trace.beginTimeRange(rangeType, action);\n}\nexports.startTimeRange = startTimeRange;\nfunction endTimeRange(range) {\n trace.endTimeRange(range);\n}\nexports.endTimeRange = endTimeRange;\n//# sourceMappingURL=wtf_impl.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/profile/wtf_impl.js\n ** module id = 395\n ** module chunks = 0\n **/","\"use strict\";\n/**\n* This is here because DART requires it. It is noop in JS.\n*/\nfunction wtfInit() { }\nexports.wtfInit = wtfInit;\n//# sourceMappingURL=wtf_init.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/profile/wtf_init.js\n ** module id = 396\n ** module chunks = 0\n **/","\"use strict\";\n// Public API for render\nvar api_1 = require('./render/api');\nexports.RootRenderer = api_1.RootRenderer;\nexports.Renderer = api_1.Renderer;\nexports.RenderComponentType = api_1.RenderComponentType;\n//# sourceMappingURL=render.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/render.js\n ** module id = 397\n ** module chunks = 0\n **/","\"use strict\";\n// Public API for util\nvar decorators_1 = require('./util/decorators');\nexports.Class = decorators_1.Class;\n//# sourceMappingURL=util.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/util.js\n ** module id = 398\n ** module chunks = 0\n **/","\"use strict\";\n// Public API for Zone\nvar ng_zone_1 = require('./zone/ng_zone');\nexports.NgZone = ng_zone_1.NgZone;\nexports.NgZoneError = ng_zone_1.NgZoneError;\n//# sourceMappingURL=zone.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/@angular/core/src/zone.js\n ** module id = 399\n ** module chunks = 0\n **/","/*!\n * @overview es6-promise - a tiny implementation of Promises/A+.\n * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)\n * @license Licensed under MIT license\n * See https://raw.githubusercontent.com/jakearchibald/es6-promise/master/LICENSE\n * @version 3.1.2\n */\n\n(function() {\n \"use strict\";\n function lib$es6$promise$utils$$objectOrFunction(x) {\n return typeof x === 'function' || (typeof x === 'object' && x !== null);\n }\n\n function lib$es6$promise$utils$$isFunction(x) {\n return typeof x === 'function';\n }\n\n function lib$es6$promise$utils$$isMaybeThenable(x) {\n return typeof x === 'object' && x !== null;\n }\n\n var lib$es6$promise$utils$$_isArray;\n if (!Array.isArray) {\n lib$es6$promise$utils$$_isArray = function (x) {\n return Object.prototype.toString.call(x) === '[object Array]';\n };\n } else {\n lib$es6$promise$utils$$_isArray = Array.isArray;\n }\n\n var lib$es6$promise$utils$$isArray = lib$es6$promise$utils$$_isArray;\n var lib$es6$promise$asap$$len = 0;\n var lib$es6$promise$asap$$vertxNext;\n var lib$es6$promise$asap$$customSchedulerFn;\n\n var lib$es6$promise$asap$$asap = function asap(callback, arg) {\n lib$es6$promise$asap$$queue[lib$es6$promise$asap$$len] = callback;\n lib$es6$promise$asap$$queue[lib$es6$promise$asap$$len + 1] = arg;\n lib$es6$promise$asap$$len += 2;\n if (lib$es6$promise$asap$$len === 2) {\n // If len is 2, that means that we need to schedule an async flush.\n // If additional callbacks are queued before the queue is flushed, they\n // will be processed by this flush that we are scheduling.\n if (lib$es6$promise$asap$$customSchedulerFn) {\n lib$es6$promise$asap$$customSchedulerFn(lib$es6$promise$asap$$flush);\n } else {\n lib$es6$promise$asap$$scheduleFlush();\n }\n }\n }\n\n function lib$es6$promise$asap$$setScheduler(scheduleFn) {\n lib$es6$promise$asap$$customSchedulerFn = scheduleFn;\n }\n\n function lib$es6$promise$asap$$setAsap(asapFn) {\n lib$es6$promise$asap$$asap = asapFn;\n }\n\n var lib$es6$promise$asap$$browserWindow = (typeof window !== 'undefined') ? window : undefined;\n var lib$es6$promise$asap$$browserGlobal = lib$es6$promise$asap$$browserWindow || {};\n var lib$es6$promise$asap$$BrowserMutationObserver = lib$es6$promise$asap$$browserGlobal.MutationObserver || lib$es6$promise$asap$$browserGlobal.WebKitMutationObserver;\n var lib$es6$promise$asap$$isNode = typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';\n\n // test for web worker but not in IE10\n var lib$es6$promise$asap$$isWorker = typeof Uint8ClampedArray !== 'undefined' &&\n typeof importScripts !== 'undefined' &&\n typeof MessageChannel !== 'undefined';\n\n // node\n function lib$es6$promise$asap$$useNextTick() {\n // node version 0.10.x displays a deprecation warning when nextTick is used recursively\n // see https://github.com/cujojs/when/issues/410 for details\n return function() {\n process.nextTick(lib$es6$promise$asap$$flush);\n };\n }\n\n // vertx\n function lib$es6$promise$asap$$useVertxTimer() {\n return function() {\n lib$es6$promise$asap$$vertxNext(lib$es6$promise$asap$$flush);\n };\n }\n\n function lib$es6$promise$asap$$useMutationObserver() {\n var iterations = 0;\n var observer = new lib$es6$promise$asap$$BrowserMutationObserver(lib$es6$promise$asap$$flush);\n var node = document.createTextNode('');\n observer.observe(node, { characterData: true });\n\n return function() {\n node.data = (iterations = ++iterations % 2);\n };\n }\n\n // web worker\n function lib$es6$promise$asap$$useMessageChannel() {\n var channel = new MessageChannel();\n channel.port1.onmessage = lib$es6$promise$asap$$flush;\n return function () {\n channel.port2.postMessage(0);\n };\n }\n\n function lib$es6$promise$asap$$useSetTimeout() {\n return function() {\n setTimeout(lib$es6$promise$asap$$flush, 1);\n };\n }\n\n var lib$es6$promise$asap$$queue = new Array(1000);\n function lib$es6$promise$asap$$flush() {\n for (var i = 0; i < lib$es6$promise$asap$$len; i+=2) {\n var callback = lib$es6$promise$asap$$queue[i];\n var arg = lib$es6$promise$asap$$queue[i+1];\n\n callback(arg);\n\n lib$es6$promise$asap$$queue[i] = undefined;\n lib$es6$promise$asap$$queue[i+1] = undefined;\n }\n\n lib$es6$promise$asap$$len = 0;\n }\n\n function lib$es6$promise$asap$$attemptVertx() {\n try {\n var r = require;\n var vertx = r('vertx');\n lib$es6$promise$asap$$vertxNext = vertx.runOnLoop || vertx.runOnContext;\n return lib$es6$promise$asap$$useVertxTimer();\n } catch(e) {\n return lib$es6$promise$asap$$useSetTimeout();\n }\n }\n\n var lib$es6$promise$asap$$scheduleFlush;\n // Decide what async method to use to triggering processing of queued callbacks:\n if (lib$es6$promise$asap$$isNode) {\n lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useNextTick();\n } else if (lib$es6$promise$asap$$BrowserMutationObserver) {\n lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMutationObserver();\n } else if (lib$es6$promise$asap$$isWorker) {\n lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMessageChannel();\n } else if (lib$es6$promise$asap$$browserWindow === undefined && typeof require === 'function') {\n lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$attemptVertx();\n } else {\n lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useSetTimeout();\n }\n function lib$es6$promise$then$$then(onFulfillment, onRejection) {\n var parent = this;\n var state = parent._state;\n\n if (state === lib$es6$promise$$internal$$FULFILLED && !onFulfillment || state === lib$es6$promise$$internal$$REJECTED && !onRejection) {\n return this;\n }\n\n var child = new this.constructor(lib$es6$promise$$internal$$noop);\n var result = parent._result;\n\n if (state) {\n var callback = arguments[state - 1];\n lib$es6$promise$asap$$asap(function(){\n lib$es6$promise$$internal$$invokeCallback(state, child, callback, result);\n });\n } else {\n lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection);\n }\n\n return child;\n }\n var lib$es6$promise$then$$default = lib$es6$promise$then$$then;\n function lib$es6$promise$promise$resolve$$resolve(object) {\n /*jshint validthis:true */\n var Constructor = this;\n\n if (object && typeof object === 'object' && object.constructor === Constructor) {\n return object;\n }\n\n var promise = new Constructor(lib$es6$promise$$internal$$noop);\n lib$es6$promise$$internal$$resolve(promise, object);\n return promise;\n }\n var lib$es6$promise$promise$resolve$$default = lib$es6$promise$promise$resolve$$resolve;\n\n function lib$es6$promise$$internal$$noop() {}\n\n var lib$es6$promise$$internal$$PENDING = void 0;\n var lib$es6$promise$$internal$$FULFILLED = 1;\n var lib$es6$promise$$internal$$REJECTED = 2;\n\n var lib$es6$promise$$internal$$GET_THEN_ERROR = new lib$es6$promise$$internal$$ErrorObject();\n\n function lib$es6$promise$$internal$$selfFulfillment() {\n return new TypeError(\"You cannot resolve a promise with itself\");\n }\n\n function lib$es6$promise$$internal$$cannotReturnOwn() {\n return new TypeError('A promises callback cannot return that same promise.');\n }\n\n function lib$es6$promise$$internal$$getThen(promise) {\n try {\n return promise.then;\n } catch(error) {\n lib$es6$promise$$internal$$GET_THEN_ERROR.error = error;\n return lib$es6$promise$$internal$$GET_THEN_ERROR;\n }\n }\n\n function lib$es6$promise$$internal$$tryThen(then, value, fulfillmentHandler, rejectionHandler) {\n try {\n then.call(value, fulfillmentHandler, rejectionHandler);\n } catch(e) {\n return e;\n }\n }\n\n function lib$es6$promise$$internal$$handleForeignThenable(promise, thenable, then) {\n lib$es6$promise$asap$$asap(function(promise) {\n var sealed = false;\n var error = lib$es6$promise$$internal$$tryThen(then, thenable, function(value) {\n if (sealed) { return; }\n sealed = true;\n if (thenable !== value) {\n lib$es6$promise$$internal$$resolve(promise, value);\n } else {\n lib$es6$promise$$internal$$fulfill(promise, value);\n }\n }, function(reason) {\n if (sealed) { return; }\n sealed = true;\n\n lib$es6$promise$$internal$$reject(promise, reason);\n }, 'Settle: ' + (promise._label || ' unknown promise'));\n\n if (!sealed && error) {\n sealed = true;\n lib$es6$promise$$internal$$reject(promise, error);\n }\n }, promise);\n }\n\n function lib$es6$promise$$internal$$handleOwnThenable(promise, thenable) {\n if (thenable._state === lib$es6$promise$$internal$$FULFILLED) {\n lib$es6$promise$$internal$$fulfill(promise, thenable._result);\n } else if (thenable._state === lib$es6$promise$$internal$$REJECTED) {\n lib$es6$promise$$internal$$reject(promise, thenable._result);\n } else {\n lib$es6$promise$$internal$$subscribe(thenable, undefined, function(value) {\n lib$es6$promise$$internal$$resolve(promise, value);\n }, function(reason) {\n lib$es6$promise$$internal$$reject(promise, reason);\n });\n }\n }\n\n function lib$es6$promise$$internal$$handleMaybeThenable(promise, maybeThenable, then) {\n if (maybeThenable.constructor === promise.constructor &&\n then === lib$es6$promise$then$$default &&\n constructor.resolve === lib$es6$promise$promise$resolve$$default) {\n lib$es6$promise$$internal$$handleOwnThenable(promise, maybeThenable);\n } else {\n if (then === lib$es6$promise$$internal$$GET_THEN_ERROR) {\n lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$GET_THEN_ERROR.error);\n } else if (then === undefined) {\n lib$es6$promise$$internal$$fulfill(promise, maybeThenable);\n } else if (lib$es6$promise$utils$$isFunction(then)) {\n lib$es6$promise$$internal$$handleForeignThenable(promise, maybeThenable, then);\n } else {\n lib$es6$promise$$internal$$fulfill(promise, maybeThenable);\n }\n }\n }\n\n function lib$es6$promise$$internal$$resolve(promise, value) {\n if (promise === value) {\n lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$selfFulfillment());\n } else if (lib$es6$promise$utils$$objectOrFunction(value)) {\n lib$es6$promise$$internal$$handleMaybeThenable(promise, value, lib$es6$promise$$internal$$getThen(value));\n } else {\n lib$es6$promise$$internal$$fulfill(promise, value);\n }\n }\n\n function lib$es6$promise$$internal$$publishRejection(promise) {\n if (promise._onerror) {\n promise._onerror(promise._result);\n }\n\n lib$es6$promise$$internal$$publish(promise);\n }\n\n function lib$es6$promise$$internal$$fulfill(promise, value) {\n if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; }\n\n promise._result = value;\n promise._state = lib$es6$promise$$internal$$FULFILLED;\n\n if (promise._subscribers.length !== 0) {\n lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publish, promise);\n }\n }\n\n function lib$es6$promise$$internal$$reject(promise, reason) {\n if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; }\n promise._state = lib$es6$promise$$internal$$REJECTED;\n promise._result = reason;\n\n lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publishRejection, promise);\n }\n\n function lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection) {\n var subscribers = parent._subscribers;\n var length = subscribers.length;\n\n parent._onerror = null;\n\n subscribers[length] = child;\n subscribers[length + lib$es6$promise$$internal$$FULFILLED] = onFulfillment;\n subscribers[length + lib$es6$promise$$internal$$REJECTED] = onRejection;\n\n if (length === 0 && parent._state) {\n lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publish, parent);\n }\n }\n\n function lib$es6$promise$$internal$$publish(promise) {\n var subscribers = promise._subscribers;\n var settled = promise._state;\n\n if (subscribers.length === 0) { return; }\n\n var child, callback, detail = promise._result;\n\n for (var i = 0; i < subscribers.length; i += 3) {\n child = subscribers[i];\n callback = subscribers[i + settled];\n\n if (child) {\n lib$es6$promise$$internal$$invokeCallback(settled, child, callback, detail);\n } else {\n callback(detail);\n }\n }\n\n promise._subscribers.length = 0;\n }\n\n function lib$es6$promise$$internal$$ErrorObject() {\n this.error = null;\n }\n\n var lib$es6$promise$$internal$$TRY_CATCH_ERROR = new lib$es6$promise$$internal$$ErrorObject();\n\n function lib$es6$promise$$internal$$tryCatch(callback, detail) {\n try {\n return callback(detail);\n } catch(e) {\n lib$es6$promise$$internal$$TRY_CATCH_ERROR.error = e;\n return lib$es6$promise$$internal$$TRY_CATCH_ERROR;\n }\n }\n\n function lib$es6$promise$$internal$$invokeCallback(settled, promise, callback, detail) {\n var hasCallback = lib$es6$promise$utils$$isFunction(callback),\n value, error, succeeded, failed;\n\n if (hasCallback) {\n value = lib$es6$promise$$internal$$tryCatch(callback, detail);\n\n if (value === lib$es6$promise$$internal$$TRY_CATCH_ERROR) {\n failed = true;\n error = value.error;\n value = null;\n } else {\n succeeded = true;\n }\n\n if (promise === value) {\n lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$cannotReturnOwn());\n return;\n }\n\n } else {\n value = detail;\n succeeded = true;\n }\n\n if (promise._state !== lib$es6$promise$$internal$$PENDING) {\n // noop\n } else if (hasCallback && succeeded) {\n lib$es6$promise$$internal$$resolve(promise, value);\n } else if (failed) {\n lib$es6$promise$$internal$$reject(promise, error);\n } else if (settled === lib$es6$promise$$internal$$FULFILLED) {\n lib$es6$promise$$internal$$fulfill(promise, value);\n } else if (settled === lib$es6$promise$$internal$$REJECTED) {\n lib$es6$promise$$internal$$reject(promise, value);\n }\n }\n\n function lib$es6$promise$$internal$$initializePromise(promise, resolver) {\n try {\n resolver(function resolvePromise(value){\n lib$es6$promise$$internal$$resolve(promise, value);\n }, function rejectPromise(reason) {\n lib$es6$promise$$internal$$reject(promise, reason);\n });\n } catch(e) {\n lib$es6$promise$$internal$$reject(promise, e);\n }\n }\n\n function lib$es6$promise$promise$all$$all(entries) {\n return new lib$es6$promise$enumerator$$default(this, entries).promise;\n }\n var lib$es6$promise$promise$all$$default = lib$es6$promise$promise$all$$all;\n function lib$es6$promise$promise$race$$race(entries) {\n /*jshint validthis:true */\n var Constructor = this;\n\n var promise = new Constructor(lib$es6$promise$$internal$$noop);\n\n if (!lib$es6$promise$utils$$isArray(entries)) {\n lib$es6$promise$$internal$$reject(promise, new TypeError('You must pass an array to race.'));\n return promise;\n }\n\n var length = entries.length;\n\n function onFulfillment(value) {\n lib$es6$promise$$internal$$resolve(promise, value);\n }\n\n function onRejection(reason) {\n lib$es6$promise$$internal$$reject(promise, reason);\n }\n\n for (var i = 0; promise._state === lib$es6$promise$$internal$$PENDING && i < length; i++) {\n lib$es6$promise$$internal$$subscribe(Constructor.resolve(entries[i]), undefined, onFulfillment, onRejection);\n }\n\n return promise;\n }\n var lib$es6$promise$promise$race$$default = lib$es6$promise$promise$race$$race;\n function lib$es6$promise$promise$reject$$reject(reason) {\n /*jshint validthis:true */\n var Constructor = this;\n var promise = new Constructor(lib$es6$promise$$internal$$noop);\n lib$es6$promise$$internal$$reject(promise, reason);\n return promise;\n }\n var lib$es6$promise$promise$reject$$default = lib$es6$promise$promise$reject$$reject;\n\n var lib$es6$promise$promise$$counter = 0;\n\n function lib$es6$promise$promise$$needsResolver() {\n throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');\n }\n\n function lib$es6$promise$promise$$needsNew() {\n throw new TypeError(\"Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.\");\n }\n\n var lib$es6$promise$promise$$default = lib$es6$promise$promise$$Promise;\n /**\n Promise objects represent the eventual result of an asynchronous operation. The\n primary way of interacting with a promise is through its `then` method, which\n registers callbacks to receive either a promise's eventual value or the reason\n why the promise cannot be fulfilled.\n\n Terminology\n -----------\n\n - `promise` is an object or function with a `then` method whose behavior conforms to this specification.\n - `thenable` is an object or function that defines a `then` method.\n - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).\n - `exception` is a value that is thrown using the throw statement.\n - `reason` is a value that indicates why a promise was rejected.\n - `settled` the final resting state of a promise, fulfilled or rejected.\n\n A promise can be in one of three states: pending, fulfilled, or rejected.\n\n Promises that are fulfilled have a fulfillment value and are in the fulfilled\n state. Promises that are rejected have a rejection reason and are in the\n rejected state. A fulfillment value is never a thenable.\n\n Promises can also be said to *resolve* a value. If this value is also a\n promise, then the original promise's settled state will match the value's\n settled state. So a promise that *resolves* a promise that rejects will\n itself reject, and a promise that *resolves* a promise that fulfills will\n itself fulfill.\n\n\n Basic Usage:\n ------------\n\n ```js\n var promise = new Promise(function(resolve, reject) {\n // on success\n resolve(value);\n\n // on failure\n reject(reason);\n });\n\n promise.then(function(value) {\n // on fulfillment\n }, function(reason) {\n // on rejection\n });\n ```\n\n Advanced Usage:\n ---------------\n\n Promises shine when abstracting away asynchronous interactions such as\n `XMLHttpRequest`s.\n\n ```js\n function getJSON(url) {\n return new Promise(function(resolve, reject){\n var xhr = new XMLHttpRequest();\n\n xhr.open('GET', url);\n xhr.onreadystatechange = handler;\n xhr.responseType = 'json';\n xhr.setRequestHeader('Accept', 'application/json');\n xhr.send();\n\n function handler() {\n if (this.readyState === this.DONE) {\n if (this.status === 200) {\n resolve(this.response);\n } else {\n reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));\n }\n }\n };\n });\n }\n\n getJSON('/posts.json').then(function(json) {\n // on fulfillment\n }, function(reason) {\n // on rejection\n });\n ```\n\n Unlike callbacks, promises are great composable primitives.\n\n ```js\n Promise.all([\n getJSON('/posts'),\n getJSON('/comments')\n ]).then(function(values){\n values[0] // => postsJSON\n values[1] // => commentsJSON\n\n return values;\n });\n ```\n\n @class Promise\n @param {function} resolver\n Useful for tooling.\n @constructor\n */\n function lib$es6$promise$promise$$Promise(resolver) {\n this._id = lib$es6$promise$promise$$counter++;\n this._state = undefined;\n this._result = undefined;\n this._subscribers = [];\n\n if (lib$es6$promise$$internal$$noop !== resolver) {\n typeof resolver !== 'function' && lib$es6$promise$promise$$needsResolver();\n this instanceof lib$es6$promise$promise$$Promise ? lib$es6$promise$$internal$$initializePromise(this, resolver) : lib$es6$promise$promise$$needsNew();\n }\n }\n\n lib$es6$promise$promise$$Promise.all = lib$es6$promise$promise$all$$default;\n lib$es6$promise$promise$$Promise.race = lib$es6$promise$promise$race$$default;\n lib$es6$promise$promise$$Promise.resolve = lib$es6$promise$promise$resolve$$default;\n lib$es6$promise$promise$$Promise.reject = lib$es6$promise$promise$reject$$default;\n lib$es6$promise$promise$$Promise._setScheduler = lib$es6$promise$asap$$setScheduler;\n lib$es6$promise$promise$$Promise._setAsap = lib$es6$promise$asap$$setAsap;\n lib$es6$promise$promise$$Promise._asap = lib$es6$promise$asap$$asap;\n\n lib$es6$promise$promise$$Promise.prototype = {\n constructor: lib$es6$promise$promise$$Promise,\n\n /**\n The primary way of interacting with a promise is through its `then` method,\n which registers callbacks to receive either a promise's eventual value or the\n reason why the promise cannot be fulfilled.\n\n ```js\n findUser().then(function(user){\n // user is available\n }, function(reason){\n // user is unavailable, and you are given the reason why\n });\n ```\n\n Chaining\n --------\n\n The return value of `then` is itself a promise. This second, 'downstream'\n promise is resolved with the return value of the first promise's fulfillment\n or rejection handler, or rejected if the handler throws an exception.\n\n ```js\n findUser().then(function (user) {\n return user.name;\n }, function (reason) {\n return 'default name';\n }).then(function (userName) {\n // If `findUser` fulfilled, `userName` will be the user's name, otherwise it\n // will be `'default name'`\n });\n\n findUser().then(function (user) {\n throw new Error('Found user, but still unhappy');\n }, function (reason) {\n throw new Error('`findUser` rejected and we're unhappy');\n }).then(function (value) {\n // never reached\n }, function (reason) {\n // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.\n // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.\n });\n ```\n If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.\n\n ```js\n findUser().then(function (user) {\n throw new PedagogicalException('Upstream error');\n }).then(function (value) {\n // never reached\n }).then(function (value) {\n // never reached\n }, function (reason) {\n // The `PedgagocialException` is propagated all the way down to here\n });\n ```\n\n Assimilation\n ------------\n\n Sometimes the value you want to propagate to a downstream promise can only be\n retrieved asynchronously. This can be achieved by returning a promise in the\n fulfillment or rejection handler. The downstream promise will then be pending\n until the returned promise is settled. This is called *assimilation*.\n\n ```js\n findUser().then(function (user) {\n return findCommentsByAuthor(user);\n }).then(function (comments) {\n // The user's comments are now available\n });\n ```\n\n If the assimliated promise rejects, then the downstream promise will also reject.\n\n ```js\n findUser().then(function (user) {\n return findCommentsByAuthor(user);\n }).then(function (comments) {\n // If `findCommentsByAuthor` fulfills, we'll have the value here\n }, function (reason) {\n // If `findCommentsByAuthor` rejects, we'll have the reason here\n });\n ```\n\n Simple Example\n --------------\n\n Synchronous Example\n\n ```javascript\n var result;\n\n try {\n result = findResult();\n // success\n } catch(reason) {\n // failure\n }\n ```\n\n Errback Example\n\n ```js\n findResult(function(result, err){\n if (err) {\n // failure\n } else {\n // success\n }\n });\n ```\n\n Promise Example;\n\n ```javascript\n findResult().then(function(result){\n // success\n }, function(reason){\n // failure\n });\n ```\n\n Advanced Example\n --------------\n\n Synchronous Example\n\n ```javascript\n var author, books;\n\n try {\n author = findAuthor();\n books = findBooksByAuthor(author);\n // success\n } catch(reason) {\n // failure\n }\n ```\n\n Errback Example\n\n ```js\n\n function foundBooks(books) {\n\n }\n\n function failure(reason) {\n\n }\n\n findAuthor(function(author, err){\n if (err) {\n failure(err);\n // failure\n } else {\n try {\n findBoooksByAuthor(author, function(books, err) {\n if (err) {\n failure(err);\n } else {\n try {\n foundBooks(books);\n } catch(reason) {\n failure(reason);\n }\n }\n });\n } catch(error) {\n failure(err);\n }\n // success\n }\n });\n ```\n\n Promise Example;\n\n ```javascript\n findAuthor().\n then(findBooksByAuthor).\n then(function(books){\n // found books\n }).catch(function(reason){\n // something went wrong\n });\n ```\n\n @method then\n @param {Function} onFulfilled\n @param {Function} onRejected\n Useful for tooling.\n @return {Promise}\n */\n then: lib$es6$promise$then$$default,\n\n /**\n `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same\n as the catch block of a try/catch statement.\n\n ```js\n function findAuthor(){\n throw new Error('couldn't find that author');\n }\n\n // synchronous\n try {\n findAuthor();\n } catch(reason) {\n // something went wrong\n }\n\n // async with promises\n findAuthor().catch(function(reason){\n // something went wrong\n });\n ```\n\n @method catch\n @param {Function} onRejection\n Useful for tooling.\n @return {Promise}\n */\n 'catch': function(onRejection) {\n return this.then(null, onRejection);\n }\n };\n var lib$es6$promise$enumerator$$default = lib$es6$promise$enumerator$$Enumerator;\n function lib$es6$promise$enumerator$$Enumerator(Constructor, input) {\n this._instanceConstructor = Constructor;\n this.promise = new Constructor(lib$es6$promise$$internal$$noop);\n\n if (Array.isArray(input)) {\n this._input = input;\n this.length = input.length;\n this._remaining = input.length;\n\n this._result = new Array(this.length);\n\n if (this.length === 0) {\n lib$es6$promise$$internal$$fulfill(this.promise, this._result);\n } else {\n this.length = this.length || 0;\n this._enumerate();\n if (this._remaining === 0) {\n lib$es6$promise$$internal$$fulfill(this.promise, this._result);\n }\n }\n } else {\n lib$es6$promise$$internal$$reject(this.promise, this._validationError());\n }\n }\n\n lib$es6$promise$enumerator$$Enumerator.prototype._validationError = function() {\n return new Error('Array Methods must be provided an Array');\n };\n\n lib$es6$promise$enumerator$$Enumerator.prototype._enumerate = function() {\n var length = this.length;\n var input = this._input;\n\n for (var i = 0; this._state === lib$es6$promise$$internal$$PENDING && i < length; i++) {\n this._eachEntry(input[i], i);\n }\n };\n\n lib$es6$promise$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) {\n var c = this._instanceConstructor;\n var resolve = c.resolve;\n\n if (resolve === lib$es6$promise$promise$resolve$$default) {\n var then = lib$es6$promise$$internal$$getThen(entry);\n\n if (then === lib$es6$promise$then$$default &&\n entry._state !== lib$es6$promise$$internal$$PENDING) {\n this._settledAt(entry._state, i, entry._result);\n } else if (typeof then !== 'function') {\n this._remaining--;\n this._result[i] = entry;\n } else if (c === lib$es6$promise$promise$$default) {\n var promise = new c(lib$es6$promise$$internal$$noop);\n lib$es6$promise$$internal$$handleMaybeThenable(promise, entry, then);\n this._willSettleAt(promise, i);\n } else {\n this._willSettleAt(new c(function(resolve) { resolve(entry); }), i);\n }\n } else {\n this._willSettleAt(resolve(entry), i);\n }\n };\n\n lib$es6$promise$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) {\n var promise = this.promise;\n\n if (promise._state === lib$es6$promise$$internal$$PENDING) {\n this._remaining--;\n\n if (state === lib$es6$promise$$internal$$REJECTED) {\n lib$es6$promise$$internal$$reject(promise, value);\n } else {\n this._result[i] = value;\n }\n }\n\n if (this._remaining === 0) {\n lib$es6$promise$$internal$$fulfill(promise, this._result);\n }\n };\n\n lib$es6$promise$enumerator$$Enumerator.prototype._willSettleAt = function(promise, i) {\n var enumerator = this;\n\n lib$es6$promise$$internal$$subscribe(promise, undefined, function(value) {\n enumerator._settledAt(lib$es6$promise$$internal$$FULFILLED, i, value);\n }, function(reason) {\n enumerator._settledAt(lib$es6$promise$$internal$$REJECTED, i, reason);\n });\n };\n function lib$es6$promise$polyfill$$polyfill() {\n var local;\n\n if (typeof global !== 'undefined') {\n local = global;\n } else if (typeof self !== 'undefined') {\n local = self;\n } else {\n try {\n local = Function('return this')();\n } catch (e) {\n throw new Error('polyfill failed because global object is unavailable in this environment');\n }\n }\n\n var P = local.Promise;\n\n if (P && Object.prototype.toString.call(P.resolve()) === '[object Promise]' && !P.cast) {\n return;\n }\n\n local.Promise = lib$es6$promise$promise$$default;\n }\n var lib$es6$promise$polyfill$$default = lib$es6$promise$polyfill$$polyfill;\n\n var lib$es6$promise$umd$$ES6Promise = {\n 'Promise': lib$es6$promise$promise$$default,\n 'polyfill': lib$es6$promise$polyfill$$default\n };\n\n /* global define:true module:true window: true */\n if (typeof define === 'function' && define['amd']) {\n define(function() { return lib$es6$promise$umd$$ES6Promise; });\n } else if (typeof module !== 'undefined' && module['exports']) {\n module['exports'] = lib$es6$promise$umd$$ES6Promise;\n } else if (typeof this !== 'undefined') {\n this['ES6Promise'] = lib$es6$promise$umd$$ES6Promise;\n }\n\n lib$es6$promise$polyfill$$default();\n}).call(this);\n\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/es6-promise/dist/es6-promise.js\n ** module id = 423\n ** module chunks = 0\n **/"," /*!\n * https://github.com/paulmillr/es6-shim\n * @license es6-shim Copyright 2013-2016 by Paul Miller (http://paulmillr.com)\n * and contributors, MIT License\n * es6-shim: v0.35.0\n * see https://github.com/paulmillr/es6-shim/blob/0.35.0/LICENSE\n * Details and documentation:\n * https://github.com/paulmillr/es6-shim/\n */\n\n// UMD (Universal Module Definition)\n// see https://github.com/umdjs/umd/blob/master/returnExports.js\n(function (root, factory) {\n /*global define, module, exports */\n if (typeof define === 'function' && define.amd) {\n // AMD. Register as an anonymous module.\n define(factory);\n } else if (typeof exports === 'object') {\n // Node. Does not work with strict CommonJS, but\n // only CommonJS-like environments that support module.exports,\n // like Node.\n module.exports = factory();\n } else {\n // Browser globals (root is window)\n root.returnExports = factory();\n }\n}(this, function () {\n 'use strict';\n\n var _apply = Function.call.bind(Function.apply);\n var _call = Function.call.bind(Function.call);\n var isArray = Array.isArray;\n var keys = Object.keys;\n\n var not = function notThunker(func) {\n return function notThunk() { return !_apply(func, this, arguments); };\n };\n var throwsError = function (func) {\n try {\n func();\n return false;\n } catch (e) {\n return true;\n }\n };\n var valueOrFalseIfThrows = function valueOrFalseIfThrows(func) {\n try {\n return func();\n } catch (e) {\n return false;\n }\n };\n\n var isCallableWithoutNew = not(throwsError);\n var arePropertyDescriptorsSupported = function () {\n // if Object.defineProperty exists but throws, it's IE 8\n return !throwsError(function () { Object.defineProperty({}, 'x', { get: function () {} }); });\n };\n var supportsDescriptors = !!Object.defineProperty && arePropertyDescriptorsSupported();\n var functionsHaveNames = (function foo() {}).name === 'foo';\n\n var _forEach = Function.call.bind(Array.prototype.forEach);\n var _reduce = Function.call.bind(Array.prototype.reduce);\n var _filter = Function.call.bind(Array.prototype.filter);\n var _some = Function.call.bind(Array.prototype.some);\n\n var defineProperty = function (object, name, value, force) {\n if (!force && name in object) { return; }\n if (supportsDescriptors) {\n Object.defineProperty(object, name, {\n configurable: true,\n enumerable: false,\n writable: true,\n value: value\n });\n } else {\n object[name] = value;\n }\n };\n\n // Define configurable, writable and non-enumerable props\n // if they don’t exist.\n var defineProperties = function (object, map, forceOverride) {\n _forEach(keys(map), function (name) {\n var method = map[name];\n defineProperty(object, name, method, !!forceOverride);\n });\n };\n\n var _toString = Function.call.bind(Object.prototype.toString);\n var isCallable = typeof /abc/ === 'function' ? function IsCallableSlow(x) {\n // Some old browsers (IE, FF) say that typeof /abc/ === 'function'\n return typeof x === 'function' && _toString(x) === '[object Function]';\n } : function IsCallableFast(x) { return typeof x === 'function'; };\n\n var Value = {\n getter: function (object, name, getter) {\n if (!supportsDescriptors) {\n throw new TypeError('getters require true ES5 support');\n }\n Object.defineProperty(object, name, {\n configurable: true,\n enumerable: false,\n get: getter\n });\n },\n proxy: function (originalObject, key, targetObject) {\n if (!supportsDescriptors) {\n throw new TypeError('getters require true ES5 support');\n }\n var originalDescriptor = Object.getOwnPropertyDescriptor(originalObject, key);\n Object.defineProperty(targetObject, key, {\n configurable: originalDescriptor.configurable,\n enumerable: originalDescriptor.enumerable,\n get: function getKey() { return originalObject[key]; },\n set: function setKey(value) { originalObject[key] = value; }\n });\n },\n redefine: function (object, property, newValue) {\n if (supportsDescriptors) {\n var descriptor = Object.getOwnPropertyDescriptor(object, property);\n descriptor.value = newValue;\n Object.defineProperty(object, property, descriptor);\n } else {\n object[property] = newValue;\n }\n },\n defineByDescriptor: function (object, property, descriptor) {\n if (supportsDescriptors) {\n Object.defineProperty(object, property, descriptor);\n } else if ('value' in descriptor) {\n object[property] = descriptor.value;\n }\n },\n preserveToString: function (target, source) {\n if (source && isCallable(source.toString)) {\n defineProperty(target, 'toString', source.toString.bind(source), true);\n }\n }\n };\n\n // Simple shim for Object.create on ES3 browsers\n // (unlike real shim, no attempt to support `prototype === null`)\n var create = Object.create || function (prototype, properties) {\n var Prototype = function Prototype() {};\n Prototype.prototype = prototype;\n var object = new Prototype();\n if (typeof properties !== 'undefined') {\n keys(properties).forEach(function (key) {\n Value.defineByDescriptor(object, key, properties[key]);\n });\n }\n return object;\n };\n\n var supportsSubclassing = function (C, f) {\n if (!Object.setPrototypeOf) { return false; /* skip test on IE < 11 */ }\n return valueOrFalseIfThrows(function () {\n var Sub = function Subclass(arg) {\n var o = new C(arg);\n Object.setPrototypeOf(o, Subclass.prototype);\n return o;\n };\n Object.setPrototypeOf(Sub, C);\n Sub.prototype = create(C.prototype, {\n constructor: { value: Sub }\n });\n return f(Sub);\n });\n };\n\n var getGlobal = function () {\n /* global self, window, global */\n // the only reliable means to get the global object is\n // `Function('return this')()`\n // However, this causes CSP violations in Chrome apps.\n if (typeof self !== 'undefined') { return self; }\n if (typeof window !== 'undefined') { return window; }\n if (typeof global !== 'undefined') { return global; }\n throw new Error('unable to locate global object');\n };\n\n var globals = getGlobal();\n var globalIsFinite = globals.isFinite;\n var _indexOf = Function.call.bind(String.prototype.indexOf);\n var _arrayIndexOfApply = Function.apply.bind(Array.prototype.indexOf);\n var _concat = Function.call.bind(Array.prototype.concat);\n var _sort = Function.call.bind(Array.prototype.sort);\n var _strSlice = Function.call.bind(String.prototype.slice);\n var _push = Function.call.bind(Array.prototype.push);\n var _pushApply = Function.apply.bind(Array.prototype.push);\n var _shift = Function.call.bind(Array.prototype.shift);\n var _max = Math.max;\n var _min = Math.min;\n var _floor = Math.floor;\n var _abs = Math.abs;\n var _log = Math.log;\n var _sqrt = Math.sqrt;\n var _hasOwnProperty = Function.call.bind(Object.prototype.hasOwnProperty);\n var ArrayIterator; // make our implementation private\n var noop = function () {};\n\n var Symbol = globals.Symbol || {};\n var symbolSpecies = Symbol.species || '@@species';\n\n var numberIsNaN = Number.isNaN || function isNaN(value) {\n // NaN !== NaN, but they are identical.\n // NaNs are the only non-reflexive value, i.e., if x !== x,\n // then x is NaN.\n // isNaN is broken: it converts its argument to number, so\n // isNaN('foo') => true\n return value !== value;\n };\n var numberIsFinite = Number.isFinite || function isFinite(value) {\n return typeof value === 'number' && globalIsFinite(value);\n };\n\n // taken directly from https://github.com/ljharb/is-arguments/blob/master/index.js\n // can be replaced with require('is-arguments') if we ever use a build process instead\n var isStandardArguments = function isArguments(value) {\n return _toString(value) === '[object Arguments]';\n };\n var isLegacyArguments = function isArguments(value) {\n return value !== null &&\n typeof value === 'object' &&\n typeof value.length === 'number' &&\n value.length >= 0 &&\n _toString(value) !== '[object Array]' &&\n _toString(value.callee) === '[object Function]';\n };\n var isArguments = isStandardArguments(arguments) ? isStandardArguments : isLegacyArguments;\n\n var Type = {\n primitive: function (x) { return x === null || (typeof x !== 'function' && typeof x !== 'object'); },\n object: function (x) { return x !== null && typeof x === 'object'; },\n string: function (x) { return _toString(x) === '[object String]'; },\n regex: function (x) { return _toString(x) === '[object RegExp]'; },\n symbol: function (x) {\n return typeof globals.Symbol === 'function' && typeof x === 'symbol';\n }\n };\n\n var overrideNative = function overrideNative(object, property, replacement) {\n var original = object[property];\n defineProperty(object, property, replacement, true);\n Value.preserveToString(object[property], original);\n };\n\n var hasSymbols = typeof Symbol === 'function' && typeof Symbol['for'] === 'function' && Type.symbol(Symbol());\n\n // This is a private name in the es6 spec, equal to '[Symbol.iterator]'\n // we're going to use an arbitrary _-prefixed name to make our shims\n // work properly with each other, even though we don't have full Iterator\n // support. That is, `Array.from(map.keys())` will work, but we don't\n // pretend to export a \"real\" Iterator interface.\n var $iterator$ = Type.symbol(Symbol.iterator) ? Symbol.iterator : '_es6-shim iterator_';\n // Firefox ships a partial implementation using the name @@iterator.\n // https://bugzilla.mozilla.org/show_bug.cgi?id=907077#c14\n // So use that name if we detect it.\n if (globals.Set && typeof new globals.Set()['@@iterator'] === 'function') {\n $iterator$ = '@@iterator';\n }\n\n // Reflect\n if (!globals.Reflect) {\n defineProperty(globals, 'Reflect', {}, true);\n }\n var Reflect = globals.Reflect;\n\n var $String = String;\n\n var ES = {\n // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-call-f-v-args\n Call: function Call(F, V) {\n var args = arguments.length > 2 ? arguments[2] : [];\n if (!ES.IsCallable(F)) {\n throw new TypeError(F + ' is not a function');\n }\n return _apply(F, V, args);\n },\n\n RequireObjectCoercible: function (x, optMessage) {\n /* jshint eqnull:true */\n if (x == null) {\n throw new TypeError(optMessage || 'Cannot call method on ' + x);\n }\n return x;\n },\n\n // This might miss the \"(non-standard exotic and does not implement\n // [[Call]])\" case from\n // http://www.ecma-international.org/ecma-262/6.0/#sec-typeof-operator-runtime-semantics-evaluation\n // but we can't find any evidence these objects exist in practice.\n // If we find some in the future, you could test `Object(x) === x`,\n // which is reliable according to\n // http://www.ecma-international.org/ecma-262/6.0/#sec-toobject\n // but is not well optimized by runtimes and creates an object\n // whenever it returns false, and thus is very slow.\n TypeIsObject: function (x) {\n if (x === void 0 || x === null || x === true || x === false) {\n return false;\n }\n return typeof x === 'function' || typeof x === 'object';\n },\n\n ToObject: function (o, optMessage) {\n return Object(ES.RequireObjectCoercible(o, optMessage));\n },\n\n IsCallable: isCallable,\n\n IsConstructor: function (x) {\n // We can't tell callables from constructors in ES5\n return ES.IsCallable(x);\n },\n\n ToInt32: function (x) {\n return ES.ToNumber(x) >> 0;\n },\n\n ToUint32: function (x) {\n return ES.ToNumber(x) >>> 0;\n },\n\n ToNumber: function (value) {\n if (_toString(value) === '[object Symbol]') {\n throw new TypeError('Cannot convert a Symbol value to a number');\n }\n return +value;\n },\n\n ToInteger: function (value) {\n var number = ES.ToNumber(value);\n if (numberIsNaN(number)) { return 0; }\n if (number === 0 || !numberIsFinite(number)) { return number; }\n return (number > 0 ? 1 : -1) * _floor(_abs(number));\n },\n\n ToLength: function (value) {\n var len = ES.ToInteger(value);\n if (len <= 0) { return 0; } // includes converting -0 to +0\n if (len > Number.MAX_SAFE_INTEGER) { return Number.MAX_SAFE_INTEGER; }\n return len;\n },\n\n SameValue: function (a, b) {\n if (a === b) {\n // 0 === -0, but they are not identical.\n if (a === 0) { return 1 / a === 1 / b; }\n return true;\n }\n return numberIsNaN(a) && numberIsNaN(b);\n },\n\n SameValueZero: function (a, b) {\n // same as SameValue except for SameValueZero(+0, -0) == true\n return (a === b) || (numberIsNaN(a) && numberIsNaN(b));\n },\n\n IsIterable: function (o) {\n return ES.TypeIsObject(o) && (typeof o[$iterator$] !== 'undefined' || isArguments(o));\n },\n\n GetIterator: function (o) {\n if (isArguments(o)) {\n // special case support for `arguments`\n return new ArrayIterator(o, 'value');\n }\n var itFn = ES.GetMethod(o, $iterator$);\n if (!ES.IsCallable(itFn)) {\n // Better diagnostics if itFn is null or undefined\n throw new TypeError('value is not an iterable');\n }\n var it = ES.Call(itFn, o);\n if (!ES.TypeIsObject(it)) {\n throw new TypeError('bad iterator');\n }\n return it;\n },\n\n GetMethod: function (o, p) {\n var func = ES.ToObject(o)[p];\n if (func === void 0 || func === null) {\n return void 0;\n }\n if (!ES.IsCallable(func)) {\n throw new TypeError('Method not callable: ' + p);\n }\n return func;\n },\n\n IteratorComplete: function (iterResult) {\n return !!(iterResult.done);\n },\n\n IteratorClose: function (iterator, completionIsThrow) {\n var returnMethod = ES.GetMethod(iterator, 'return');\n if (returnMethod === void 0) {\n return;\n }\n var innerResult, innerException;\n try {\n innerResult = ES.Call(returnMethod, iterator);\n } catch (e) {\n innerException = e;\n }\n if (completionIsThrow) {\n return;\n }\n if (innerException) {\n throw innerException;\n }\n if (!ES.TypeIsObject(innerResult)) {\n throw new TypeError(\"Iterator's return method returned a non-object.\");\n }\n },\n\n IteratorNext: function (it) {\n var result = arguments.length > 1 ? it.next(arguments[1]) : it.next();\n if (!ES.TypeIsObject(result)) {\n throw new TypeError('bad iterator');\n }\n return result;\n },\n\n IteratorStep: function (it) {\n var result = ES.IteratorNext(it);\n var done = ES.IteratorComplete(result);\n return done ? false : result;\n },\n\n Construct: function (C, args, newTarget, isES6internal) {\n var target = typeof newTarget === 'undefined' ? C : newTarget;\n\n if (!isES6internal && Reflect.construct) {\n // Try to use Reflect.construct if available\n return Reflect.construct(C, args, target);\n }\n // OK, we have to fake it. This will only work if the\n // C.[[ConstructorKind]] == \"base\" -- but that's the only\n // kind we can make in ES5 code anyway.\n\n // OrdinaryCreateFromConstructor(target, \"%ObjectPrototype%\")\n var proto = target.prototype;\n if (!ES.TypeIsObject(proto)) {\n proto = Object.prototype;\n }\n var obj = create(proto);\n // Call the constructor.\n var result = ES.Call(C, obj, args);\n return ES.TypeIsObject(result) ? result : obj;\n },\n\n SpeciesConstructor: function (O, defaultConstructor) {\n var C = O.constructor;\n if (C === void 0) {\n return defaultConstructor;\n }\n if (!ES.TypeIsObject(C)) {\n throw new TypeError('Bad constructor');\n }\n var S = C[symbolSpecies];\n if (S === void 0 || S === null) {\n return defaultConstructor;\n }\n if (!ES.IsConstructor(S)) {\n throw new TypeError('Bad @@species');\n }\n return S;\n },\n\n CreateHTML: function (string, tag, attribute, value) {\n var S = ES.ToString(string);\n var p1 = '<' + tag;\n if (attribute !== '') {\n var V = ES.ToString(value);\n var escapedV = V.replace(/\"/g, '"');\n p1 += ' ' + attribute + '=\"' + escapedV + '\"';\n }\n var p2 = p1 + '>';\n var p3 = p2 + S;\n return p3 + '';\n },\n\n IsRegExp: function IsRegExp(argument) {\n if (!ES.TypeIsObject(argument)) {\n return false;\n }\n var isRegExp = argument[Symbol.match];\n if (typeof isRegExp !== 'undefined') {\n return !!isRegExp;\n }\n return Type.regex(argument);\n },\n\n ToString: function ToString(string) {\n return $String(string);\n }\n };\n\n // Well-known Symbol shims\n if (supportsDescriptors && hasSymbols) {\n var defineWellKnownSymbol = function defineWellKnownSymbol(name) {\n if (Type.symbol(Symbol[name])) {\n return Symbol[name];\n }\n var sym = Symbol['for']('Symbol.' + name);\n Object.defineProperty(Symbol, name, {\n configurable: false,\n enumerable: false,\n writable: false,\n value: sym\n });\n return sym;\n };\n if (!Type.symbol(Symbol.search)) {\n var symbolSearch = defineWellKnownSymbol('search');\n var originalSearch = String.prototype.search;\n defineProperty(RegExp.prototype, symbolSearch, function search(string) {\n return ES.Call(originalSearch, string, [this]);\n });\n var searchShim = function search(regexp) {\n var O = ES.RequireObjectCoercible(this);\n if (regexp !== null && typeof regexp !== 'undefined') {\n var searcher = ES.GetMethod(regexp, symbolSearch);\n if (typeof searcher !== 'undefined') {\n return ES.Call(searcher, regexp, [O]);\n }\n }\n return ES.Call(originalSearch, O, [ES.ToString(regexp)]);\n };\n overrideNative(String.prototype, 'search', searchShim);\n }\n if (!Type.symbol(Symbol.replace)) {\n var symbolReplace = defineWellKnownSymbol('replace');\n var originalReplace = String.prototype.replace;\n defineProperty(RegExp.prototype, symbolReplace, function replace(string, replaceValue) {\n return ES.Call(originalReplace, string, [this, replaceValue]);\n });\n var replaceShim = function replace(searchValue, replaceValue) {\n var O = ES.RequireObjectCoercible(this);\n if (searchValue !== null && typeof searchValue !== 'undefined') {\n var replacer = ES.GetMethod(searchValue, symbolReplace);\n if (typeof replacer !== 'undefined') {\n return ES.Call(replacer, searchValue, [O, replaceValue]);\n }\n }\n return ES.Call(originalReplace, O, [ES.ToString(searchValue), replaceValue]);\n };\n overrideNative(String.prototype, 'replace', replaceShim);\n }\n if (!Type.symbol(Symbol.split)) {\n var symbolSplit = defineWellKnownSymbol('split');\n var originalSplit = String.prototype.split;\n defineProperty(RegExp.prototype, symbolSplit, function split(string, limit) {\n return ES.Call(originalSplit, string, [this, limit]);\n });\n var splitShim = function split(separator, limit) {\n var O = ES.RequireObjectCoercible(this);\n if (separator !== null && typeof separator !== 'undefined') {\n var splitter = ES.GetMethod(separator, symbolSplit);\n if (typeof splitter !== 'undefined') {\n return ES.Call(splitter, separator, [O, limit]);\n }\n }\n return ES.Call(originalSplit, O, [ES.ToString(separator), limit]);\n };\n overrideNative(String.prototype, 'split', splitShim);\n }\n var symbolMatchExists = Type.symbol(Symbol.match);\n var stringMatchIgnoresSymbolMatch = symbolMatchExists && (function () {\n // Firefox 41, through Nightly 45 has Symbol.match, but String#match ignores it.\n // Firefox 40 and below have Symbol.match but String#match works fine.\n var o = {};\n o[Symbol.match] = function () { return 42; };\n return 'a'.match(o) !== 42;\n }());\n if (!symbolMatchExists || stringMatchIgnoresSymbolMatch) {\n var symbolMatch = defineWellKnownSymbol('match');\n\n var originalMatch = String.prototype.match;\n defineProperty(RegExp.prototype, symbolMatch, function match(string) {\n return ES.Call(originalMatch, string, [this]);\n });\n\n var matchShim = function match(regexp) {\n var O = ES.RequireObjectCoercible(this);\n if (regexp !== null && typeof regexp !== 'undefined') {\n var matcher = ES.GetMethod(regexp, symbolMatch);\n if (typeof matcher !== 'undefined') {\n return ES.Call(matcher, regexp, [O]);\n }\n }\n return ES.Call(originalMatch, O, [ES.ToString(regexp)]);\n };\n overrideNative(String.prototype, 'match', matchShim);\n }\n }\n\n var wrapConstructor = function wrapConstructor(original, replacement, keysToSkip) {\n Value.preserveToString(replacement, original);\n if (Object.setPrototypeOf) {\n // sets up proper prototype chain where possible\n Object.setPrototypeOf(original, replacement);\n }\n if (supportsDescriptors) {\n _forEach(Object.getOwnPropertyNames(original), function (key) {\n if (key in noop || keysToSkip[key]) { return; }\n Value.proxy(original, key, replacement);\n });\n } else {\n _forEach(Object.keys(original), function (key) {\n if (key in noop || keysToSkip[key]) { return; }\n replacement[key] = original[key];\n });\n }\n replacement.prototype = original.prototype;\n Value.redefine(original.prototype, 'constructor', replacement);\n };\n\n var defaultSpeciesGetter = function () { return this; };\n var addDefaultSpecies = function (C) {\n if (supportsDescriptors && !_hasOwnProperty(C, symbolSpecies)) {\n Value.getter(C, symbolSpecies, defaultSpeciesGetter);\n }\n };\n\n var addIterator = function (prototype, impl) {\n var implementation = impl || function iterator() { return this; };\n defineProperty(prototype, $iterator$, implementation);\n if (!prototype[$iterator$] && Type.symbol($iterator$)) {\n // implementations are buggy when $iterator$ is a Symbol\n prototype[$iterator$] = implementation;\n }\n };\n\n var createDataProperty = function createDataProperty(object, name, value) {\n if (supportsDescriptors) {\n Object.defineProperty(object, name, {\n configurable: true,\n enumerable: true,\n writable: true,\n value: value\n });\n } else {\n object[name] = value;\n }\n };\n var createDataPropertyOrThrow = function createDataPropertyOrThrow(object, name, value) {\n createDataProperty(object, name, value);\n if (!ES.SameValue(object[name], value)) {\n throw new TypeError('property is nonconfigurable');\n }\n };\n\n var emulateES6construct = function (o, defaultNewTarget, defaultProto, slots) {\n // This is an es5 approximation to es6 construct semantics. in es6,\n // 'new Foo' invokes Foo.[[Construct]] which (for almost all objects)\n // just sets the internal variable NewTarget (in es6 syntax `new.target`)\n // to Foo and then returns Foo().\n\n // Many ES6 object then have constructors of the form:\n // 1. If NewTarget is undefined, throw a TypeError exception\n // 2. Let xxx by OrdinaryCreateFromConstructor(NewTarget, yyy, zzz)\n\n // So we're going to emulate those first two steps.\n if (!ES.TypeIsObject(o)) {\n throw new TypeError('Constructor requires `new`: ' + defaultNewTarget.name);\n }\n var proto = defaultNewTarget.prototype;\n if (!ES.TypeIsObject(proto)) {\n proto = defaultProto;\n }\n var obj = create(proto);\n for (var name in slots) {\n if (_hasOwnProperty(slots, name)) {\n var value = slots[name];\n defineProperty(obj, name, value, true);\n }\n }\n return obj;\n };\n\n // Firefox 31 reports this function's length as 0\n // https://bugzilla.mozilla.org/show_bug.cgi?id=1062484\n if (String.fromCodePoint && String.fromCodePoint.length !== 1) {\n var originalFromCodePoint = String.fromCodePoint;\n overrideNative(String, 'fromCodePoint', function fromCodePoint(codePoints) { return ES.Call(originalFromCodePoint, this, arguments); });\n }\n\n var StringShims = {\n fromCodePoint: function fromCodePoint(codePoints) {\n var result = [];\n var next;\n for (var i = 0, length = arguments.length; i < length; i++) {\n next = Number(arguments[i]);\n if (!ES.SameValue(next, ES.ToInteger(next)) || next < 0 || next > 0x10FFFF) {\n throw new RangeError('Invalid code point ' + next);\n }\n\n if (next < 0x10000) {\n _push(result, String.fromCharCode(next));\n } else {\n next -= 0x10000;\n _push(result, String.fromCharCode((next >> 10) + 0xD800));\n _push(result, String.fromCharCode((next % 0x400) + 0xDC00));\n }\n }\n return result.join('');\n },\n\n raw: function raw(callSite) {\n var cooked = ES.ToObject(callSite, 'bad callSite');\n var rawString = ES.ToObject(cooked.raw, 'bad raw value');\n var len = rawString.length;\n var literalsegments = ES.ToLength(len);\n if (literalsegments <= 0) {\n return '';\n }\n\n var stringElements = [];\n var nextIndex = 0;\n var nextKey, next, nextSeg, nextSub;\n while (nextIndex < literalsegments) {\n nextKey = ES.ToString(nextIndex);\n nextSeg = ES.ToString(rawString[nextKey]);\n _push(stringElements, nextSeg);\n if (nextIndex + 1 >= literalsegments) {\n break;\n }\n next = nextIndex + 1 < arguments.length ? arguments[nextIndex + 1] : '';\n nextSub = ES.ToString(next);\n _push(stringElements, nextSub);\n nextIndex += 1;\n }\n return stringElements.join('');\n }\n };\n if (String.raw && String.raw({ raw: { 0: 'x', 1: 'y', length: 2 } }) !== 'xy') {\n // IE 11 TP has a broken String.raw implementation\n overrideNative(String, 'raw', StringShims.raw);\n }\n defineProperties(String, StringShims);\n\n // Fast repeat, uses the `Exponentiation by squaring` algorithm.\n // Perf: http://jsperf.com/string-repeat2/2\n var stringRepeat = function repeat(s, times) {\n if (times < 1) { return ''; }\n if (times % 2) { return repeat(s, times - 1) + s; }\n var half = repeat(s, times / 2);\n return half + half;\n };\n var stringMaxLength = Infinity;\n\n var StringPrototypeShims = {\n repeat: function repeat(times) {\n var thisStr = ES.ToString(ES.RequireObjectCoercible(this));\n var numTimes = ES.ToInteger(times);\n if (numTimes < 0 || numTimes >= stringMaxLength) {\n throw new RangeError('repeat count must be less than infinity and not overflow maximum string size');\n }\n return stringRepeat(thisStr, numTimes);\n },\n\n startsWith: function startsWith(searchString) {\n var S = ES.ToString(ES.RequireObjectCoercible(this));\n if (ES.IsRegExp(searchString)) {\n throw new TypeError('Cannot call method \"startsWith\" with a regex');\n }\n var searchStr = ES.ToString(searchString);\n var position;\n if (arguments.length > 1) {\n position = arguments[1];\n }\n var start = _max(ES.ToInteger(position), 0);\n return _strSlice(S, start, start + searchStr.length) === searchStr;\n },\n\n endsWith: function endsWith(searchString) {\n var S = ES.ToString(ES.RequireObjectCoercible(this));\n if (ES.IsRegExp(searchString)) {\n throw new TypeError('Cannot call method \"endsWith\" with a regex');\n }\n var searchStr = ES.ToString(searchString);\n var len = S.length;\n var endPosition;\n if (arguments.length > 1) {\n endPosition = arguments[1];\n }\n var pos = typeof endPosition === 'undefined' ? len : ES.ToInteger(endPosition);\n var end = _min(_max(pos, 0), len);\n return _strSlice(S, end - searchStr.length, end) === searchStr;\n },\n\n includes: function includes(searchString) {\n if (ES.IsRegExp(searchString)) {\n throw new TypeError('\"includes\" does not accept a RegExp');\n }\n var searchStr = ES.ToString(searchString);\n var position;\n if (arguments.length > 1) {\n position = arguments[1];\n }\n // Somehow this trick makes method 100% compat with the spec.\n return _indexOf(this, searchStr, position) !== -1;\n },\n\n codePointAt: function codePointAt(pos) {\n var thisStr = ES.ToString(ES.RequireObjectCoercible(this));\n var position = ES.ToInteger(pos);\n var length = thisStr.length;\n if (position >= 0 && position < length) {\n var first = thisStr.charCodeAt(position);\n var isEnd = (position + 1 === length);\n if (first < 0xD800 || first > 0xDBFF || isEnd) { return first; }\n var second = thisStr.charCodeAt(position + 1);\n if (second < 0xDC00 || second > 0xDFFF) { return first; }\n return ((first - 0xD800) * 1024) + (second - 0xDC00) + 0x10000;\n }\n }\n };\n if (String.prototype.includes && 'a'.includes('a', Infinity) !== false) {\n overrideNative(String.prototype, 'includes', StringPrototypeShims.includes);\n }\n\n if (String.prototype.startsWith && String.prototype.endsWith) {\n var startsWithRejectsRegex = throwsError(function () {\n /* throws if spec-compliant */\n '/a/'.startsWith(/a/);\n });\n var startsWithHandlesInfinity = valueOrFalseIfThrows(function () {\n return 'abc'.startsWith('a', Infinity) === false;\n });\n if (!startsWithRejectsRegex || !startsWithHandlesInfinity) {\n // Firefox (< 37?) and IE 11 TP have a noncompliant startsWith implementation\n overrideNative(String.prototype, 'startsWith', StringPrototypeShims.startsWith);\n overrideNative(String.prototype, 'endsWith', StringPrototypeShims.endsWith);\n }\n }\n if (hasSymbols) {\n var startsWithSupportsSymbolMatch = valueOrFalseIfThrows(function () {\n var re = /a/;\n re[Symbol.match] = false;\n return '/a/'.startsWith(re);\n });\n if (!startsWithSupportsSymbolMatch) {\n overrideNative(String.prototype, 'startsWith', StringPrototypeShims.startsWith);\n }\n var endsWithSupportsSymbolMatch = valueOrFalseIfThrows(function () {\n var re = /a/;\n re[Symbol.match] = false;\n return '/a/'.endsWith(re);\n });\n if (!endsWithSupportsSymbolMatch) {\n overrideNative(String.prototype, 'endsWith', StringPrototypeShims.endsWith);\n }\n var includesSupportsSymbolMatch = valueOrFalseIfThrows(function () {\n var re = /a/;\n re[Symbol.match] = false;\n return '/a/'.includes(re);\n });\n if (!includesSupportsSymbolMatch) {\n overrideNative(String.prototype, 'includes', StringPrototypeShims.includes);\n }\n }\n\n defineProperties(String.prototype, StringPrototypeShims);\n\n // whitespace from: http://es5.github.io/#x15.5.4.20\n // implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324\n var ws = [\n '\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003',\n '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028',\n '\\u2029\\uFEFF'\n ].join('');\n var trimRegexp = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g');\n var trimShim = function trim() {\n return ES.ToString(ES.RequireObjectCoercible(this)).replace(trimRegexp, '');\n };\n var nonWS = ['\\u0085', '\\u200b', '\\ufffe'].join('');\n var nonWSregex = new RegExp('[' + nonWS + ']', 'g');\n var isBadHexRegex = /^[\\-+]0x[0-9a-f]+$/i;\n var hasStringTrimBug = nonWS.trim().length !== nonWS.length;\n defineProperty(String.prototype, 'trim', trimShim, hasStringTrimBug);\n\n // see https://people.mozilla.org/~jorendorff/es6-draft.html#sec-string.prototype-@@iterator\n var StringIterator = function (s) {\n ES.RequireObjectCoercible(s);\n this._s = ES.ToString(s);\n this._i = 0;\n };\n StringIterator.prototype.next = function () {\n var s = this._s, i = this._i;\n if (typeof s === 'undefined' || i >= s.length) {\n this._s = void 0;\n return { value: void 0, done: true };\n }\n var first = s.charCodeAt(i), second, len;\n if (first < 0xD800 || first > 0xDBFF || (i + 1) === s.length) {\n len = 1;\n } else {\n second = s.charCodeAt(i + 1);\n len = (second < 0xDC00 || second > 0xDFFF) ? 1 : 2;\n }\n this._i = i + len;\n return { value: s.substr(i, len), done: false };\n };\n addIterator(StringIterator.prototype);\n addIterator(String.prototype, function () {\n return new StringIterator(this);\n });\n\n var ArrayShims = {\n from: function from(items) {\n var C = this;\n var mapFn;\n if (arguments.length > 1) {\n mapFn = arguments[1];\n }\n var mapping, T;\n if (typeof mapFn === 'undefined') {\n mapping = false;\n } else {\n if (!ES.IsCallable(mapFn)) {\n throw new TypeError('Array.from: when provided, the second argument must be a function');\n }\n if (arguments.length > 2) {\n T = arguments[2];\n }\n mapping = true;\n }\n\n // Note that that Arrays will use ArrayIterator:\n // https://bugs.ecmascript.org/show_bug.cgi?id=2416\n var usingIterator = typeof (isArguments(items) || ES.GetMethod(items, $iterator$)) !== 'undefined';\n\n var length, result, i;\n if (usingIterator) {\n result = ES.IsConstructor(C) ? Object(new C()) : [];\n var iterator = ES.GetIterator(items);\n var next, nextValue;\n\n i = 0;\n while (true) {\n next = ES.IteratorStep(iterator);\n if (next === false) {\n break;\n }\n nextValue = next.value;\n try {\n if (mapping) {\n nextValue = typeof T === 'undefined' ? mapFn(nextValue, i) : _call(mapFn, T, nextValue, i);\n }\n result[i] = nextValue;\n } catch (e) {\n ES.IteratorClose(iterator, true);\n throw e;\n }\n i += 1;\n }\n length = i;\n } else {\n var arrayLike = ES.ToObject(items);\n length = ES.ToLength(arrayLike.length);\n result = ES.IsConstructor(C) ? Object(new C(length)) : new Array(length);\n var value;\n for (i = 0; i < length; ++i) {\n value = arrayLike[i];\n if (mapping) {\n value = typeof T === 'undefined' ? mapFn(value, i) : _call(mapFn, T, value, i);\n }\n result[i] = value;\n }\n }\n\n result.length = length;\n return result;\n },\n\n of: function of() {\n var len = arguments.length;\n var C = this;\n var A = isArray(C) || !ES.IsCallable(C) ? new Array(len) : ES.Construct(C, [len]);\n for (var k = 0; k < len; ++k) {\n createDataPropertyOrThrow(A, k, arguments[k]);\n }\n A.length = len;\n return A;\n }\n };\n defineProperties(Array, ArrayShims);\n addDefaultSpecies(Array);\n\n // Given an argument x, it will return an IteratorResult object,\n // with value set to x and done to false.\n // Given no arguments, it will return an iterator completion object.\n var iteratorResult = function (x) {\n return { value: x, done: arguments.length === 0 };\n };\n\n // Our ArrayIterator is private; see\n // https://github.com/paulmillr/es6-shim/issues/252\n ArrayIterator = function (array, kind) {\n this.i = 0;\n this.array = array;\n this.kind = kind;\n };\n\n defineProperties(ArrayIterator.prototype, {\n next: function () {\n var i = this.i, array = this.array;\n if (!(this instanceof ArrayIterator)) {\n throw new TypeError('Not an ArrayIterator');\n }\n if (typeof array !== 'undefined') {\n var len = ES.ToLength(array.length);\n for (; i < len; i++) {\n var kind = this.kind;\n var retval;\n if (kind === 'key') {\n retval = i;\n } else if (kind === 'value') {\n retval = array[i];\n } else if (kind === 'entry') {\n retval = [i, array[i]];\n }\n this.i = i + 1;\n return { value: retval, done: false };\n }\n }\n this.array = void 0;\n return { value: void 0, done: true };\n }\n });\n addIterator(ArrayIterator.prototype);\n\n var orderKeys = function orderKeys(a, b) {\n var aNumeric = String(ES.ToInteger(a)) === a;\n var bNumeric = String(ES.ToInteger(b)) === b;\n if (aNumeric && bNumeric) {\n return b - a;\n } else if (aNumeric && !bNumeric) {\n return -1;\n } else if (!aNumeric && bNumeric) {\n return 1;\n } else {\n return a.localeCompare(b);\n }\n };\n var getAllKeys = function getAllKeys(object) {\n var ownKeys = [];\n var keys = [];\n\n for (var key in object) {\n _push(_hasOwnProperty(object, key) ? ownKeys : keys, key);\n }\n _sort(ownKeys, orderKeys);\n _sort(keys, orderKeys);\n\n return _concat(ownKeys, keys);\n };\n\n // note: this is positioned here because it depends on ArrayIterator\n var arrayOfSupportsSubclassing = Array.of === ArrayShims.of || (function () {\n // Detects a bug in Webkit nightly r181886\n var Foo = function Foo(len) { this.length = len; };\n Foo.prototype = [];\n var fooArr = Array.of.apply(Foo, [1, 2]);\n return fooArr instanceof Foo && fooArr.length === 2;\n }());\n if (!arrayOfSupportsSubclassing) {\n overrideNative(Array, 'of', ArrayShims.of);\n }\n\n var ArrayPrototypeShims = {\n copyWithin: function copyWithin(target, start) {\n var o = ES.ToObject(this);\n var len = ES.ToLength(o.length);\n var relativeTarget = ES.ToInteger(target);\n var relativeStart = ES.ToInteger(start);\n var to = relativeTarget < 0 ? _max(len + relativeTarget, 0) : _min(relativeTarget, len);\n var from = relativeStart < 0 ? _max(len + relativeStart, 0) : _min(relativeStart, len);\n var end;\n if (arguments.length > 2) {\n end = arguments[2];\n }\n var relativeEnd = typeof end === 'undefined' ? len : ES.ToInteger(end);\n var finalItem = relativeEnd < 0 ? _max(len + relativeEnd, 0) : _min(relativeEnd, len);\n var count = _min(finalItem - from, len - to);\n var direction = 1;\n if (from < to && to < (from + count)) {\n direction = -1;\n from += count - 1;\n to += count - 1;\n }\n while (count > 0) {\n if (from in o) {\n o[to] = o[from];\n } else {\n delete o[to];\n }\n from += direction;\n to += direction;\n count -= 1;\n }\n return o;\n },\n\n fill: function fill(value) {\n var start;\n if (arguments.length > 1) {\n start = arguments[1];\n }\n var end;\n if (arguments.length > 2) {\n end = arguments[2];\n }\n var O = ES.ToObject(this);\n var len = ES.ToLength(O.length);\n start = ES.ToInteger(typeof start === 'undefined' ? 0 : start);\n end = ES.ToInteger(typeof end === 'undefined' ? len : end);\n\n var relativeStart = start < 0 ? _max(len + start, 0) : _min(start, len);\n var relativeEnd = end < 0 ? len + end : end;\n\n for (var i = relativeStart; i < len && i < relativeEnd; ++i) {\n O[i] = value;\n }\n return O;\n },\n\n find: function find(predicate) {\n var list = ES.ToObject(this);\n var length = ES.ToLength(list.length);\n if (!ES.IsCallable(predicate)) {\n throw new TypeError('Array#find: predicate must be a function');\n }\n var thisArg = arguments.length > 1 ? arguments[1] : null;\n for (var i = 0, value; i < length; i++) {\n value = list[i];\n if (thisArg) {\n if (_call(predicate, thisArg, value, i, list)) { return value; }\n } else if (predicate(value, i, list)) {\n return value;\n }\n }\n },\n\n findIndex: function findIndex(predicate) {\n var list = ES.ToObject(this);\n var length = ES.ToLength(list.length);\n if (!ES.IsCallable(predicate)) {\n throw new TypeError('Array#findIndex: predicate must be a function');\n }\n var thisArg = arguments.length > 1 ? arguments[1] : null;\n for (var i = 0; i < length; i++) {\n if (thisArg) {\n if (_call(predicate, thisArg, list[i], i, list)) { return i; }\n } else if (predicate(list[i], i, list)) {\n return i;\n }\n }\n return -1;\n },\n\n keys: function keys() {\n return new ArrayIterator(this, 'key');\n },\n\n values: function values() {\n return new ArrayIterator(this, 'value');\n },\n\n entries: function entries() {\n return new ArrayIterator(this, 'entry');\n }\n };\n // Safari 7.1 defines Array#keys and Array#entries natively,\n // but the resulting ArrayIterator objects don't have a \"next\" method.\n if (Array.prototype.keys && !ES.IsCallable([1].keys().next)) {\n delete Array.prototype.keys;\n }\n if (Array.prototype.entries && !ES.IsCallable([1].entries().next)) {\n delete Array.prototype.entries;\n }\n\n // Chrome 38 defines Array#keys and Array#entries, and Array#@@iterator, but not Array#values\n if (Array.prototype.keys && Array.prototype.entries && !Array.prototype.values && Array.prototype[$iterator$]) {\n defineProperties(Array.prototype, {\n values: Array.prototype[$iterator$]\n });\n if (Type.symbol(Symbol.unscopables)) {\n Array.prototype[Symbol.unscopables].values = true;\n }\n }\n // Chrome 40 defines Array#values with the incorrect name, although Array#{keys,entries} have the correct name\n if (functionsHaveNames && Array.prototype.values && Array.prototype.values.name !== 'values') {\n var originalArrayPrototypeValues = Array.prototype.values;\n overrideNative(Array.prototype, 'values', function values() { return ES.Call(originalArrayPrototypeValues, this, arguments); });\n defineProperty(Array.prototype, $iterator$, Array.prototype.values, true);\n }\n defineProperties(Array.prototype, ArrayPrototypeShims);\n\n if (1 / [true].indexOf(true, -0) < 0) {\n // indexOf when given a position arg of -0 should return +0.\n // https://github.com/tc39/ecma262/pull/316\n defineProperty(Array.prototype, 'indexOf', function indexOf(searchElement) {\n var value = _arrayIndexOfApply(this, arguments);\n if (value === 0 && (1 / value) < 0) {\n return 0;\n }\n return value;\n }, true);\n }\n\n addIterator(Array.prototype, function () { return this.values(); });\n // Chrome defines keys/values/entries on Array, but doesn't give us\n // any way to identify its iterator. So add our own shimmed field.\n if (Object.getPrototypeOf) {\n addIterator(Object.getPrototypeOf([].values()));\n }\n\n // note: this is positioned here because it relies on Array#entries\n var arrayFromSwallowsNegativeLengths = (function () {\n // Detects a Firefox bug in v32\n // https://bugzilla.mozilla.org/show_bug.cgi?id=1063993\n return valueOrFalseIfThrows(function () { return Array.from({ length: -1 }).length === 0; });\n }());\n var arrayFromHandlesIterables = (function () {\n // Detects a bug in Webkit nightly r181886\n var arr = Array.from([0].entries());\n return arr.length === 1 && isArray(arr[0]) && arr[0][0] === 0 && arr[0][1] === 0;\n }());\n if (!arrayFromSwallowsNegativeLengths || !arrayFromHandlesIterables) {\n overrideNative(Array, 'from', ArrayShims.from);\n }\n var arrayFromHandlesUndefinedMapFunction = (function () {\n // Microsoft Edge v0.11 throws if the mapFn argument is *provided* but undefined,\n // but the spec doesn't care if it's provided or not - undefined doesn't throw.\n return valueOrFalseIfThrows(function () { return Array.from([0], void 0); });\n }());\n if (!arrayFromHandlesUndefinedMapFunction) {\n var origArrayFrom = Array.from;\n overrideNative(Array, 'from', function from(items) {\n if (arguments.length > 1 && typeof arguments[1] !== 'undefined') {\n return ES.Call(origArrayFrom, this, arguments);\n } else {\n return _call(origArrayFrom, this, items);\n }\n });\n }\n\n var int32sAsOne = -(Math.pow(2, 32) - 1);\n var toLengthsCorrectly = function (method, reversed) {\n var obj = { length: int32sAsOne };\n obj[reversed ? ((obj.length >>> 0) - 1) : 0] = true;\n return valueOrFalseIfThrows(function () {\n _call(method, obj, function () {\n // note: in nonconforming browsers, this will be called\n // -1 >>> 0 times, which is 4294967295, so the throw matters.\n throw new RangeError('should not reach here');\n }, []);\n return true;\n });\n };\n if (!toLengthsCorrectly(Array.prototype.forEach)) {\n var originalForEach = Array.prototype.forEach;\n overrideNative(Array.prototype, 'forEach', function forEach(callbackFn) {\n return ES.Call(originalForEach, this.length >= 0 ? this : [], arguments);\n }, true);\n }\n if (!toLengthsCorrectly(Array.prototype.map)) {\n var originalMap = Array.prototype.map;\n overrideNative(Array.prototype, 'map', function map(callbackFn) {\n return ES.Call(originalMap, this.length >= 0 ? this : [], arguments);\n }, true);\n }\n if (!toLengthsCorrectly(Array.prototype.filter)) {\n var originalFilter = Array.prototype.filter;\n overrideNative(Array.prototype, 'filter', function filter(callbackFn) {\n return ES.Call(originalFilter, this.length >= 0 ? this : [], arguments);\n }, true);\n }\n if (!toLengthsCorrectly(Array.prototype.some)) {\n var originalSome = Array.prototype.some;\n overrideNative(Array.prototype, 'some', function some(callbackFn) {\n return ES.Call(originalSome, this.length >= 0 ? this : [], arguments);\n }, true);\n }\n if (!toLengthsCorrectly(Array.prototype.every)) {\n var originalEvery = Array.prototype.every;\n overrideNative(Array.prototype, 'every', function every(callbackFn) {\n return ES.Call(originalEvery, this.length >= 0 ? this : [], arguments);\n }, true);\n }\n if (!toLengthsCorrectly(Array.prototype.reduce)) {\n var originalReduce = Array.prototype.reduce;\n overrideNative(Array.prototype, 'reduce', function reduce(callbackFn) {\n return ES.Call(originalReduce, this.length >= 0 ? this : [], arguments);\n }, true);\n }\n if (!toLengthsCorrectly(Array.prototype.reduceRight, true)) {\n var originalReduceRight = Array.prototype.reduceRight;\n overrideNative(Array.prototype, 'reduceRight', function reduceRight(callbackFn) {\n return ES.Call(originalReduceRight, this.length >= 0 ? this : [], arguments);\n }, true);\n }\n\n var lacksOctalSupport = Number('0o10') !== 8;\n var lacksBinarySupport = Number('0b10') !== 2;\n var trimsNonWhitespace = _some(nonWS, function (c) {\n return Number(c + 0 + c) === 0;\n });\n if (lacksOctalSupport || lacksBinarySupport || trimsNonWhitespace) {\n var OrigNumber = Number;\n var binaryRegex = /^0b[01]+$/i;\n var octalRegex = /^0o[0-7]+$/i;\n // Note that in IE 8, RegExp.prototype.test doesn't seem to exist: ie, \"test\" is an own property of regexes. wtf.\n var isBinary = binaryRegex.test.bind(binaryRegex);\n var isOctal = octalRegex.test.bind(octalRegex);\n var toPrimitive = function (O) { // need to replace this with `es-to-primitive/es6`\n var result;\n if (typeof O.valueOf === 'function') {\n result = O.valueOf();\n if (Type.primitive(result)) {\n return result;\n }\n }\n if (typeof O.toString === 'function') {\n result = O.toString();\n if (Type.primitive(result)) {\n return result;\n }\n }\n throw new TypeError('No default value');\n };\n var hasNonWS = nonWSregex.test.bind(nonWSregex);\n var isBadHex = isBadHexRegex.test.bind(isBadHexRegex);\n var NumberShim = (function () {\n // this is wrapped in an IIFE because of IE 6-8's wacky scoping issues with named function expressions.\n var NumberShim = function Number(value) {\n var primValue;\n if (arguments.length > 0) {\n primValue = Type.primitive(value) ? value : toPrimitive(value, 'number');\n } else {\n primValue = 0;\n }\n if (typeof primValue === 'string') {\n primValue = ES.Call(trimShim, primValue);\n if (isBinary(primValue)) {\n primValue = parseInt(_strSlice(primValue, 2), 2);\n } else if (isOctal(primValue)) {\n primValue = parseInt(_strSlice(primValue, 2), 8);\n } else if (hasNonWS(primValue) || isBadHex(primValue)) {\n primValue = NaN;\n }\n }\n var receiver = this;\n var valueOfSucceeds = valueOrFalseIfThrows(function () {\n OrigNumber.prototype.valueOf.call(receiver);\n return true;\n });\n if (receiver instanceof NumberShim && !valueOfSucceeds) {\n return new OrigNumber(primValue);\n }\n /* jshint newcap: false */\n return OrigNumber(primValue);\n /* jshint newcap: true */\n };\n return NumberShim;\n }());\n wrapConstructor(OrigNumber, NumberShim, {});\n // this is necessary for ES3 browsers, where these properties are non-enumerable.\n defineProperties(NumberShim, {\n NaN: OrigNumber.NaN,\n MAX_VALUE: OrigNumber.MAX_VALUE,\n MIN_VALUE: OrigNumber.MIN_VALUE,\n NEGATIVE_INFINITY: OrigNumber.NEGATIVE_INFINITY,\n POSITIVE_INFINITY: OrigNumber.POSITIVE_INFINITY\n });\n /* globals Number: true */\n /* eslint-disable no-undef */\n /* jshint -W020 */\n Number = NumberShim;\n Value.redefine(globals, 'Number', NumberShim);\n /* jshint +W020 */\n /* eslint-enable no-undef */\n /* globals Number: false */\n }\n\n var maxSafeInteger = Math.pow(2, 53) - 1;\n defineProperties(Number, {\n MAX_SAFE_INTEGER: maxSafeInteger,\n MIN_SAFE_INTEGER: -maxSafeInteger,\n EPSILON: 2.220446049250313e-16,\n\n parseInt: globals.parseInt,\n parseFloat: globals.parseFloat,\n\n isFinite: numberIsFinite,\n\n isInteger: function isInteger(value) {\n return numberIsFinite(value) && ES.ToInteger(value) === value;\n },\n\n isSafeInteger: function isSafeInteger(value) {\n return Number.isInteger(value) && _abs(value) <= Number.MAX_SAFE_INTEGER;\n },\n\n isNaN: numberIsNaN\n });\n // Firefox 37 has a conforming Number.parseInt, but it's not === to the global parseInt (fixed in v40)\n defineProperty(Number, 'parseInt', globals.parseInt, Number.parseInt !== globals.parseInt);\n\n // Work around bugs in Array#find and Array#findIndex -- early\n // implementations skipped holes in sparse arrays. (Note that the\n // implementations of find/findIndex indirectly use shimmed\n // methods of Number, so this test has to happen down here.)\n /*jshint elision: true */\n /* eslint-disable no-sparse-arrays */\n if (![, 1].find(function (item, idx) { return idx === 0; })) {\n overrideNative(Array.prototype, 'find', ArrayPrototypeShims.find);\n }\n if ([, 1].findIndex(function (item, idx) { return idx === 0; }) !== 0) {\n overrideNative(Array.prototype, 'findIndex', ArrayPrototypeShims.findIndex);\n }\n /* eslint-enable no-sparse-arrays */\n /*jshint elision: false */\n\n var isEnumerableOn = Function.bind.call(Function.bind, Object.prototype.propertyIsEnumerable);\n var ensureEnumerable = function ensureEnumerable(obj, prop) {\n if (supportsDescriptors && isEnumerableOn(obj, prop)) {\n Object.defineProperty(obj, prop, { enumerable: false });\n }\n };\n var sliceArgs = function sliceArgs() {\n // per https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments\n // and https://gist.github.com/WebReflection/4327762cb87a8c634a29\n var initial = Number(this);\n var len = arguments.length;\n var desiredArgCount = len - initial;\n var args = new Array(desiredArgCount < 0 ? 0 : desiredArgCount);\n for (var i = initial; i < len; ++i) {\n args[i - initial] = arguments[i];\n }\n return args;\n };\n var assignTo = function assignTo(source) {\n return function assignToSource(target, key) {\n target[key] = source[key];\n return target;\n };\n };\n var assignReducer = function (target, source) {\n var sourceKeys = keys(Object(source));\n var symbols;\n if (ES.IsCallable(Object.getOwnPropertySymbols)) {\n symbols = _filter(Object.getOwnPropertySymbols(Object(source)), isEnumerableOn(source));\n }\n return _reduce(_concat(sourceKeys, symbols || []), assignTo(source), target);\n };\n\n var ObjectShims = {\n // 19.1.3.1\n assign: function (target, source) {\n var to = ES.ToObject(target, 'Cannot convert undefined or null to object');\n return _reduce(ES.Call(sliceArgs, 1, arguments), assignReducer, to);\n },\n\n // Added in WebKit in https://bugs.webkit.org/show_bug.cgi?id=143865\n is: function is(a, b) {\n return ES.SameValue(a, b);\n }\n };\n var assignHasPendingExceptions = Object.assign && Object.preventExtensions && (function () {\n // Firefox 37 still has \"pending exception\" logic in its Object.assign implementation,\n // which is 72% slower than our shim, and Firefox 40's native implementation.\n var thrower = Object.preventExtensions({ 1: 2 });\n try {\n Object.assign(thrower, 'xy');\n } catch (e) {\n return thrower[1] === 'y';\n }\n }());\n if (assignHasPendingExceptions) {\n overrideNative(Object, 'assign', ObjectShims.assign);\n }\n defineProperties(Object, ObjectShims);\n\n if (supportsDescriptors) {\n var ES5ObjectShims = {\n // 19.1.3.9\n // shim from https://gist.github.com/WebReflection/5593554\n setPrototypeOf: (function (Object, magic) {\n var set;\n\n var checkArgs = function (O, proto) {\n if (!ES.TypeIsObject(O)) {\n throw new TypeError('cannot set prototype on a non-object');\n }\n if (!(proto === null || ES.TypeIsObject(proto))) {\n throw new TypeError('can only set prototype to an object or null' + proto);\n }\n };\n\n var setPrototypeOf = function (O, proto) {\n checkArgs(O, proto);\n _call(set, O, proto);\n return O;\n };\n\n try {\n // this works already in Firefox and Safari\n set = Object.getOwnPropertyDescriptor(Object.prototype, magic).set;\n _call(set, {}, null);\n } catch (e) {\n if (Object.prototype !== {}[magic]) {\n // IE < 11 cannot be shimmed\n return;\n }\n // probably Chrome or some old Mobile stock browser\n set = function (proto) {\n this[magic] = proto;\n };\n // please note that this will **not** work\n // in those browsers that do not inherit\n // __proto__ by mistake from Object.prototype\n // in these cases we should probably throw an error\n // or at least be informed about the issue\n setPrototypeOf.polyfill = setPrototypeOf(\n setPrototypeOf({}, null),\n Object.prototype\n ) instanceof Object;\n // setPrototypeOf.polyfill === true means it works as meant\n // setPrototypeOf.polyfill === false means it's not 100% reliable\n // setPrototypeOf.polyfill === undefined\n // or\n // setPrototypeOf.polyfill == null means it's not a polyfill\n // which means it works as expected\n // we can even delete Object.prototype.__proto__;\n }\n return setPrototypeOf;\n }(Object, '__proto__'))\n };\n\n defineProperties(Object, ES5ObjectShims);\n }\n\n // Workaround bug in Opera 12 where setPrototypeOf(x, null) doesn't work,\n // but Object.create(null) does.\n if (Object.setPrototypeOf && Object.getPrototypeOf &&\n Object.getPrototypeOf(Object.setPrototypeOf({}, null)) !== null &&\n Object.getPrototypeOf(Object.create(null)) === null) {\n (function () {\n var FAKENULL = Object.create(null);\n var gpo = Object.getPrototypeOf, spo = Object.setPrototypeOf;\n Object.getPrototypeOf = function (o) {\n var result = gpo(o);\n return result === FAKENULL ? null : result;\n };\n Object.setPrototypeOf = function (o, p) {\n var proto = p === null ? FAKENULL : p;\n return spo(o, proto);\n };\n Object.setPrototypeOf.polyfill = false;\n }());\n }\n\n var objectKeysAcceptsPrimitives = !throwsError(function () { Object.keys('foo'); });\n if (!objectKeysAcceptsPrimitives) {\n var originalObjectKeys = Object.keys;\n overrideNative(Object, 'keys', function keys(value) {\n return originalObjectKeys(ES.ToObject(value));\n });\n keys = Object.keys;\n }\n var objectKeysRejectsRegex = throwsError(function () { Object.keys(/a/g); });\n if (objectKeysRejectsRegex) {\n var regexRejectingObjectKeys = Object.keys;\n overrideNative(Object, 'keys', function keys(value) {\n if (Type.regex(value)) {\n var regexKeys = [];\n for (var k in value) {\n if (_hasOwnProperty(value, k)) {\n _push(regexKeys, k);\n }\n }\n return regexKeys;\n }\n return regexRejectingObjectKeys(value);\n });\n keys = Object.keys;\n }\n\n if (Object.getOwnPropertyNames) {\n var objectGOPNAcceptsPrimitives = !throwsError(function () { Object.getOwnPropertyNames('foo'); });\n if (!objectGOPNAcceptsPrimitives) {\n var cachedWindowNames = typeof window === 'object' ? Object.getOwnPropertyNames(window) : [];\n var originalObjectGetOwnPropertyNames = Object.getOwnPropertyNames;\n overrideNative(Object, 'getOwnPropertyNames', function getOwnPropertyNames(value) {\n var val = ES.ToObject(value);\n if (_toString(val) === '[object Window]') {\n try {\n return originalObjectGetOwnPropertyNames(val);\n } catch (e) {\n // IE bug where layout engine calls userland gOPN for cross-domain `window` objects\n return _concat([], cachedWindowNames);\n }\n }\n return originalObjectGetOwnPropertyNames(val);\n });\n }\n }\n if (Object.getOwnPropertyDescriptor) {\n var objectGOPDAcceptsPrimitives = !throwsError(function () { Object.getOwnPropertyDescriptor('foo', 'bar'); });\n if (!objectGOPDAcceptsPrimitives) {\n var originalObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n overrideNative(Object, 'getOwnPropertyDescriptor', function getOwnPropertyDescriptor(value, property) {\n return originalObjectGetOwnPropertyDescriptor(ES.ToObject(value), property);\n });\n }\n }\n if (Object.seal) {\n var objectSealAcceptsPrimitives = !throwsError(function () { Object.seal('foo'); });\n if (!objectSealAcceptsPrimitives) {\n var originalObjectSeal = Object.seal;\n overrideNative(Object, 'seal', function seal(value) {\n if (!Type.object(value)) { return value; }\n return originalObjectSeal(value);\n });\n }\n }\n if (Object.isSealed) {\n var objectIsSealedAcceptsPrimitives = !throwsError(function () { Object.isSealed('foo'); });\n if (!objectIsSealedAcceptsPrimitives) {\n var originalObjectIsSealed = Object.isSealed;\n overrideNative(Object, 'isSealed', function isSealed(value) {\n if (!Type.object(value)) { return true; }\n return originalObjectIsSealed(value);\n });\n }\n }\n if (Object.freeze) {\n var objectFreezeAcceptsPrimitives = !throwsError(function () { Object.freeze('foo'); });\n if (!objectFreezeAcceptsPrimitives) {\n var originalObjectFreeze = Object.freeze;\n overrideNative(Object, 'freeze', function freeze(value) {\n if (!Type.object(value)) { return value; }\n return originalObjectFreeze(value);\n });\n }\n }\n if (Object.isFrozen) {\n var objectIsFrozenAcceptsPrimitives = !throwsError(function () { Object.isFrozen('foo'); });\n if (!objectIsFrozenAcceptsPrimitives) {\n var originalObjectIsFrozen = Object.isFrozen;\n overrideNative(Object, 'isFrozen', function isFrozen(value) {\n if (!Type.object(value)) { return true; }\n return originalObjectIsFrozen(value);\n });\n }\n }\n if (Object.preventExtensions) {\n var objectPreventExtensionsAcceptsPrimitives = !throwsError(function () { Object.preventExtensions('foo'); });\n if (!objectPreventExtensionsAcceptsPrimitives) {\n var originalObjectPreventExtensions = Object.preventExtensions;\n overrideNative(Object, 'preventExtensions', function preventExtensions(value) {\n if (!Type.object(value)) { return value; }\n return originalObjectPreventExtensions(value);\n });\n }\n }\n if (Object.isExtensible) {\n var objectIsExtensibleAcceptsPrimitives = !throwsError(function () { Object.isExtensible('foo'); });\n if (!objectIsExtensibleAcceptsPrimitives) {\n var originalObjectIsExtensible = Object.isExtensible;\n overrideNative(Object, 'isExtensible', function isExtensible(value) {\n if (!Type.object(value)) { return false; }\n return originalObjectIsExtensible(value);\n });\n }\n }\n if (Object.getPrototypeOf) {\n var objectGetProtoAcceptsPrimitives = !throwsError(function () { Object.getPrototypeOf('foo'); });\n if (!objectGetProtoAcceptsPrimitives) {\n var originalGetProto = Object.getPrototypeOf;\n overrideNative(Object, 'getPrototypeOf', function getPrototypeOf(value) {\n return originalGetProto(ES.ToObject(value));\n });\n }\n }\n\n var hasFlags = supportsDescriptors && (function () {\n var desc = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags');\n return desc && ES.IsCallable(desc.get);\n }());\n if (supportsDescriptors && !hasFlags) {\n var regExpFlagsGetter = function flags() {\n if (!ES.TypeIsObject(this)) {\n throw new TypeError('Method called on incompatible type: must be an object.');\n }\n var result = '';\n if (this.global) {\n result += 'g';\n }\n if (this.ignoreCase) {\n result += 'i';\n }\n if (this.multiline) {\n result += 'm';\n }\n if (this.unicode) {\n result += 'u';\n }\n if (this.sticky) {\n result += 'y';\n }\n return result;\n };\n\n Value.getter(RegExp.prototype, 'flags', regExpFlagsGetter);\n }\n\n var regExpSupportsFlagsWithRegex = supportsDescriptors && valueOrFalseIfThrows(function () {\n return String(new RegExp(/a/g, 'i')) === '/a/i';\n });\n var regExpNeedsToSupportSymbolMatch = hasSymbols && supportsDescriptors && (function () {\n // Edge 0.12 supports flags fully, but does not support Symbol.match\n var regex = /./;\n regex[Symbol.match] = false;\n return RegExp(regex) === regex;\n }());\n\n var regexToStringIsGeneric = valueOrFalseIfThrows(function () {\n return RegExp.prototype.toString.call({ source: 'abc' }) === '/abc/';\n });\n var regexToStringSupportsGenericFlags = regexToStringIsGeneric && valueOrFalseIfThrows(function () {\n return RegExp.prototype.toString.call({ source: 'a', flags: 'b' }) === '/a/b';\n });\n if (!regexToStringIsGeneric || !regexToStringSupportsGenericFlags) {\n var origRegExpToString = RegExp.prototype.toString;\n defineProperty(RegExp.prototype, 'toString', function toString() {\n var R = ES.RequireObjectCoercible(this);\n if (Type.regex(R)) {\n return _call(origRegExpToString, R);\n }\n var pattern = $String(R.source);\n var flags = $String(R.flags);\n return '/' + pattern + '/' + flags;\n }, true);\n Value.preserveToString(RegExp.prototype.toString, origRegExpToString);\n }\n\n if (supportsDescriptors && (!regExpSupportsFlagsWithRegex || regExpNeedsToSupportSymbolMatch)) {\n var flagsGetter = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags').get;\n var sourceDesc = Object.getOwnPropertyDescriptor(RegExp.prototype, 'source') || {};\n var legacySourceGetter = function () { return this.source; }; // prior to it being a getter, it's own + nonconfigurable\n var sourceGetter = ES.IsCallable(sourceDesc.get) ? sourceDesc.get : legacySourceGetter;\n\n var OrigRegExp = RegExp;\n var RegExpShim = (function () {\n return function RegExp(pattern, flags) {\n var patternIsRegExp = ES.IsRegExp(pattern);\n var calledWithNew = this instanceof RegExp;\n if (!calledWithNew && patternIsRegExp && typeof flags === 'undefined' && pattern.constructor === RegExp) {\n return pattern;\n }\n\n var P = pattern;\n var F = flags;\n if (Type.regex(pattern)) {\n P = ES.Call(sourceGetter, pattern);\n F = typeof flags === 'undefined' ? ES.Call(flagsGetter, pattern) : flags;\n return new RegExp(P, F);\n } else if (patternIsRegExp) {\n P = pattern.source;\n F = typeof flags === 'undefined' ? pattern.flags : flags;\n }\n return new OrigRegExp(pattern, flags);\n };\n }());\n wrapConstructor(OrigRegExp, RegExpShim, {\n $input: true // Chrome < v39 & Opera < 26 have a nonstandard \"$input\" property\n });\n /* globals RegExp: true */\n /* eslint-disable no-undef */\n /* jshint -W020 */\n RegExp = RegExpShim;\n Value.redefine(globals, 'RegExp', RegExpShim);\n /* jshint +W020 */\n /* eslint-enable no-undef */\n /* globals RegExp: false */\n }\n\n if (supportsDescriptors) {\n var regexGlobals = {\n input: '$_',\n lastMatch: '$&',\n lastParen: '$+',\n leftContext: '$`',\n rightContext: '$\\''\n };\n _forEach(keys(regexGlobals), function (prop) {\n if (prop in RegExp && !(regexGlobals[prop] in RegExp)) {\n Value.getter(RegExp, regexGlobals[prop], function get() {\n return RegExp[prop];\n });\n }\n });\n }\n addDefaultSpecies(RegExp);\n\n var inverseEpsilon = 1 / Number.EPSILON;\n var roundTiesToEven = function roundTiesToEven(n) {\n // Even though this reduces down to `return n`, it takes advantage of built-in rounding.\n return (n + inverseEpsilon) - inverseEpsilon;\n };\n var BINARY_32_EPSILON = Math.pow(2, -23);\n var BINARY_32_MAX_VALUE = Math.pow(2, 127) * (2 - BINARY_32_EPSILON);\n var BINARY_32_MIN_VALUE = Math.pow(2, -126);\n var numberCLZ = Number.prototype.clz;\n delete Number.prototype.clz; // Safari 8 has Number#clz\n\n var MathShims = {\n acosh: function acosh(value) {\n var x = Number(value);\n if (Number.isNaN(x) || value < 1) { return NaN; }\n if (x === 1) { return 0; }\n if (x === Infinity) { return x; }\n return _log(x / Math.E + _sqrt(x + 1) * _sqrt(x - 1) / Math.E) + 1;\n },\n\n asinh: function asinh(value) {\n var x = Number(value);\n if (x === 0 || !globalIsFinite(x)) {\n return x;\n }\n return x < 0 ? -Math.asinh(-x) : _log(x + _sqrt(x * x + 1));\n },\n\n atanh: function atanh(value) {\n var x = Number(value);\n if (Number.isNaN(x) || x < -1 || x > 1) {\n return NaN;\n }\n if (x === -1) { return -Infinity; }\n if (x === 1) { return Infinity; }\n if (x === 0) { return x; }\n return 0.5 * _log((1 + x) / (1 - x));\n },\n\n cbrt: function cbrt(value) {\n var x = Number(value);\n if (x === 0) { return x; }\n var negate = x < 0, result;\n if (negate) { x = -x; }\n if (x === Infinity) {\n result = Infinity;\n } else {\n result = Math.exp(_log(x) / 3);\n // from http://en.wikipedia.org/wiki/Cube_root#Numerical_methods\n result = (x / (result * result) + (2 * result)) / 3;\n }\n return negate ? -result : result;\n },\n\n clz32: function clz32(value) {\n // See https://bugs.ecmascript.org/show_bug.cgi?id=2465\n var x = Number(value);\n var number = ES.ToUint32(x);\n if (number === 0) {\n return 32;\n }\n return numberCLZ ? ES.Call(numberCLZ, number) : 31 - _floor(_log(number + 0.5) * Math.LOG2E);\n },\n\n cosh: function cosh(value) {\n var x = Number(value);\n if (x === 0) { return 1; } // +0 or -0\n if (Number.isNaN(x)) { return NaN; }\n if (!globalIsFinite(x)) { return Infinity; }\n if (x < 0) { x = -x; }\n if (x > 21) { return Math.exp(x) / 2; }\n return (Math.exp(x) + Math.exp(-x)) / 2;\n },\n\n expm1: function expm1(value) {\n var x = Number(value);\n if (x === -Infinity) { return -1; }\n if (!globalIsFinite(x) || x === 0) { return x; }\n if (_abs(x) > 0.5) {\n return Math.exp(x) - 1;\n }\n // A more precise approximation using Taylor series expansion\n // from https://github.com/paulmillr/es6-shim/issues/314#issuecomment-70293986\n var t = x;\n var sum = 0;\n var n = 1;\n while (sum + t !== sum) {\n sum += t;\n n += 1;\n t *= x / n;\n }\n return sum;\n },\n\n hypot: function hypot(x, y) {\n var result = 0;\n var largest = 0;\n for (var i = 0; i < arguments.length; ++i) {\n var value = _abs(Number(arguments[i]));\n if (largest < value) {\n result *= (largest / value) * (largest / value);\n result += 1;\n largest = value;\n } else {\n result += (value > 0 ? (value / largest) * (value / largest) : value);\n }\n }\n return largest === Infinity ? Infinity : largest * _sqrt(result);\n },\n\n log2: function log2(value) {\n return _log(value) * Math.LOG2E;\n },\n\n log10: function log10(value) {\n return _log(value) * Math.LOG10E;\n },\n\n log1p: function log1p(value) {\n var x = Number(value);\n if (x < -1 || Number.isNaN(x)) { return NaN; }\n if (x === 0 || x === Infinity) { return x; }\n if (x === -1) { return -Infinity; }\n\n return (1 + x) - 1 === 0 ? x : x * (_log(1 + x) / ((1 + x) - 1));\n },\n\n sign: function sign(value) {\n var number = Number(value);\n if (number === 0) { return number; }\n if (Number.isNaN(number)) { return number; }\n return number < 0 ? -1 : 1;\n },\n\n sinh: function sinh(value) {\n var x = Number(value);\n if (!globalIsFinite(x) || x === 0) { return x; }\n\n if (_abs(x) < 1) {\n return (Math.expm1(x) - Math.expm1(-x)) / 2;\n }\n return (Math.exp(x - 1) - Math.exp(-x - 1)) * Math.E / 2;\n },\n\n tanh: function tanh(value) {\n var x = Number(value);\n if (Number.isNaN(x) || x === 0) { return x; }\n // can exit early at +-20 as JS loses precision for true value at this integer\n if (x >= 20) { return 1; }\n if (x <= -20) { return -1; }\n var a = Math.expm1(x);\n var b = Math.expm1(-x);\n if (a === Infinity) { return 1; }\n if (b === Infinity) { return -1; }\n return (a - b) / (Math.exp(x) + Math.exp(-x));\n },\n\n trunc: function trunc(value) {\n var x = Number(value);\n return x < 0 ? -_floor(-x) : _floor(x);\n },\n\n imul: function imul(x, y) {\n // taken from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul\n var a = ES.ToUint32(x);\n var b = ES.ToUint32(y);\n var ah = (a >>> 16) & 0xffff;\n var al = a & 0xffff;\n var bh = (b >>> 16) & 0xffff;\n var bl = b & 0xffff;\n // the shift by 0 fixes the sign on the high part\n // the final |0 converts the unsigned value into a signed value\n return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0) | 0);\n },\n\n fround: function fround(x) {\n var v = Number(x);\n if (v === 0 || v === Infinity || v === -Infinity || numberIsNaN(v)) {\n return v;\n }\n var sign = Math.sign(v);\n var abs = _abs(v);\n if (abs < BINARY_32_MIN_VALUE) {\n return sign * roundTiesToEven(abs / BINARY_32_MIN_VALUE / BINARY_32_EPSILON) * BINARY_32_MIN_VALUE * BINARY_32_EPSILON;\n }\n // Veltkamp's splitting (?)\n var a = (1 + BINARY_32_EPSILON / Number.EPSILON) * abs;\n var result = a - (a - abs);\n if (result > BINARY_32_MAX_VALUE || numberIsNaN(result)) {\n return sign * Infinity;\n }\n return sign * result;\n }\n };\n defineProperties(Math, MathShims);\n // IE 11 TP has an imprecise log1p: reports Math.log1p(-1e-17) as 0\n defineProperty(Math, 'log1p', MathShims.log1p, Math.log1p(-1e-17) !== -1e-17);\n // IE 11 TP has an imprecise asinh: reports Math.asinh(-1e7) as not exactly equal to -Math.asinh(1e7)\n defineProperty(Math, 'asinh', MathShims.asinh, Math.asinh(-1e7) !== -Math.asinh(1e7));\n // Chrome 40 has an imprecise Math.tanh with very small numbers\n defineProperty(Math, 'tanh', MathShims.tanh, Math.tanh(-2e-17) !== -2e-17);\n // Chrome 40 loses Math.acosh precision with high numbers\n defineProperty(Math, 'acosh', MathShims.acosh, Math.acosh(Number.MAX_VALUE) === Infinity);\n // Firefox 38 on Windows\n defineProperty(Math, 'cbrt', MathShims.cbrt, Math.abs(1 - Math.cbrt(1e-300) / 1e-100) / Number.EPSILON > 8);\n // node 0.11 has an imprecise Math.sinh with very small numbers\n defineProperty(Math, 'sinh', MathShims.sinh, Math.sinh(-2e-17) !== -2e-17);\n // FF 35 on Linux reports 22025.465794806725 for Math.expm1(10)\n var expm1OfTen = Math.expm1(10);\n defineProperty(Math, 'expm1', MathShims.expm1, expm1OfTen > 22025.465794806719 || expm1OfTen < 22025.4657948067165168);\n\n var origMathRound = Math.round;\n // breaks in e.g. Safari 8, Internet Explorer 11, Opera 12\n var roundHandlesBoundaryConditions = Math.round(0.5 - Number.EPSILON / 4) === 0 && Math.round(-0.5 + Number.EPSILON / 3.99) === 1;\n\n // When engines use Math.floor(x + 0.5) internally, Math.round can be buggy for large integers.\n // This behavior should be governed by \"round to nearest, ties to even mode\"\n // see https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ecmascript-language-types-number-type\n // These are the boundary cases where it breaks.\n var smallestPositiveNumberWhereRoundBreaks = inverseEpsilon + 1;\n var largestPositiveNumberWhereRoundBreaks = 2 * inverseEpsilon - 1;\n var roundDoesNotIncreaseIntegers = [smallestPositiveNumberWhereRoundBreaks, largestPositiveNumberWhereRoundBreaks].every(function (num) {\n return Math.round(num) === num;\n });\n defineProperty(Math, 'round', function round(x) {\n var floor = _floor(x);\n var ceil = floor === -1 ? -0 : floor + 1;\n return x - floor < 0.5 ? floor : ceil;\n }, !roundHandlesBoundaryConditions || !roundDoesNotIncreaseIntegers);\n Value.preserveToString(Math.round, origMathRound);\n\n var origImul = Math.imul;\n if (Math.imul(0xffffffff, 5) !== -5) {\n // Safari 6.1, at least, reports \"0\" for this value\n Math.imul = MathShims.imul;\n Value.preserveToString(Math.imul, origImul);\n }\n if (Math.imul.length !== 2) {\n // Safari 8.0.4 has a length of 1\n // fixed in https://bugs.webkit.org/show_bug.cgi?id=143658\n overrideNative(Math, 'imul', function imul(x, y) {\n return ES.Call(origImul, Math, arguments);\n });\n }\n\n // Promises\n // Simplest possible implementation; use a 3rd-party library if you\n // want the best possible speed and/or long stack traces.\n var PromiseShim = (function () {\n var setTimeout = globals.setTimeout;\n // some environments don't have setTimeout - no way to shim here.\n if (typeof setTimeout !== 'function' && typeof setTimeout !== 'object') { return; }\n\n ES.IsPromise = function (promise) {\n if (!ES.TypeIsObject(promise)) {\n return false;\n }\n if (typeof promise._promise === 'undefined') {\n return false; // uninitialized, or missing our hidden field.\n }\n return true;\n };\n\n // \"PromiseCapability\" in the spec is what most promise implementations\n // call a \"deferred\".\n var PromiseCapability = function (C) {\n if (!ES.IsConstructor(C)) {\n throw new TypeError('Bad promise constructor');\n }\n var capability = this;\n var resolver = function (resolve, reject) {\n if (capability.resolve !== void 0 || capability.reject !== void 0) {\n throw new TypeError('Bad Promise implementation!');\n }\n capability.resolve = resolve;\n capability.reject = reject;\n };\n // Initialize fields to inform optimizers about the object shape.\n capability.resolve = void 0;\n capability.reject = void 0;\n capability.promise = new C(resolver);\n if (!(ES.IsCallable(capability.resolve) && ES.IsCallable(capability.reject))) {\n throw new TypeError('Bad promise constructor');\n }\n };\n\n // find an appropriate setImmediate-alike\n var makeZeroTimeout;\n /*global window */\n if (typeof window !== 'undefined' && ES.IsCallable(window.postMessage)) {\n makeZeroTimeout = function () {\n // from http://dbaron.org/log/20100309-faster-timeouts\n var timeouts = [];\n var messageName = 'zero-timeout-message';\n var setZeroTimeout = function (fn) {\n _push(timeouts, fn);\n window.postMessage(messageName, '*');\n };\n var handleMessage = function (event) {\n if (event.source === window && event.data === messageName) {\n event.stopPropagation();\n if (timeouts.length === 0) { return; }\n var fn = _shift(timeouts);\n fn();\n }\n };\n window.addEventListener('message', handleMessage, true);\n return setZeroTimeout;\n };\n }\n var makePromiseAsap = function () {\n // An efficient task-scheduler based on a pre-existing Promise\n // implementation, which we can use even if we override the\n // global Promise below (in order to workaround bugs)\n // https://github.com/Raynos/observ-hash/issues/2#issuecomment-35857671\n var P = globals.Promise;\n var pr = P && P.resolve && P.resolve();\n return pr && function (task) {\n return pr.then(task);\n };\n };\n /*global process */\n /* jscs:disable disallowMultiLineTernary */\n var enqueue = ES.IsCallable(globals.setImmediate) ?\n globals.setImmediate :\n typeof process === 'object' && process.nextTick ? process.nextTick :\n makePromiseAsap() ||\n (ES.IsCallable(makeZeroTimeout) ? makeZeroTimeout() :\n function (task) { setTimeout(task, 0); }); // fallback\n /* jscs:enable disallowMultiLineTernary */\n\n // Constants for Promise implementation\n var PROMISE_IDENTITY = function (x) { return x; };\n var PROMISE_THROWER = function (e) { throw e; };\n var PROMISE_PENDING = 0;\n var PROMISE_FULFILLED = 1;\n var PROMISE_REJECTED = 2;\n // We store fulfill/reject handlers and capabilities in a single array.\n var PROMISE_FULFILL_OFFSET = 0;\n var PROMISE_REJECT_OFFSET = 1;\n var PROMISE_CAPABILITY_OFFSET = 2;\n // This is used in an optimization for chaining promises via then.\n var PROMISE_FAKE_CAPABILITY = {};\n\n var enqueuePromiseReactionJob = function (handler, capability, argument) {\n enqueue(function () {\n promiseReactionJob(handler, capability, argument);\n });\n };\n\n var promiseReactionJob = function (handler, promiseCapability, argument) {\n var handlerResult, f;\n if (promiseCapability === PROMISE_FAKE_CAPABILITY) {\n // Fast case, when we don't actually need to chain through to a\n // (real) promiseCapability.\n return handler(argument);\n }\n try {\n handlerResult = handler(argument);\n f = promiseCapability.resolve;\n } catch (e) {\n handlerResult = e;\n f = promiseCapability.reject;\n }\n f(handlerResult);\n };\n\n var fulfillPromise = function (promise, value) {\n var _promise = promise._promise;\n var length = _promise.reactionLength;\n if (length > 0) {\n enqueuePromiseReactionJob(\n _promise.fulfillReactionHandler0,\n _promise.reactionCapability0,\n value\n );\n _promise.fulfillReactionHandler0 = void 0;\n _promise.rejectReactions0 = void 0;\n _promise.reactionCapability0 = void 0;\n if (length > 1) {\n for (var i = 1, idx = 0; i < length; i++, idx += 3) {\n enqueuePromiseReactionJob(\n _promise[idx + PROMISE_FULFILL_OFFSET],\n _promise[idx + PROMISE_CAPABILITY_OFFSET],\n value\n );\n promise[idx + PROMISE_FULFILL_OFFSET] = void 0;\n promise[idx + PROMISE_REJECT_OFFSET] = void 0;\n promise[idx + PROMISE_CAPABILITY_OFFSET] = void 0;\n }\n }\n }\n _promise.result = value;\n _promise.state = PROMISE_FULFILLED;\n _promise.reactionLength = 0;\n };\n\n var rejectPromise = function (promise, reason) {\n var _promise = promise._promise;\n var length = _promise.reactionLength;\n if (length > 0) {\n enqueuePromiseReactionJob(\n _promise.rejectReactionHandler0,\n _promise.reactionCapability0,\n reason\n );\n _promise.fulfillReactionHandler0 = void 0;\n _promise.rejectReactions0 = void 0;\n _promise.reactionCapability0 = void 0;\n if (length > 1) {\n for (var i = 1, idx = 0; i < length; i++, idx += 3) {\n enqueuePromiseReactionJob(\n _promise[idx + PROMISE_REJECT_OFFSET],\n _promise[idx + PROMISE_CAPABILITY_OFFSET],\n reason\n );\n promise[idx + PROMISE_FULFILL_OFFSET] = void 0;\n promise[idx + PROMISE_REJECT_OFFSET] = void 0;\n promise[idx + PROMISE_CAPABILITY_OFFSET] = void 0;\n }\n }\n }\n _promise.result = reason;\n _promise.state = PROMISE_REJECTED;\n _promise.reactionLength = 0;\n };\n\n var createResolvingFunctions = function (promise) {\n var alreadyResolved = false;\n var resolve = function (resolution) {\n var then;\n if (alreadyResolved) { return; }\n alreadyResolved = true;\n if (resolution === promise) {\n return rejectPromise(promise, new TypeError('Self resolution'));\n }\n if (!ES.TypeIsObject(resolution)) {\n return fulfillPromise(promise, resolution);\n }\n try {\n then = resolution.then;\n } catch (e) {\n return rejectPromise(promise, e);\n }\n if (!ES.IsCallable(then)) {\n return fulfillPromise(promise, resolution);\n }\n enqueue(function () {\n promiseResolveThenableJob(promise, resolution, then);\n });\n };\n var reject = function (reason) {\n if (alreadyResolved) { return; }\n alreadyResolved = true;\n return rejectPromise(promise, reason);\n };\n return { resolve: resolve, reject: reject };\n };\n\n var optimizedThen = function (then, thenable, resolve, reject) {\n // Optimization: since we discard the result, we can pass our\n // own then implementation a special hint to let it know it\n // doesn't have to create it. (The PROMISE_FAKE_CAPABILITY\n // object is local to this implementation and unforgeable outside.)\n if (then === Promise$prototype$then) {\n _call(then, thenable, resolve, reject, PROMISE_FAKE_CAPABILITY);\n } else {\n _call(then, thenable, resolve, reject);\n }\n };\n var promiseResolveThenableJob = function (promise, thenable, then) {\n var resolvingFunctions = createResolvingFunctions(promise);\n var resolve = resolvingFunctions.resolve;\n var reject = resolvingFunctions.reject;\n try {\n optimizedThen(then, thenable, resolve, reject);\n } catch (e) {\n reject(e);\n }\n };\n\n var Promise$prototype, Promise$prototype$then;\n var Promise = (function () {\n var PromiseShim = function Promise(resolver) {\n if (!(this instanceof PromiseShim)) {\n throw new TypeError('Constructor Promise requires \"new\"');\n }\n if (this && this._promise) {\n throw new TypeError('Bad construction');\n }\n // see https://bugs.ecmascript.org/show_bug.cgi?id=2482\n if (!ES.IsCallable(resolver)) {\n throw new TypeError('not a valid resolver');\n }\n var promise = emulateES6construct(this, PromiseShim, Promise$prototype, {\n _promise: {\n result: void 0,\n state: PROMISE_PENDING,\n // The first member of the \"reactions\" array is inlined here,\n // since most promises only have one reaction.\n // We've also exploded the 'reaction' object to inline the\n // \"handler\" and \"capability\" fields, since both fulfill and\n // reject reactions share the same capability.\n reactionLength: 0,\n fulfillReactionHandler0: void 0,\n rejectReactionHandler0: void 0,\n reactionCapability0: void 0\n }\n });\n var resolvingFunctions = createResolvingFunctions(promise);\n var reject = resolvingFunctions.reject;\n try {\n resolver(resolvingFunctions.resolve, reject);\n } catch (e) {\n reject(e);\n }\n return promise;\n };\n return PromiseShim;\n }());\n Promise$prototype = Promise.prototype;\n\n var _promiseAllResolver = function (index, values, capability, remaining) {\n var alreadyCalled = false;\n return function (x) {\n if (alreadyCalled) { return; }\n alreadyCalled = true;\n values[index] = x;\n if ((--remaining.count) === 0) {\n var resolve = capability.resolve;\n resolve(values); // call w/ this===undefined\n }\n };\n };\n\n var performPromiseAll = function (iteratorRecord, C, resultCapability) {\n var it = iteratorRecord.iterator;\n var values = [], remaining = { count: 1 }, next, nextValue;\n var index = 0;\n while (true) {\n try {\n next = ES.IteratorStep(it);\n if (next === false) {\n iteratorRecord.done = true;\n break;\n }\n nextValue = next.value;\n } catch (e) {\n iteratorRecord.done = true;\n throw e;\n }\n values[index] = void 0;\n var nextPromise = C.resolve(nextValue);\n var resolveElement = _promiseAllResolver(\n index, values, resultCapability, remaining\n );\n remaining.count += 1;\n optimizedThen(nextPromise.then, nextPromise, resolveElement, resultCapability.reject);\n index += 1;\n }\n if ((--remaining.count) === 0) {\n var resolve = resultCapability.resolve;\n resolve(values); // call w/ this===undefined\n }\n return resultCapability.promise;\n };\n\n var performPromiseRace = function (iteratorRecord, C, resultCapability) {\n var it = iteratorRecord.iterator, next, nextValue, nextPromise;\n while (true) {\n try {\n next = ES.IteratorStep(it);\n if (next === false) {\n // NOTE: If iterable has no items, resulting promise will never\n // resolve; see:\n // https://github.com/domenic/promises-unwrapping/issues/75\n // https://bugs.ecmascript.org/show_bug.cgi?id=2515\n iteratorRecord.done = true;\n break;\n }\n nextValue = next.value;\n } catch (e) {\n iteratorRecord.done = true;\n throw e;\n }\n nextPromise = C.resolve(nextValue);\n optimizedThen(nextPromise.then, nextPromise, resultCapability.resolve, resultCapability.reject);\n }\n return resultCapability.promise;\n };\n\n defineProperties(Promise, {\n all: function all(iterable) {\n var C = this;\n if (!ES.TypeIsObject(C)) {\n throw new TypeError('Promise is not object');\n }\n var capability = new PromiseCapability(C);\n var iterator, iteratorRecord;\n try {\n iterator = ES.GetIterator(iterable);\n iteratorRecord = { iterator: iterator, done: false };\n return performPromiseAll(iteratorRecord, C, capability);\n } catch (e) {\n var exception = e;\n if (iteratorRecord && !iteratorRecord.done) {\n try {\n ES.IteratorClose(iterator, true);\n } catch (ee) {\n exception = ee;\n }\n }\n var reject = capability.reject;\n reject(exception);\n return capability.promise;\n }\n },\n\n race: function race(iterable) {\n var C = this;\n if (!ES.TypeIsObject(C)) {\n throw new TypeError('Promise is not object');\n }\n var capability = new PromiseCapability(C);\n var iterator, iteratorRecord;\n try {\n iterator = ES.GetIterator(iterable);\n iteratorRecord = { iterator: iterator, done: false };\n return performPromiseRace(iteratorRecord, C, capability);\n } catch (e) {\n var exception = e;\n if (iteratorRecord && !iteratorRecord.done) {\n try {\n ES.IteratorClose(iterator, true);\n } catch (ee) {\n exception = ee;\n }\n }\n var reject = capability.reject;\n reject(exception);\n return capability.promise;\n }\n },\n\n reject: function reject(reason) {\n var C = this;\n if (!ES.TypeIsObject(C)) {\n throw new TypeError('Bad promise constructor');\n }\n var capability = new PromiseCapability(C);\n var rejectFunc = capability.reject;\n rejectFunc(reason); // call with this===undefined\n return capability.promise;\n },\n\n resolve: function resolve(v) {\n // See https://esdiscuss.org/topic/fixing-promise-resolve for spec\n var C = this;\n if (!ES.TypeIsObject(C)) {\n throw new TypeError('Bad promise constructor');\n }\n if (ES.IsPromise(v)) {\n var constructor = v.constructor;\n if (constructor === C) { return v; }\n }\n var capability = new PromiseCapability(C);\n var resolveFunc = capability.resolve;\n resolveFunc(v); // call with this===undefined\n return capability.promise;\n }\n });\n\n defineProperties(Promise$prototype, {\n 'catch': function (onRejected) {\n return this.then(null, onRejected);\n },\n\n then: function then(onFulfilled, onRejected) {\n var promise = this;\n if (!ES.IsPromise(promise)) { throw new TypeError('not a promise'); }\n var C = ES.SpeciesConstructor(promise, Promise);\n var resultCapability;\n var returnValueIsIgnored = arguments.length > 2 && arguments[2] === PROMISE_FAKE_CAPABILITY;\n if (returnValueIsIgnored && C === Promise) {\n resultCapability = PROMISE_FAKE_CAPABILITY;\n } else {\n resultCapability = new PromiseCapability(C);\n }\n // PerformPromiseThen(promise, onFulfilled, onRejected, resultCapability)\n // Note that we've split the 'reaction' object into its two\n // components, \"capabilities\" and \"handler\"\n // \"capabilities\" is always equal to `resultCapability`\n var fulfillReactionHandler = ES.IsCallable(onFulfilled) ? onFulfilled : PROMISE_IDENTITY;\n var rejectReactionHandler = ES.IsCallable(onRejected) ? onRejected : PROMISE_THROWER;\n var _promise = promise._promise;\n var value;\n if (_promise.state === PROMISE_PENDING) {\n if (_promise.reactionLength === 0) {\n _promise.fulfillReactionHandler0 = fulfillReactionHandler;\n _promise.rejectReactionHandler0 = rejectReactionHandler;\n _promise.reactionCapability0 = resultCapability;\n } else {\n var idx = 3 * (_promise.reactionLength - 1);\n _promise[idx + PROMISE_FULFILL_OFFSET] = fulfillReactionHandler;\n _promise[idx + PROMISE_REJECT_OFFSET] = rejectReactionHandler;\n _promise[idx + PROMISE_CAPABILITY_OFFSET] = resultCapability;\n }\n _promise.reactionLength += 1;\n } else if (_promise.state === PROMISE_FULFILLED) {\n value = _promise.result;\n enqueuePromiseReactionJob(\n fulfillReactionHandler, resultCapability, value\n );\n } else if (_promise.state === PROMISE_REJECTED) {\n value = _promise.result;\n enqueuePromiseReactionJob(\n rejectReactionHandler, resultCapability, value\n );\n } else {\n throw new TypeError('unexpected Promise state');\n }\n return resultCapability.promise;\n }\n });\n // This helps the optimizer by ensuring that methods which take\n // capabilities aren't polymorphic.\n PROMISE_FAKE_CAPABILITY = new PromiseCapability(Promise);\n Promise$prototype$then = Promise$prototype.then;\n\n return Promise;\n }());\n\n // Chrome's native Promise has extra methods that it shouldn't have. Let's remove them.\n if (globals.Promise) {\n delete globals.Promise.accept;\n delete globals.Promise.defer;\n delete globals.Promise.prototype.chain;\n }\n\n if (typeof PromiseShim === 'function') {\n // export the Promise constructor.\n defineProperties(globals, { Promise: PromiseShim });\n // In Chrome 33 (and thereabouts) Promise is defined, but the\n // implementation is buggy in a number of ways. Let's check subclassing\n // support to see if we have a buggy implementation.\n var promiseSupportsSubclassing = supportsSubclassing(globals.Promise, function (S) {\n return S.resolve(42).then(function () {}) instanceof S;\n });\n var promiseIgnoresNonFunctionThenCallbacks = !throwsError(function () { globals.Promise.reject(42).then(null, 5).then(null, noop); });\n var promiseRequiresObjectContext = throwsError(function () { globals.Promise.call(3, noop); });\n // Promise.resolve() was errata'ed late in the ES6 process.\n // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1170742\n // https://code.google.com/p/v8/issues/detail?id=4161\n // It serves as a proxy for a number of other bugs in early Promise\n // implementations.\n var promiseResolveBroken = (function (Promise) {\n var p = Promise.resolve(5);\n p.constructor = {};\n var p2 = Promise.resolve(p);\n try {\n p2.then(null, noop).then(null, noop); // avoid \"uncaught rejection\" warnings in console\n } catch (e) {\n return true; // v8 native Promises break here https://code.google.com/p/chromium/issues/detail?id=575314\n }\n return p === p2; // This *should* be false!\n }(globals.Promise));\n\n // Chrome 46 (probably older too) does not retrieve a thenable's .then synchronously\n var getsThenSynchronously = supportsDescriptors && (function () {\n var count = 0;\n var thenable = Object.defineProperty({}, 'then', { get: function () { count += 1; } });\n Promise.resolve(thenable);\n return count === 1;\n }());\n\n var BadResolverPromise = function BadResolverPromise(executor) {\n var p = new Promise(executor);\n executor(3, function () {});\n this.then = p.then;\n this.constructor = BadResolverPromise;\n };\n BadResolverPromise.prototype = Promise.prototype;\n BadResolverPromise.all = Promise.all;\n // Chrome Canary 49 (probably older too) has some implementation bugs\n var hasBadResolverPromise = valueOrFalseIfThrows(function () {\n return !!BadResolverPromise.all([1, 2]);\n });\n\n if (!promiseSupportsSubclassing || !promiseIgnoresNonFunctionThenCallbacks ||\n !promiseRequiresObjectContext || promiseResolveBroken ||\n !getsThenSynchronously || hasBadResolverPromise) {\n /* globals Promise: true */\n /* eslint-disable no-undef */\n /* jshint -W020 */\n Promise = PromiseShim;\n /* jshint +W020 */\n /* eslint-enable no-undef */\n /* globals Promise: false */\n overrideNative(globals, 'Promise', PromiseShim);\n }\n if (Promise.all.length !== 1) {\n var origAll = Promise.all;\n overrideNative(Promise, 'all', function all(iterable) {\n return ES.Call(origAll, this, arguments);\n });\n }\n if (Promise.race.length !== 1) {\n var origRace = Promise.race;\n overrideNative(Promise, 'race', function race(iterable) {\n return ES.Call(origRace, this, arguments);\n });\n }\n if (Promise.resolve.length !== 1) {\n var origResolve = Promise.resolve;\n overrideNative(Promise, 'resolve', function resolve(x) {\n return ES.Call(origResolve, this, arguments);\n });\n }\n if (Promise.reject.length !== 1) {\n var origReject = Promise.reject;\n overrideNative(Promise, 'reject', function reject(r) {\n return ES.Call(origReject, this, arguments);\n });\n }\n ensureEnumerable(Promise, 'all');\n ensureEnumerable(Promise, 'race');\n ensureEnumerable(Promise, 'resolve');\n ensureEnumerable(Promise, 'reject');\n addDefaultSpecies(Promise);\n }\n\n // Map and Set require a true ES5 environment\n // Their fast path also requires that the environment preserve\n // property insertion order, which is not guaranteed by the spec.\n var testOrder = function (a) {\n var b = keys(_reduce(a, function (o, k) {\n o[k] = true;\n return o;\n }, {}));\n return a.join(':') === b.join(':');\n };\n var preservesInsertionOrder = testOrder(['z', 'a', 'bb']);\n // some engines (eg, Chrome) only preserve insertion order for string keys\n var preservesNumericInsertionOrder = testOrder(['z', 1, 'a', '3', 2]);\n\n if (supportsDescriptors) {\n\n var fastkey = function fastkey(key) {\n if (!preservesInsertionOrder) {\n return null;\n }\n if (typeof key === 'undefined' || key === null) {\n return '^' + ES.ToString(key);\n } else if (typeof key === 'string') {\n return '$' + key;\n } else if (typeof key === 'number') {\n // note that -0 will get coerced to \"0\" when used as a property key\n if (!preservesNumericInsertionOrder) {\n return 'n' + key;\n }\n return key;\n } else if (typeof key === 'boolean') {\n return 'b' + key;\n }\n return null;\n };\n\n var emptyObject = function emptyObject() {\n // accomodate some older not-quite-ES5 browsers\n return Object.create ? Object.create(null) : {};\n };\n\n var addIterableToMap = function addIterableToMap(MapConstructor, map, iterable) {\n if (isArray(iterable) || Type.string(iterable)) {\n _forEach(iterable, function (entry) {\n if (!ES.TypeIsObject(entry)) {\n throw new TypeError('Iterator value ' + entry + ' is not an entry object');\n }\n map.set(entry[0], entry[1]);\n });\n } else if (iterable instanceof MapConstructor) {\n _call(MapConstructor.prototype.forEach, iterable, function (value, key) {\n map.set(key, value);\n });\n } else {\n var iter, adder;\n if (iterable !== null && typeof iterable !== 'undefined') {\n adder = map.set;\n if (!ES.IsCallable(adder)) { throw new TypeError('bad map'); }\n iter = ES.GetIterator(iterable);\n }\n if (typeof iter !== 'undefined') {\n while (true) {\n var next = ES.IteratorStep(iter);\n if (next === false) { break; }\n var nextItem = next.value;\n try {\n if (!ES.TypeIsObject(nextItem)) {\n throw new TypeError('Iterator value ' + nextItem + ' is not an entry object');\n }\n _call(adder, map, nextItem[0], nextItem[1]);\n } catch (e) {\n ES.IteratorClose(iter, true);\n throw e;\n }\n }\n }\n }\n };\n var addIterableToSet = function addIterableToSet(SetConstructor, set, iterable) {\n if (isArray(iterable) || Type.string(iterable)) {\n _forEach(iterable, function (value) {\n set.add(value);\n });\n } else if (iterable instanceof SetConstructor) {\n _call(SetConstructor.prototype.forEach, iterable, function (value) {\n set.add(value);\n });\n } else {\n var iter, adder;\n if (iterable !== null && typeof iterable !== 'undefined') {\n adder = set.add;\n if (!ES.IsCallable(adder)) { throw new TypeError('bad set'); }\n iter = ES.GetIterator(iterable);\n }\n if (typeof iter !== 'undefined') {\n while (true) {\n var next = ES.IteratorStep(iter);\n if (next === false) { break; }\n var nextValue = next.value;\n try {\n _call(adder, set, nextValue);\n } catch (e) {\n ES.IteratorClose(iter, true);\n throw e;\n }\n }\n }\n }\n };\n\n var collectionShims = {\n Map: (function () {\n\n var empty = {};\n\n var MapEntry = function MapEntry(key, value) {\n this.key = key;\n this.value = value;\n this.next = null;\n this.prev = null;\n };\n\n MapEntry.prototype.isRemoved = function isRemoved() {\n return this.key === empty;\n };\n\n var isMap = function isMap(map) {\n return !!map._es6map;\n };\n\n var requireMapSlot = function requireMapSlot(map, method) {\n if (!ES.TypeIsObject(map) || !isMap(map)) {\n throw new TypeError('Method Map.prototype.' + method + ' called on incompatible receiver ' + ES.ToString(map));\n }\n };\n\n var MapIterator = function MapIterator(map, kind) {\n requireMapSlot(map, '[[MapIterator]]');\n this.head = map._head;\n this.i = this.head;\n this.kind = kind;\n };\n\n MapIterator.prototype = {\n next: function next() {\n var i = this.i, kind = this.kind, head = this.head, result;\n if (typeof this.i === 'undefined') {\n return { value: void 0, done: true };\n }\n while (i.isRemoved() && i !== head) {\n // back up off of removed entries\n i = i.prev;\n }\n // advance to next unreturned element.\n while (i.next !== head) {\n i = i.next;\n if (!i.isRemoved()) {\n if (kind === 'key') {\n result = i.key;\n } else if (kind === 'value') {\n result = i.value;\n } else {\n result = [i.key, i.value];\n }\n this.i = i;\n return { value: result, done: false };\n }\n }\n // once the iterator is done, it is done forever.\n this.i = void 0;\n return { value: void 0, done: true };\n }\n };\n addIterator(MapIterator.prototype);\n\n var Map$prototype;\n var MapShim = function Map() {\n if (!(this instanceof Map)) {\n throw new TypeError('Constructor Map requires \"new\"');\n }\n if (this && this._es6map) {\n throw new TypeError('Bad construction');\n }\n var map = emulateES6construct(this, Map, Map$prototype, {\n _es6map: true,\n _head: null,\n _storage: emptyObject(),\n _size: 0\n });\n\n var head = new MapEntry(null, null);\n // circular doubly-linked list.\n head.next = head.prev = head;\n map._head = head;\n\n // Optionally initialize map from iterable\n if (arguments.length > 0) {\n addIterableToMap(Map, map, arguments[0]);\n }\n return map;\n };\n Map$prototype = MapShim.prototype;\n\n Value.getter(Map$prototype, 'size', function () {\n if (typeof this._size === 'undefined') {\n throw new TypeError('size method called on incompatible Map');\n }\n return this._size;\n });\n\n defineProperties(Map$prototype, {\n get: function get(key) {\n requireMapSlot(this, 'get');\n var fkey = fastkey(key);\n if (fkey !== null) {\n // fast O(1) path\n var entry = this._storage[fkey];\n if (entry) {\n return entry.value;\n } else {\n return;\n }\n }\n var head = this._head, i = head;\n while ((i = i.next) !== head) {\n if (ES.SameValueZero(i.key, key)) {\n return i.value;\n }\n }\n },\n\n has: function has(key) {\n requireMapSlot(this, 'has');\n var fkey = fastkey(key);\n if (fkey !== null) {\n // fast O(1) path\n return typeof this._storage[fkey] !== 'undefined';\n }\n var head = this._head, i = head;\n while ((i = i.next) !== head) {\n if (ES.SameValueZero(i.key, key)) {\n return true;\n }\n }\n return false;\n },\n\n set: function set(key, value) {\n requireMapSlot(this, 'set');\n var head = this._head, i = head, entry;\n var fkey = fastkey(key);\n if (fkey !== null) {\n // fast O(1) path\n if (typeof this._storage[fkey] !== 'undefined') {\n this._storage[fkey].value = value;\n return this;\n } else {\n entry = this._storage[fkey] = new MapEntry(key, value);\n i = head.prev;\n // fall through\n }\n }\n while ((i = i.next) !== head) {\n if (ES.SameValueZero(i.key, key)) {\n i.value = value;\n return this;\n }\n }\n entry = entry || new MapEntry(key, value);\n if (ES.SameValue(-0, key)) {\n entry.key = +0; // coerce -0 to +0 in entry\n }\n entry.next = this._head;\n entry.prev = this._head.prev;\n entry.prev.next = entry;\n entry.next.prev = entry;\n this._size += 1;\n return this;\n },\n\n 'delete': function (key) {\n requireMapSlot(this, 'delete');\n var head = this._head, i = head;\n var fkey = fastkey(key);\n if (fkey !== null) {\n // fast O(1) path\n if (typeof this._storage[fkey] === 'undefined') {\n return false;\n }\n i = this._storage[fkey].prev;\n delete this._storage[fkey];\n // fall through\n }\n while ((i = i.next) !== head) {\n if (ES.SameValueZero(i.key, key)) {\n i.key = i.value = empty;\n i.prev.next = i.next;\n i.next.prev = i.prev;\n this._size -= 1;\n return true;\n }\n }\n return false;\n },\n\n clear: function clear() {\n requireMapSlot(this, 'clear');\n this._size = 0;\n this._storage = emptyObject();\n var head = this._head, i = head, p = i.next;\n while ((i = p) !== head) {\n i.key = i.value = empty;\n p = i.next;\n i.next = i.prev = head;\n }\n head.next = head.prev = head;\n },\n\n keys: function keys() {\n requireMapSlot(this, 'keys');\n return new MapIterator(this, 'key');\n },\n\n values: function values() {\n requireMapSlot(this, 'values');\n return new MapIterator(this, 'value');\n },\n\n entries: function entries() {\n requireMapSlot(this, 'entries');\n return new MapIterator(this, 'key+value');\n },\n\n forEach: function forEach(callback) {\n requireMapSlot(this, 'forEach');\n var context = arguments.length > 1 ? arguments[1] : null;\n var it = this.entries();\n for (var entry = it.next(); !entry.done; entry = it.next()) {\n if (context) {\n _call(callback, context, entry.value[1], entry.value[0], this);\n } else {\n callback(entry.value[1], entry.value[0], this);\n }\n }\n }\n });\n addIterator(Map$prototype, Map$prototype.entries);\n\n return MapShim;\n }()),\n\n Set: (function () {\n var isSet = function isSet(set) {\n return set._es6set && typeof set._storage !== 'undefined';\n };\n var requireSetSlot = function requireSetSlot(set, method) {\n if (!ES.TypeIsObject(set) || !isSet(set)) {\n // https://github.com/paulmillr/es6-shim/issues/176\n throw new TypeError('Set.prototype.' + method + ' called on incompatible receiver ' + ES.ToString(set));\n }\n };\n\n // Creating a Map is expensive. To speed up the common case of\n // Sets containing only string or numeric keys, we use an object\n // as backing storage and lazily create a full Map only when\n // required.\n var Set$prototype;\n var SetShim = function Set() {\n if (!(this instanceof Set)) {\n throw new TypeError('Constructor Set requires \"new\"');\n }\n if (this && this._es6set) {\n throw new TypeError('Bad construction');\n }\n var set = emulateES6construct(this, Set, Set$prototype, {\n _es6set: true,\n '[[SetData]]': null,\n _storage: emptyObject()\n });\n if (!set._es6set) {\n throw new TypeError('bad set');\n }\n\n // Optionally initialize Set from iterable\n if (arguments.length > 0) {\n addIterableToSet(Set, set, arguments[0]);\n }\n return set;\n };\n Set$prototype = SetShim.prototype;\n\n var decodeKey = function (key) {\n var k = key;\n if (k === '^null') {\n return null;\n } else if (k === '^undefined') {\n return void 0;\n } else {\n var first = k.charAt(0);\n if (first === '$') {\n return _strSlice(k, 1);\n } else if (first === 'n') {\n return +_strSlice(k, 1);\n } else if (first === 'b') {\n return k === 'btrue';\n }\n }\n return +k;\n };\n // Switch from the object backing storage to a full Map.\n var ensureMap = function ensureMap(set) {\n if (!set['[[SetData]]']) {\n var m = set['[[SetData]]'] = new collectionShims.Map();\n _forEach(keys(set._storage), function (key) {\n var k = decodeKey(key);\n m.set(k, k);\n });\n set['[[SetData]]'] = m;\n }\n set._storage = null; // free old backing storage\n };\n\n Value.getter(SetShim.prototype, 'size', function () {\n requireSetSlot(this, 'size');\n if (this._storage) {\n return keys(this._storage).length;\n }\n ensureMap(this);\n return this['[[SetData]]'].size;\n });\n\n defineProperties(SetShim.prototype, {\n has: function has(key) {\n requireSetSlot(this, 'has');\n var fkey;\n if (this._storage && (fkey = fastkey(key)) !== null) {\n return !!this._storage[fkey];\n }\n ensureMap(this);\n return this['[[SetData]]'].has(key);\n },\n\n add: function add(key) {\n requireSetSlot(this, 'add');\n var fkey;\n if (this._storage && (fkey = fastkey(key)) !== null) {\n this._storage[fkey] = true;\n return this;\n }\n ensureMap(this);\n this['[[SetData]]'].set(key, key);\n return this;\n },\n\n 'delete': function (key) {\n requireSetSlot(this, 'delete');\n var fkey;\n if (this._storage && (fkey = fastkey(key)) !== null) {\n var hasFKey = _hasOwnProperty(this._storage, fkey);\n return (delete this._storage[fkey]) && hasFKey;\n }\n ensureMap(this);\n return this['[[SetData]]']['delete'](key);\n },\n\n clear: function clear() {\n requireSetSlot(this, 'clear');\n if (this._storage) {\n this._storage = emptyObject();\n }\n if (this['[[SetData]]']) {\n this['[[SetData]]'].clear();\n }\n },\n\n values: function values() {\n requireSetSlot(this, 'values');\n ensureMap(this);\n return this['[[SetData]]'].values();\n },\n\n entries: function entries() {\n requireSetSlot(this, 'entries');\n ensureMap(this);\n return this['[[SetData]]'].entries();\n },\n\n forEach: function forEach(callback) {\n requireSetSlot(this, 'forEach');\n var context = arguments.length > 1 ? arguments[1] : null;\n var entireSet = this;\n ensureMap(entireSet);\n this['[[SetData]]'].forEach(function (value, key) {\n if (context) {\n _call(callback, context, key, key, entireSet);\n } else {\n callback(key, key, entireSet);\n }\n });\n }\n });\n defineProperty(SetShim.prototype, 'keys', SetShim.prototype.values, true);\n addIterator(SetShim.prototype, SetShim.prototype.values);\n\n return SetShim;\n }())\n };\n\n if (globals.Map || globals.Set) {\n // Safari 8, for example, doesn't accept an iterable.\n var mapAcceptsArguments = valueOrFalseIfThrows(function () { return new Map([[1, 2]]).get(1) === 2; });\n if (!mapAcceptsArguments) {\n var OrigMapNoArgs = globals.Map;\n globals.Map = function Map() {\n if (!(this instanceof Map)) {\n throw new TypeError('Constructor Map requires \"new\"');\n }\n var m = new OrigMapNoArgs();\n if (arguments.length > 0) {\n addIterableToMap(Map, m, arguments[0]);\n }\n delete m.constructor;\n Object.setPrototypeOf(m, globals.Map.prototype);\n return m;\n };\n globals.Map.prototype = create(OrigMapNoArgs.prototype);\n defineProperty(globals.Map.prototype, 'constructor', globals.Map, true);\n Value.preserveToString(globals.Map, OrigMapNoArgs);\n }\n var testMap = new Map();\n var mapUsesSameValueZero = (function () {\n // Chrome 38-42, node 0.11/0.12, iojs 1/2 also have a bug when the Map has a size > 4\n var m = new Map([[1, 0], [2, 0], [3, 0], [4, 0]]);\n m.set(-0, m);\n return m.get(0) === m && m.get(-0) === m && m.has(0) && m.has(-0);\n }());\n var mapSupportsChaining = testMap.set(1, 2) === testMap;\n if (!mapUsesSameValueZero || !mapSupportsChaining) {\n var origMapSet = Map.prototype.set;\n overrideNative(Map.prototype, 'set', function set(k, v) {\n _call(origMapSet, this, k === 0 ? 0 : k, v);\n return this;\n });\n }\n if (!mapUsesSameValueZero) {\n var origMapGet = Map.prototype.get;\n var origMapHas = Map.prototype.has;\n defineProperties(Map.prototype, {\n get: function get(k) {\n return _call(origMapGet, this, k === 0 ? 0 : k);\n },\n has: function has(k) {\n return _call(origMapHas, this, k === 0 ? 0 : k);\n }\n }, true);\n Value.preserveToString(Map.prototype.get, origMapGet);\n Value.preserveToString(Map.prototype.has, origMapHas);\n }\n var testSet = new Set();\n var setUsesSameValueZero = (function (s) {\n s['delete'](0);\n s.add(-0);\n return !s.has(0);\n }(testSet));\n var setSupportsChaining = testSet.add(1) === testSet;\n if (!setUsesSameValueZero || !setSupportsChaining) {\n var origSetAdd = Set.prototype.add;\n Set.prototype.add = function add(v) {\n _call(origSetAdd, this, v === 0 ? 0 : v);\n return this;\n };\n Value.preserveToString(Set.prototype.add, origSetAdd);\n }\n if (!setUsesSameValueZero) {\n var origSetHas = Set.prototype.has;\n Set.prototype.has = function has(v) {\n return _call(origSetHas, this, v === 0 ? 0 : v);\n };\n Value.preserveToString(Set.prototype.has, origSetHas);\n var origSetDel = Set.prototype['delete'];\n Set.prototype['delete'] = function SetDelete(v) {\n return _call(origSetDel, this, v === 0 ? 0 : v);\n };\n Value.preserveToString(Set.prototype['delete'], origSetDel);\n }\n var mapSupportsSubclassing = supportsSubclassing(globals.Map, function (M) {\n var m = new M([]);\n // Firefox 32 is ok with the instantiating the subclass but will\n // throw when the map is used.\n m.set(42, 42);\n return m instanceof M;\n });\n var mapFailsToSupportSubclassing = Object.setPrototypeOf && !mapSupportsSubclassing; // without Object.setPrototypeOf, subclassing is not possible\n var mapRequiresNew = (function () {\n try {\n return !(globals.Map() instanceof globals.Map);\n } catch (e) {\n return e instanceof TypeError;\n }\n }());\n if (globals.Map.length !== 0 || mapFailsToSupportSubclassing || !mapRequiresNew) {\n var OrigMap = globals.Map;\n globals.Map = function Map() {\n if (!(this instanceof Map)) {\n throw new TypeError('Constructor Map requires \"new\"');\n }\n var m = new OrigMap();\n if (arguments.length > 0) {\n addIterableToMap(Map, m, arguments[0]);\n }\n delete m.constructor;\n Object.setPrototypeOf(m, Map.prototype);\n return m;\n };\n globals.Map.prototype = OrigMap.prototype;\n defineProperty(globals.Map.prototype, 'constructor', globals.Map, true);\n Value.preserveToString(globals.Map, OrigMap);\n }\n var setSupportsSubclassing = supportsSubclassing(globals.Set, function (S) {\n var s = new S([]);\n s.add(42, 42);\n return s instanceof S;\n });\n var setFailsToSupportSubclassing = Object.setPrototypeOf && !setSupportsSubclassing; // without Object.setPrototypeOf, subclassing is not possible\n var setRequiresNew = (function () {\n try {\n return !(globals.Set() instanceof globals.Set);\n } catch (e) {\n return e instanceof TypeError;\n }\n }());\n if (globals.Set.length !== 0 || setFailsToSupportSubclassing || !setRequiresNew) {\n var OrigSet = globals.Set;\n globals.Set = function Set() {\n if (!(this instanceof Set)) {\n throw new TypeError('Constructor Set requires \"new\"');\n }\n var s = new OrigSet();\n if (arguments.length > 0) {\n addIterableToSet(Set, s, arguments[0]);\n }\n delete s.constructor;\n Object.setPrototypeOf(s, Set.prototype);\n return s;\n };\n globals.Set.prototype = OrigSet.prototype;\n defineProperty(globals.Set.prototype, 'constructor', globals.Set, true);\n Value.preserveToString(globals.Set, OrigSet);\n }\n var mapIterationThrowsStopIterator = !valueOrFalseIfThrows(function () {\n return (new Map()).keys().next().done;\n });\n /*\n - In Firefox < 23, Map#size is a function.\n - In all current Firefox, Set#entries/keys/values & Map#clear do not exist\n - https://bugzilla.mozilla.org/show_bug.cgi?id=869996\n - In Firefox 24, Map and Set do not implement forEach\n - In Firefox 25 at least, Map and Set are callable without \"new\"\n */\n if (\n typeof globals.Map.prototype.clear !== 'function' ||\n new globals.Set().size !== 0 ||\n new globals.Map().size !== 0 ||\n typeof globals.Map.prototype.keys !== 'function' ||\n typeof globals.Set.prototype.keys !== 'function' ||\n typeof globals.Map.prototype.forEach !== 'function' ||\n typeof globals.Set.prototype.forEach !== 'function' ||\n isCallableWithoutNew(globals.Map) ||\n isCallableWithoutNew(globals.Set) ||\n typeof (new globals.Map().keys().next) !== 'function' || // Safari 8\n mapIterationThrowsStopIterator || // Firefox 25\n !mapSupportsSubclassing\n ) {\n defineProperties(globals, {\n Map: collectionShims.Map,\n Set: collectionShims.Set\n }, true);\n }\n\n if (globals.Set.prototype.keys !== globals.Set.prototype.values) {\n // Fixed in WebKit with https://bugs.webkit.org/show_bug.cgi?id=144190\n defineProperty(globals.Set.prototype, 'keys', globals.Set.prototype.values, true);\n }\n\n // Shim incomplete iterator implementations.\n addIterator(Object.getPrototypeOf((new globals.Map()).keys()));\n addIterator(Object.getPrototypeOf((new globals.Set()).keys()));\n\n if (functionsHaveNames && globals.Set.prototype.has.name !== 'has') {\n // Microsoft Edge v0.11.10074.0 is missing a name on Set#has\n var anonymousSetHas = globals.Set.prototype.has;\n overrideNative(globals.Set.prototype, 'has', function has(key) {\n return _call(anonymousSetHas, this, key);\n });\n }\n }\n defineProperties(globals, collectionShims);\n addDefaultSpecies(globals.Map);\n addDefaultSpecies(globals.Set);\n }\n\n var throwUnlessTargetIsObject = function throwUnlessTargetIsObject(target) {\n if (!ES.TypeIsObject(target)) {\n throw new TypeError('target must be an object');\n }\n };\n\n // Some Reflect methods are basically the same as\n // those on the Object global, except that a TypeError is thrown if\n // target isn't an object. As well as returning a boolean indicating\n // the success of the operation.\n var ReflectShims = {\n // Apply method in a functional form.\n apply: function apply() {\n return ES.Call(ES.Call, null, arguments);\n },\n\n // New operator in a functional form.\n construct: function construct(constructor, args) {\n if (!ES.IsConstructor(constructor)) {\n throw new TypeError('First argument must be a constructor.');\n }\n var newTarget = arguments.length > 2 ? arguments[2] : constructor;\n if (!ES.IsConstructor(newTarget)) {\n throw new TypeError('new.target must be a constructor.');\n }\n return ES.Construct(constructor, args, newTarget, 'internal');\n },\n\n // When deleting a non-existent or configurable property,\n // true is returned.\n // When attempting to delete a non-configurable property,\n // it will return false.\n deleteProperty: function deleteProperty(target, key) {\n throwUnlessTargetIsObject(target);\n if (supportsDescriptors) {\n var desc = Object.getOwnPropertyDescriptor(target, key);\n\n if (desc && !desc.configurable) {\n return false;\n }\n }\n\n // Will return true.\n return delete target[key];\n },\n\n has: function has(target, key) {\n throwUnlessTargetIsObject(target);\n return key in target;\n }\n };\n\n if (Object.getOwnPropertyNames) {\n Object.assign(ReflectShims, {\n // Basically the result of calling the internal [[OwnPropertyKeys]].\n // Concatenating propertyNames and propertySymbols should do the trick.\n // This should continue to work together with a Symbol shim\n // which overrides Object.getOwnPropertyNames and implements\n // Object.getOwnPropertySymbols.\n ownKeys: function ownKeys(target) {\n throwUnlessTargetIsObject(target);\n var keys = Object.getOwnPropertyNames(target);\n\n if (ES.IsCallable(Object.getOwnPropertySymbols)) {\n _pushApply(keys, Object.getOwnPropertySymbols(target));\n }\n\n return keys;\n }\n });\n }\n\n var callAndCatchException = function ConvertExceptionToBoolean(func) {\n return !throwsError(func);\n };\n\n if (Object.preventExtensions) {\n Object.assign(ReflectShims, {\n isExtensible: function isExtensible(target) {\n throwUnlessTargetIsObject(target);\n return Object.isExtensible(target);\n },\n preventExtensions: function preventExtensions(target) {\n throwUnlessTargetIsObject(target);\n return callAndCatchException(function () {\n Object.preventExtensions(target);\n });\n }\n });\n }\n\n if (supportsDescriptors) {\n var internalGet = function get(target, key, receiver) {\n var desc = Object.getOwnPropertyDescriptor(target, key);\n\n if (!desc) {\n var parent = Object.getPrototypeOf(target);\n\n if (parent === null) {\n return void 0;\n }\n\n return internalGet(parent, key, receiver);\n }\n\n if ('value' in desc) {\n return desc.value;\n }\n\n if (desc.get) {\n return ES.Call(desc.get, receiver);\n }\n\n return void 0;\n };\n\n var internalSet = function set(target, key, value, receiver) {\n var desc = Object.getOwnPropertyDescriptor(target, key);\n\n if (!desc) {\n var parent = Object.getPrototypeOf(target);\n\n if (parent !== null) {\n return internalSet(parent, key, value, receiver);\n }\n\n desc = {\n value: void 0,\n writable: true,\n enumerable: true,\n configurable: true\n };\n }\n\n if ('value' in desc) {\n if (!desc.writable) {\n return false;\n }\n\n if (!ES.TypeIsObject(receiver)) {\n return false;\n }\n\n var existingDesc = Object.getOwnPropertyDescriptor(receiver, key);\n\n if (existingDesc) {\n return Reflect.defineProperty(receiver, key, {\n value: value\n });\n } else {\n return Reflect.defineProperty(receiver, key, {\n value: value,\n writable: true,\n enumerable: true,\n configurable: true\n });\n }\n }\n\n if (desc.set) {\n _call(desc.set, receiver, value);\n return true;\n }\n\n return false;\n };\n\n Object.assign(ReflectShims, {\n defineProperty: function defineProperty(target, propertyKey, attributes) {\n throwUnlessTargetIsObject(target);\n return callAndCatchException(function () {\n Object.defineProperty(target, propertyKey, attributes);\n });\n },\n\n getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) {\n throwUnlessTargetIsObject(target);\n return Object.getOwnPropertyDescriptor(target, propertyKey);\n },\n\n // Syntax in a functional form.\n get: function get(target, key) {\n throwUnlessTargetIsObject(target);\n var receiver = arguments.length > 2 ? arguments[2] : target;\n\n return internalGet(target, key, receiver);\n },\n\n set: function set(target, key, value) {\n throwUnlessTargetIsObject(target);\n var receiver = arguments.length > 3 ? arguments[3] : target;\n\n return internalSet(target, key, value, receiver);\n }\n });\n }\n\n if (Object.getPrototypeOf) {\n var objectDotGetPrototypeOf = Object.getPrototypeOf;\n ReflectShims.getPrototypeOf = function getPrototypeOf(target) {\n throwUnlessTargetIsObject(target);\n return objectDotGetPrototypeOf(target);\n };\n }\n\n if (Object.setPrototypeOf && ReflectShims.getPrototypeOf) {\n var willCreateCircularPrototype = function (object, lastProto) {\n var proto = lastProto;\n while (proto) {\n if (object === proto) {\n return true;\n }\n proto = ReflectShims.getPrototypeOf(proto);\n }\n return false;\n };\n\n Object.assign(ReflectShims, {\n // Sets the prototype of the given object.\n // Returns true on success, otherwise false.\n setPrototypeOf: function setPrototypeOf(object, proto) {\n throwUnlessTargetIsObject(object);\n if (proto !== null && !ES.TypeIsObject(proto)) {\n throw new TypeError('proto must be an object or null');\n }\n\n // If they already are the same, we're done.\n if (proto === Reflect.getPrototypeOf(object)) {\n return true;\n }\n\n // Cannot alter prototype if object not extensible.\n if (Reflect.isExtensible && !Reflect.isExtensible(object)) {\n return false;\n }\n\n // Ensure that we do not create a circular prototype chain.\n if (willCreateCircularPrototype(object, proto)) {\n return false;\n }\n\n Object.setPrototypeOf(object, proto);\n\n return true;\n }\n });\n }\n var defineOrOverrideReflectProperty = function (key, shim) {\n if (!ES.IsCallable(globals.Reflect[key])) {\n defineProperty(globals.Reflect, key, shim);\n } else {\n var acceptsPrimitives = valueOrFalseIfThrows(function () {\n globals.Reflect[key](1);\n globals.Reflect[key](NaN);\n globals.Reflect[key](true);\n return true;\n });\n if (acceptsPrimitives) {\n overrideNative(globals.Reflect, key, shim);\n }\n }\n };\n Object.keys(ReflectShims).forEach(function (key) {\n defineOrOverrideReflectProperty(key, ReflectShims[key]);\n });\n var originalReflectGetProto = globals.Reflect.getPrototypeOf;\n if (functionsHaveNames && originalReflectGetProto && originalReflectGetProto.name !== 'getPrototypeOf') {\n overrideNative(globals.Reflect, 'getPrototypeOf', function getPrototypeOf(target) {\n return _call(originalReflectGetProto, globals.Reflect, target);\n });\n }\n if (globals.Reflect.setPrototypeOf) {\n if (valueOrFalseIfThrows(function () {\n globals.Reflect.setPrototypeOf(1, {});\n return true;\n })) {\n overrideNative(globals.Reflect, 'setPrototypeOf', ReflectShims.setPrototypeOf);\n }\n }\n if (globals.Reflect.defineProperty) {\n if (!valueOrFalseIfThrows(function () {\n var basic = !globals.Reflect.defineProperty(1, 'test', { value: 1 });\n // \"extensible\" fails on Edge 0.12\n var extensible = typeof Object.preventExtensions !== 'function' || !globals.Reflect.defineProperty(Object.preventExtensions({}), 'test', {});\n return basic && extensible;\n })) {\n overrideNative(globals.Reflect, 'defineProperty', ReflectShims.defineProperty);\n }\n }\n if (globals.Reflect.construct) {\n if (!valueOrFalseIfThrows(function () {\n var F = function F() {};\n return globals.Reflect.construct(function () {}, [], F) instanceof F;\n })) {\n overrideNative(globals.Reflect, 'construct', ReflectShims.construct);\n }\n }\n\n if (String(new Date(NaN)) !== 'Invalid Date') {\n var dateToString = Date.prototype.toString;\n var shimmedDateToString = function toString() {\n var valueOf = +this;\n if (valueOf !== valueOf) {\n return 'Invalid Date';\n }\n return ES.Call(dateToString, this);\n };\n overrideNative(Date.prototype, 'toString', shimmedDateToString);\n }\n\n // Annex B HTML methods\n // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-additional-properties-of-the-string.prototype-object\n var stringHTMLshims = {\n anchor: function anchor(name) { return ES.CreateHTML(this, 'a', 'name', name); },\n big: function big() { return ES.CreateHTML(this, 'big', '', ''); },\n blink: function blink() { return ES.CreateHTML(this, 'blink', '', ''); },\n bold: function bold() { return ES.CreateHTML(this, 'b', '', ''); },\n fixed: function fixed() { return ES.CreateHTML(this, 'tt', '', ''); },\n fontcolor: function fontcolor(color) { return ES.CreateHTML(this, 'font', 'color', color); },\n fontsize: function fontsize(size) { return ES.CreateHTML(this, 'font', 'size', size); },\n italics: function italics() { return ES.CreateHTML(this, 'i', '', ''); },\n link: function link(url) { return ES.CreateHTML(this, 'a', 'href', url); },\n small: function small() { return ES.CreateHTML(this, 'small', '', ''); },\n strike: function strike() { return ES.CreateHTML(this, 'strike', '', ''); },\n sub: function sub() { return ES.CreateHTML(this, 'sub', '', ''); },\n sup: function sub() { return ES.CreateHTML(this, 'sup', '', ''); }\n };\n _forEach(Object.keys(stringHTMLshims), function (key) {\n var method = String.prototype[key];\n var shouldOverwrite = false;\n if (ES.IsCallable(method)) {\n var output = _call(method, '', ' \" ');\n var quotesCount = _concat([], output.match(/\"/g)).length;\n shouldOverwrite = output !== output.toLowerCase() || quotesCount > 2;\n } else {\n shouldOverwrite = true;\n }\n if (shouldOverwrite) {\n overrideNative(String.prototype, key, stringHTMLshims[key]);\n }\n });\n\n var JSONstringifiesSymbols = (function () {\n // Microsoft Edge v0.12 stringifies Symbols incorrectly\n if (!hasSymbols) { return false; } // Symbols are not supported\n var stringify = typeof JSON === 'object' && typeof JSON.stringify === 'function' ? JSON.stringify : null;\n if (!stringify) { return false; } // JSON.stringify is not supported\n if (typeof stringify(Symbol()) !== 'undefined') { return true; } // Symbols should become `undefined`\n if (stringify([Symbol()]) !== '[null]') { return true; } // Symbols in arrays should become `null`\n var obj = { a: Symbol() };\n obj[Symbol()] = true;\n if (stringify(obj) !== '{}') { return true; } // Symbol-valued keys *and* Symbol-valued properties should be omitted\n return false;\n }());\n var JSONstringifyAcceptsObjectSymbol = valueOrFalseIfThrows(function () {\n // Chrome 45 throws on stringifying object symbols\n if (!hasSymbols) { return true; } // Symbols are not supported\n return JSON.stringify(Object(Symbol())) === '{}' && JSON.stringify([Object(Symbol())]) === '[{}]';\n });\n if (JSONstringifiesSymbols || !JSONstringifyAcceptsObjectSymbol) {\n var origStringify = JSON.stringify;\n overrideNative(JSON, 'stringify', function stringify(value) {\n if (typeof value === 'symbol') { return; }\n var replacer;\n if (arguments.length > 1) {\n replacer = arguments[1];\n }\n var args = [value];\n if (!isArray(replacer)) {\n var replaceFn = ES.IsCallable(replacer) ? replacer : null;\n var wrappedReplacer = function (key, val) {\n var parsedValue = replaceFn ? _call(replaceFn, this, key, val) : val;\n if (typeof parsedValue !== 'symbol') {\n if (Type.symbol(parsedValue)) {\n return assignTo({})(parsedValue);\n } else {\n return parsedValue;\n }\n }\n };\n args.push(wrappedReplacer);\n } else {\n // create wrapped replacer that handles an array replacer?\n args.push(replacer);\n }\n if (arguments.length > 2) {\n args.push(arguments[2]);\n }\n return origStringify.apply(this, args);\n });\n }\n\n return globals;\n}));\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/es6-shim/es6-shim.js\n ** module id = 424\n ** module chunks = 0\n **/","/*! *****************************************************************************\r\nCopyright (C) Microsoft. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n\"use strict\";\r\nvar Reflect;\r\n(function (Reflect) {\r\n // Load global or shim versions of Map, Set, and WeakMap\r\n var functionPrototype = Object.getPrototypeOf(Function);\r\n var _Map = typeof Map === \"function\" ? Map : CreateMapPolyfill();\r\n var _Set = typeof Set === \"function\" ? Set : CreateSetPolyfill();\r\n var _WeakMap = typeof WeakMap === \"function\" ? WeakMap : CreateWeakMapPolyfill();\r\n // [[Metadata]] internal slot\r\n var __Metadata__ = new _WeakMap();\r\n /**\r\n * Applies a set of decorators to a property of a target object.\r\n * @param decorators An array of decorators.\r\n * @param target The target object.\r\n * @param targetKey (Optional) The property key to decorate.\r\n * @param targetDescriptor (Optional) The property descriptor for the target key\r\n * @remarks Decorators are applied in reverse order.\r\n * @example\r\n *\r\n * class C {\r\n * // property declarations are not part of ES6, though they are valid in TypeScript:\r\n * // static staticProperty;\r\n * // property;\r\n *\r\n * constructor(p) { }\r\n * static staticMethod(p) { }\r\n * method(p) { }\r\n * }\r\n *\r\n * // constructor\r\n * C = Reflect.decorate(decoratorsArray, C);\r\n *\r\n * // property (on constructor)\r\n * Reflect.decorate(decoratorsArray, C, \"staticProperty\");\r\n *\r\n * // property (on prototype)\r\n * Reflect.decorate(decoratorsArray, C.prototype, \"property\");\r\n *\r\n * // method (on constructor)\r\n * Object.defineProperty(C, \"staticMethod\",\r\n * Reflect.decorate(decoratorsArray, C, \"staticMethod\",\r\n * Object.getOwnPropertyDescriptor(C, \"staticMethod\")));\r\n *\r\n * // method (on prototype)\r\n * Object.defineProperty(C.prototype, \"method\",\r\n * Reflect.decorate(decoratorsArray, C.prototype, \"method\",\r\n * Object.getOwnPropertyDescriptor(C.prototype, \"method\")));\r\n *\r\n */\r\n function decorate(decorators, target, targetKey, targetDescriptor) {\r\n if (!IsUndefined(targetDescriptor)) {\r\n if (!IsArray(decorators)) {\r\n throw new TypeError();\r\n }\r\n else if (!IsObject(target)) {\r\n throw new TypeError();\r\n }\r\n else if (IsUndefined(targetKey)) {\r\n throw new TypeError();\r\n }\r\n else if (!IsObject(targetDescriptor)) {\r\n throw new TypeError();\r\n }\r\n targetKey = ToPropertyKey(targetKey);\r\n return DecoratePropertyWithDescriptor(decorators, target, targetKey, targetDescriptor);\r\n }\r\n else if (!IsUndefined(targetKey)) {\r\n if (!IsArray(decorators)) {\r\n throw new TypeError();\r\n }\r\n else if (!IsObject(target)) {\r\n throw new TypeError();\r\n }\r\n targetKey = ToPropertyKey(targetKey);\r\n return DecoratePropertyWithoutDescriptor(decorators, target, targetKey);\r\n }\r\n else {\r\n if (!IsArray(decorators)) {\r\n throw new TypeError();\r\n }\r\n else if (!IsConstructor(target)) {\r\n throw new TypeError();\r\n }\r\n return DecorateConstructor(decorators, target);\r\n }\r\n }\r\n Reflect.decorate = decorate;\r\n /**\r\n * A default metadata decorator factory that can be used on a class, class member, or parameter.\r\n * @param metadataKey The key for the metadata entry.\r\n * @param metadataValue The value for the metadata entry.\r\n * @returns A decorator function.\r\n * @remarks\r\n * If `metadataKey` is already defined for the target and target key, the\r\n * metadataValue for that key will be overwritten.\r\n * @example\r\n *\r\n * // constructor\r\n * @Reflect.metadata(key, value)\r\n * class C {\r\n * }\r\n *\r\n * // property (on constructor, TypeScript only)\r\n * class C {\r\n * @Reflect.metadata(key, value)\r\n * static staticProperty;\r\n * }\r\n *\r\n * // property (on prototype, TypeScript only)\r\n * class C {\r\n * @Reflect.metadata(key, value)\r\n * property;\r\n * }\r\n *\r\n * // method (on constructor)\r\n * class C {\r\n * @Reflect.metadata(key, value)\r\n * static staticMethod() { }\r\n * }\r\n *\r\n * // method (on prototype)\r\n * class C {\r\n * @Reflect.metadata(key, value)\r\n * method() { }\r\n * }\r\n *\r\n */\r\n function metadata(metadataKey, metadataValue) {\r\n function decorator(target, targetKey) {\r\n if (!IsUndefined(targetKey)) {\r\n if (!IsObject(target)) {\r\n throw new TypeError();\r\n }\r\n targetKey = ToPropertyKey(targetKey);\r\n OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, targetKey);\r\n }\r\n else {\r\n if (!IsConstructor(target)) {\r\n throw new TypeError();\r\n }\r\n OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, undefined);\r\n }\r\n }\r\n return decorator;\r\n }\r\n Reflect.metadata = metadata;\r\n /**\r\n * Define a unique metadata entry on the target.\r\n * @param metadataKey A key used to store and retrieve metadata.\r\n * @param metadataValue A value that contains attached metadata.\r\n * @param target The target object on which to define metadata.\r\n * @param targetKey (Optional) The property key for the target.\r\n * @example\r\n *\r\n * class C {\r\n * // property declarations are not part of ES6, though they are valid in TypeScript:\r\n * // static staticProperty;\r\n * // property;\r\n *\r\n * constructor(p) { }\r\n * static staticMethod(p) { }\r\n * method(p) { }\r\n * }\r\n *\r\n * // constructor\r\n * Reflect.defineMetadata(\"custom:annotation\", options, C);\r\n *\r\n * // property (on constructor)\r\n * Reflect.defineMetadata(\"custom:annotation\", options, C, \"staticProperty\");\r\n *\r\n * // property (on prototype)\r\n * Reflect.defineMetadata(\"custom:annotation\", options, C.prototype, \"property\");\r\n *\r\n * // method (on constructor)\r\n * Reflect.defineMetadata(\"custom:annotation\", options, C, \"staticMethod\");\r\n *\r\n * // method (on prototype)\r\n * Reflect.defineMetadata(\"custom:annotation\", options, C.prototype, \"method\");\r\n *\r\n * // decorator factory as metadata-producing annotation.\r\n * function MyAnnotation(options): Decorator {\r\n * return (target, key?) => Reflect.defineMetadata(\"custom:annotation\", options, target, key);\r\n * }\r\n *\r\n */\r\n function defineMetadata(metadataKey, metadataValue, target, targetKey) {\r\n if (!IsObject(target)) {\r\n throw new TypeError();\r\n }\r\n else if (!IsUndefined(targetKey)) {\r\n targetKey = ToPropertyKey(targetKey);\r\n }\r\n return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, targetKey);\r\n }\r\n Reflect.defineMetadata = defineMetadata;\r\n /**\r\n * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.\r\n * @param metadataKey A key used to store and retrieve metadata.\r\n * @param target The target object on which the metadata is defined.\r\n * @param targetKey (Optional) The property key for the target.\r\n * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.\r\n * @example\r\n *\r\n * class C {\r\n * // property declarations are not part of ES6, though they are valid in TypeScript:\r\n * // static staticProperty;\r\n * // property;\r\n *\r\n * constructor(p) { }\r\n * static staticMethod(p) { }\r\n * method(p) { }\r\n * }\r\n *\r\n * // constructor\r\n * result = Reflect.hasMetadata(\"custom:annotation\", C);\r\n *\r\n * // property (on constructor)\r\n * result = Reflect.hasMetadata(\"custom:annotation\", C, \"staticProperty\");\r\n *\r\n * // property (on prototype)\r\n * result = Reflect.hasMetadata(\"custom:annotation\", C.prototype, \"property\");\r\n *\r\n * // method (on constructor)\r\n * result = Reflect.hasMetadata(\"custom:annotation\", C, \"staticMethod\");\r\n *\r\n * // method (on prototype)\r\n * result = Reflect.hasMetadata(\"custom:annotation\", C.prototype, \"method\");\r\n *\r\n */\r\n function hasMetadata(metadataKey, target, targetKey) {\r\n if (!IsObject(target)) {\r\n throw new TypeError();\r\n }\r\n else if (!IsUndefined(targetKey)) {\r\n targetKey = ToPropertyKey(targetKey);\r\n }\r\n return OrdinaryHasMetadata(metadataKey, target, targetKey);\r\n }\r\n Reflect.hasMetadata = hasMetadata;\r\n /**\r\n * Gets a value indicating whether the target object has the provided metadata key defined.\r\n * @param metadataKey A key used to store and retrieve metadata.\r\n * @param target The target object on which the metadata is defined.\r\n * @param targetKey (Optional) The property key for the target.\r\n * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.\r\n * @example\r\n *\r\n * class C {\r\n * // property declarations are not part of ES6, though they are valid in TypeScript:\r\n * // static staticProperty;\r\n * // property;\r\n *\r\n * constructor(p) { }\r\n * static staticMethod(p) { }\r\n * method(p) { }\r\n * }\r\n *\r\n * // constructor\r\n * result = Reflect.hasOwnMetadata(\"custom:annotation\", C);\r\n *\r\n * // property (on constructor)\r\n * result = Reflect.hasOwnMetadata(\"custom:annotation\", C, \"staticProperty\");\r\n *\r\n * // property (on prototype)\r\n * result = Reflect.hasOwnMetadata(\"custom:annotation\", C.prototype, \"property\");\r\n *\r\n * // method (on constructor)\r\n * result = Reflect.hasOwnMetadata(\"custom:annotation\", C, \"staticMethod\");\r\n *\r\n * // method (on prototype)\r\n * result = Reflect.hasOwnMetadata(\"custom:annotation\", C.prototype, \"method\");\r\n *\r\n */\r\n function hasOwnMetadata(metadataKey, target, targetKey) {\r\n if (!IsObject(target)) {\r\n throw new TypeError();\r\n }\r\n else if (!IsUndefined(targetKey)) {\r\n targetKey = ToPropertyKey(targetKey);\r\n }\r\n return OrdinaryHasOwnMetadata(metadataKey, target, targetKey);\r\n }\r\n Reflect.hasOwnMetadata = hasOwnMetadata;\r\n /**\r\n * Gets the metadata value for the provided metadata key on the target object or its prototype chain.\r\n * @param metadataKey A key used to store and retrieve metadata.\r\n * @param target The target object on which the metadata is defined.\r\n * @param targetKey (Optional) The property key for the target.\r\n * @returns The metadata value for the metadata key if found; otherwise, `undefined`.\r\n * @example\r\n *\r\n * class C {\r\n * // property declarations are not part of ES6, though they are valid in TypeScript:\r\n * // static staticProperty;\r\n * // property;\r\n *\r\n * constructor(p) { }\r\n * static staticMethod(p) { }\r\n * method(p) { }\r\n * }\r\n *\r\n * // constructor\r\n * result = Reflect.getMetadata(\"custom:annotation\", C);\r\n *\r\n * // property (on constructor)\r\n * result = Reflect.getMetadata(\"custom:annotation\", C, \"staticProperty\");\r\n *\r\n * // property (on prototype)\r\n * result = Reflect.getMetadata(\"custom:annotation\", C.prototype, \"property\");\r\n *\r\n * // method (on constructor)\r\n * result = Reflect.getMetadata(\"custom:annotation\", C, \"staticMethod\");\r\n *\r\n * // method (on prototype)\r\n * result = Reflect.getMetadata(\"custom:annotation\", C.prototype, \"method\");\r\n *\r\n */\r\n function getMetadata(metadataKey, target, targetKey) {\r\n if (!IsObject(target)) {\r\n throw new TypeError();\r\n }\r\n else if (!IsUndefined(targetKey)) {\r\n targetKey = ToPropertyKey(targetKey);\r\n }\r\n return OrdinaryGetMetadata(metadataKey, target, targetKey);\r\n }\r\n Reflect.getMetadata = getMetadata;\r\n /**\r\n * Gets the metadata value for the provided metadata key on the target object.\r\n * @param metadataKey A key used to store and retrieve metadata.\r\n * @param target The target object on which the metadata is defined.\r\n * @param targetKey (Optional) The property key for the target.\r\n * @returns The metadata value for the metadata key if found; otherwise, `undefined`.\r\n * @example\r\n *\r\n * class C {\r\n * // property declarations are not part of ES6, though they are valid in TypeScript:\r\n * // static staticProperty;\r\n * // property;\r\n *\r\n * constructor(p) { }\r\n * static staticMethod(p) { }\r\n * method(p) { }\r\n * }\r\n *\r\n * // constructor\r\n * result = Reflect.getOwnMetadata(\"custom:annotation\", C);\r\n *\r\n * // property (on constructor)\r\n * result = Reflect.getOwnMetadata(\"custom:annotation\", C, \"staticProperty\");\r\n *\r\n * // property (on prototype)\r\n * result = Reflect.getOwnMetadata(\"custom:annotation\", C.prototype, \"property\");\r\n *\r\n * // method (on constructor)\r\n * result = Reflect.getOwnMetadata(\"custom:annotation\", C, \"staticMethod\");\r\n *\r\n * // method (on prototype)\r\n * result = Reflect.getOwnMetadata(\"custom:annotation\", C.prototype, \"method\");\r\n *\r\n */\r\n function getOwnMetadata(metadataKey, target, targetKey) {\r\n if (!IsObject(target)) {\r\n throw new TypeError();\r\n }\r\n else if (!IsUndefined(targetKey)) {\r\n targetKey = ToPropertyKey(targetKey);\r\n }\r\n return OrdinaryGetOwnMetadata(metadataKey, target, targetKey);\r\n }\r\n Reflect.getOwnMetadata = getOwnMetadata;\r\n /**\r\n * Gets the metadata keys defined on the target object or its prototype chain.\r\n * @param target The target object on which the metadata is defined.\r\n * @param targetKey (Optional) The property key for the target.\r\n * @returns An array of unique metadata keys.\r\n * @example\r\n *\r\n * class C {\r\n * // property declarations are not part of ES6, though they are valid in TypeScript:\r\n * // static staticProperty;\r\n * // property;\r\n *\r\n * constructor(p) { }\r\n * static staticMethod(p) { }\r\n * method(p) { }\r\n * }\r\n *\r\n * // constructor\r\n * result = Reflect.getMetadataKeys(C);\r\n *\r\n * // property (on constructor)\r\n * result = Reflect.getMetadataKeys(C, \"staticProperty\");\r\n *\r\n * // property (on prototype)\r\n * result = Reflect.getMetadataKeys(C.prototype, \"property\");\r\n *\r\n * // method (on constructor)\r\n * result = Reflect.getMetadataKeys(C, \"staticMethod\");\r\n *\r\n * // method (on prototype)\r\n * result = Reflect.getMetadataKeys(C.prototype, \"method\");\r\n *\r\n */\r\n function getMetadataKeys(target, targetKey) {\r\n if (!IsObject(target)) {\r\n throw new TypeError();\r\n }\r\n else if (!IsUndefined(targetKey)) {\r\n targetKey = ToPropertyKey(targetKey);\r\n }\r\n return OrdinaryMetadataKeys(target, targetKey);\r\n }\r\n Reflect.getMetadataKeys = getMetadataKeys;\r\n /**\r\n * Gets the unique metadata keys defined on the target object.\r\n * @param target The target object on which the metadata is defined.\r\n * @param targetKey (Optional) The property key for the target.\r\n * @returns An array of unique metadata keys.\r\n * @example\r\n *\r\n * class C {\r\n * // property declarations are not part of ES6, though they are valid in TypeScript:\r\n * // static staticProperty;\r\n * // property;\r\n *\r\n * constructor(p) { }\r\n * static staticMethod(p) { }\r\n * method(p) { }\r\n * }\r\n *\r\n * // constructor\r\n * result = Reflect.getOwnMetadataKeys(C);\r\n *\r\n * // property (on constructor)\r\n * result = Reflect.getOwnMetadataKeys(C, \"staticProperty\");\r\n *\r\n * // property (on prototype)\r\n * result = Reflect.getOwnMetadataKeys(C.prototype, \"property\");\r\n *\r\n * // method (on constructor)\r\n * result = Reflect.getOwnMetadataKeys(C, \"staticMethod\");\r\n *\r\n * // method (on prototype)\r\n * result = Reflect.getOwnMetadataKeys(C.prototype, \"method\");\r\n *\r\n */\r\n function getOwnMetadataKeys(target, targetKey) {\r\n if (!IsObject(target)) {\r\n throw new TypeError();\r\n }\r\n else if (!IsUndefined(targetKey)) {\r\n targetKey = ToPropertyKey(targetKey);\r\n }\r\n return OrdinaryOwnMetadataKeys(target, targetKey);\r\n }\r\n Reflect.getOwnMetadataKeys = getOwnMetadataKeys;\r\n /**\r\n * Deletes the metadata entry from the target object with the provided key.\r\n * @param metadataKey A key used to store and retrieve metadata.\r\n * @param target The target object on which the metadata is defined.\r\n * @param targetKey (Optional) The property key for the target.\r\n * @returns `true` if the metadata entry was found and deleted; otherwise, false.\r\n * @example\r\n *\r\n * class C {\r\n * // property declarations are not part of ES6, though they are valid in TypeScript:\r\n * // static staticProperty;\r\n * // property;\r\n *\r\n * constructor(p) { }\r\n * static staticMethod(p) { }\r\n * method(p) { }\r\n * }\r\n *\r\n * // constructor\r\n * result = Reflect.deleteMetadata(\"custom:annotation\", C);\r\n *\r\n * // property (on constructor)\r\n * result = Reflect.deleteMetadata(\"custom:annotation\", C, \"staticProperty\");\r\n *\r\n * // property (on prototype)\r\n * result = Reflect.deleteMetadata(\"custom:annotation\", C.prototype, \"property\");\r\n *\r\n * // method (on constructor)\r\n * result = Reflect.deleteMetadata(\"custom:annotation\", C, \"staticMethod\");\r\n *\r\n * // method (on prototype)\r\n * result = Reflect.deleteMetadata(\"custom:annotation\", C.prototype, \"method\");\r\n *\r\n */\r\n function deleteMetadata(metadataKey, target, targetKey) {\r\n if (!IsObject(target)) {\r\n throw new TypeError();\r\n }\r\n else if (!IsUndefined(targetKey)) {\r\n targetKey = ToPropertyKey(targetKey);\r\n }\r\n // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#deletemetadata-metadatakey-p-\r\n var metadataMap = GetOrCreateMetadataMap(target, targetKey, false);\r\n if (IsUndefined(metadataMap)) {\r\n return false;\r\n }\r\n if (!metadataMap.delete(metadataKey)) {\r\n return false;\r\n }\r\n if (metadataMap.size > 0) {\r\n return true;\r\n }\r\n var targetMetadata = __Metadata__.get(target);\r\n targetMetadata.delete(targetKey);\r\n if (targetMetadata.size > 0) {\r\n return true;\r\n }\r\n __Metadata__.delete(target);\r\n return true;\r\n }\r\n Reflect.deleteMetadata = deleteMetadata;\r\n function DecorateConstructor(decorators, target) {\r\n for (var i = decorators.length - 1; i >= 0; --i) {\r\n var decorator = decorators[i];\r\n var decorated = decorator(target);\r\n if (!IsUndefined(decorated)) {\r\n if (!IsConstructor(decorated)) {\r\n throw new TypeError();\r\n }\r\n target = decorated;\r\n }\r\n }\r\n return target;\r\n }\r\n function DecoratePropertyWithDescriptor(decorators, target, propertyKey, descriptor) {\r\n for (var i = decorators.length - 1; i >= 0; --i) {\r\n var decorator = decorators[i];\r\n var decorated = decorator(target, propertyKey, descriptor);\r\n if (!IsUndefined(decorated)) {\r\n if (!IsObject(decorated)) {\r\n throw new TypeError();\r\n }\r\n descriptor = decorated;\r\n }\r\n }\r\n return descriptor;\r\n }\r\n function DecoratePropertyWithoutDescriptor(decorators, target, propertyKey) {\r\n for (var i = decorators.length - 1; i >= 0; --i) {\r\n var decorator = decorators[i];\r\n decorator(target, propertyKey);\r\n }\r\n }\r\n // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#getorcreatemetadatamap--o-p-create-\r\n function GetOrCreateMetadataMap(target, targetKey, create) {\r\n var targetMetadata = __Metadata__.get(target);\r\n if (!targetMetadata) {\r\n if (!create) {\r\n return undefined;\r\n }\r\n targetMetadata = new _Map();\r\n __Metadata__.set(target, targetMetadata);\r\n }\r\n var keyMetadata = targetMetadata.get(targetKey);\r\n if (!keyMetadata) {\r\n if (!create) {\r\n return undefined;\r\n }\r\n keyMetadata = new _Map();\r\n targetMetadata.set(targetKey, keyMetadata);\r\n }\r\n return keyMetadata;\r\n }\r\n // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinaryhasmetadata--metadatakey-o-p-\r\n function OrdinaryHasMetadata(MetadataKey, O, P) {\r\n var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);\r\n if (hasOwn) {\r\n return true;\r\n }\r\n var parent = GetPrototypeOf(O);\r\n if (parent !== null) {\r\n return OrdinaryHasMetadata(MetadataKey, parent, P);\r\n }\r\n return false;\r\n }\r\n // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinaryhasownmetadata--metadatakey-o-p-\r\n function OrdinaryHasOwnMetadata(MetadataKey, O, P) {\r\n var metadataMap = GetOrCreateMetadataMap(O, P, false);\r\n if (metadataMap === undefined) {\r\n return false;\r\n }\r\n return Boolean(metadataMap.has(MetadataKey));\r\n }\r\n // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarygetmetadata--metadatakey-o-p-\r\n function OrdinaryGetMetadata(MetadataKey, O, P) {\r\n var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);\r\n if (hasOwn) {\r\n return OrdinaryGetOwnMetadata(MetadataKey, O, P);\r\n }\r\n var parent = GetPrototypeOf(O);\r\n if (parent !== null) {\r\n return OrdinaryGetMetadata(MetadataKey, parent, P);\r\n }\r\n return undefined;\r\n }\r\n // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarygetownmetadata--metadatakey-o-p-\r\n function OrdinaryGetOwnMetadata(MetadataKey, O, P) {\r\n var metadataMap = GetOrCreateMetadataMap(O, P, false);\r\n if (metadataMap === undefined) {\r\n return undefined;\r\n }\r\n return metadataMap.get(MetadataKey);\r\n }\r\n // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarydefineownmetadata--metadatakey-metadatavalue-o-p-\r\n function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {\r\n var metadataMap = GetOrCreateMetadataMap(O, P, true);\r\n metadataMap.set(MetadataKey, MetadataValue);\r\n }\r\n // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarymetadatakeys--o-p-\r\n function OrdinaryMetadataKeys(O, P) {\r\n var ownKeys = OrdinaryOwnMetadataKeys(O, P);\r\n var parent = GetPrototypeOf(O);\r\n if (parent === null) {\r\n return ownKeys;\r\n }\r\n var parentKeys = OrdinaryMetadataKeys(parent, P);\r\n if (parentKeys.length <= 0) {\r\n return ownKeys;\r\n }\r\n if (ownKeys.length <= 0) {\r\n return parentKeys;\r\n }\r\n var set = new _Set();\r\n var keys = [];\r\n for (var _i = 0; _i < ownKeys.length; _i++) {\r\n var key = ownKeys[_i];\r\n var hasKey = set.has(key);\r\n if (!hasKey) {\r\n set.add(key);\r\n keys.push(key);\r\n }\r\n }\r\n for (var _a = 0; _a < parentKeys.length; _a++) {\r\n var key = parentKeys[_a];\r\n var hasKey = set.has(key);\r\n if (!hasKey) {\r\n set.add(key);\r\n keys.push(key);\r\n }\r\n }\r\n return keys;\r\n }\r\n // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinaryownmetadatakeys--o-p-\r\n function OrdinaryOwnMetadataKeys(target, targetKey) {\r\n var metadataMap = GetOrCreateMetadataMap(target, targetKey, false);\r\n var keys = [];\r\n if (metadataMap) {\r\n metadataMap.forEach(function (_, key) { return keys.push(key); });\r\n }\r\n return keys;\r\n }\r\n // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ecmascript-language-types-undefined-type\r\n function IsUndefined(x) {\r\n return x === undefined;\r\n }\r\n // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isarray\r\n function IsArray(x) {\r\n return Array.isArray(x);\r\n }\r\n // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object-type\r\n function IsObject(x) {\r\n return typeof x === \"object\" ? x !== null : typeof x === \"function\";\r\n }\r\n // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isconstructor\r\n function IsConstructor(x) {\r\n return typeof x === \"function\";\r\n }\r\n // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ecmascript-language-types-symbol-type\r\n function IsSymbol(x) {\r\n return typeof x === \"symbol\";\r\n }\r\n // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-topropertykey\r\n function ToPropertyKey(value) {\r\n if (IsSymbol(value)) {\r\n return value;\r\n }\r\n return String(value);\r\n }\r\n function GetPrototypeOf(O) {\r\n var proto = Object.getPrototypeOf(O);\r\n if (typeof O !== \"function\" || O === functionPrototype) {\r\n return proto;\r\n }\r\n // TypeScript doesn't set __proto__ in ES5, as it's non-standard. \r\n // Try to determine the superclass constructor. Compatible implementations\r\n // must either set __proto__ on a subclass constructor to the superclass constructor,\r\n // or ensure each class has a valid `constructor` property on its prototype that\r\n // points back to the constructor.\r\n // If this is not the same as Function.[[Prototype]], then this is definately inherited.\r\n // This is the case when in ES6 or when using __proto__ in a compatible browser.\r\n if (proto !== functionPrototype) {\r\n return proto;\r\n }\r\n // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage.\r\n var prototype = O.prototype;\r\n var prototypeProto = Object.getPrototypeOf(prototype);\r\n if (prototypeProto == null || prototypeProto === Object.prototype) {\r\n return proto;\r\n }\r\n // if the constructor was not a function, then we cannot determine the heritage.\r\n var constructor = prototypeProto.constructor;\r\n if (typeof constructor !== \"function\") {\r\n return proto;\r\n }\r\n // if we have some kind of self-reference, then we cannot determine the heritage.\r\n if (constructor === O) {\r\n return proto;\r\n }\r\n // we have a pretty good guess at the heritage.\r\n return constructor;\r\n }\r\n // naive Map shim\r\n function CreateMapPolyfill() {\r\n var cacheSentinel = {};\r\n function Map() {\r\n this._keys = [];\r\n this._values = [];\r\n this._cache = cacheSentinel;\r\n }\r\n Map.prototype = {\r\n get size() {\r\n return this._keys.length;\r\n },\r\n has: function (key) {\r\n if (key === this._cache) {\r\n return true;\r\n }\r\n if (this._find(key) >= 0) {\r\n this._cache = key;\r\n return true;\r\n }\r\n return false;\r\n },\r\n get: function (key) {\r\n var index = this._find(key);\r\n if (index >= 0) {\r\n this._cache = key;\r\n return this._values[index];\r\n }\r\n return undefined;\r\n },\r\n set: function (key, value) {\r\n this.delete(key);\r\n this._keys.push(key);\r\n this._values.push(value);\r\n this._cache = key;\r\n return this;\r\n },\r\n delete: function (key) {\r\n var index = this._find(key);\r\n if (index >= 0) {\r\n this._keys.splice(index, 1);\r\n this._values.splice(index, 1);\r\n this._cache = cacheSentinel;\r\n return true;\r\n }\r\n return false;\r\n },\r\n clear: function () {\r\n this._keys.length = 0;\r\n this._values.length = 0;\r\n this._cache = cacheSentinel;\r\n },\r\n forEach: function (callback, thisArg) {\r\n var size = this.size;\r\n for (var i = 0; i < size; ++i) {\r\n var key = this._keys[i];\r\n var value = this._values[i];\r\n this._cache = key;\r\n callback.call(this, value, key, this);\r\n }\r\n },\r\n _find: function (key) {\r\n var keys = this._keys;\r\n var size = keys.length;\r\n for (var i = 0; i < size; ++i) {\r\n if (keys[i] === key) {\r\n return i;\r\n }\r\n }\r\n return -1;\r\n }\r\n };\r\n return Map;\r\n }\r\n // naive Set shim\r\n function CreateSetPolyfill() {\r\n var cacheSentinel = {};\r\n function Set() {\r\n this._map = new _Map();\r\n }\r\n Set.prototype = {\r\n get size() {\r\n return this._map.length;\r\n },\r\n has: function (value) {\r\n return this._map.has(value);\r\n },\r\n add: function (value) {\r\n this._map.set(value, value);\r\n return this;\r\n },\r\n delete: function (value) {\r\n return this._map.delete(value);\r\n },\r\n clear: function () {\r\n this._map.clear();\r\n },\r\n forEach: function (callback, thisArg) {\r\n this._map.forEach(callback, thisArg);\r\n }\r\n };\r\n return Set;\r\n }\r\n // naive WeakMap shim\r\n function CreateWeakMapPolyfill() {\r\n var UUID_SIZE = 16;\r\n var isNode = typeof global !== \"undefined\" && Object.prototype.toString.call(global.process) === '[object process]';\r\n var nodeCrypto = isNode && require(\"crypto\");\r\n var hasOwn = Object.prototype.hasOwnProperty;\r\n var keys = {};\r\n var rootKey = CreateUniqueKey();\r\n function WeakMap() {\r\n this._key = CreateUniqueKey();\r\n }\r\n WeakMap.prototype = {\r\n has: function (target) {\r\n var table = GetOrCreateWeakMapTable(target, false);\r\n if (table) {\r\n return this._key in table;\r\n }\r\n return false;\r\n },\r\n get: function (target) {\r\n var table = GetOrCreateWeakMapTable(target, false);\r\n if (table) {\r\n return table[this._key];\r\n }\r\n return undefined;\r\n },\r\n set: function (target, value) {\r\n var table = GetOrCreateWeakMapTable(target, true);\r\n table[this._key] = value;\r\n return this;\r\n },\r\n delete: function (target) {\r\n var table = GetOrCreateWeakMapTable(target, false);\r\n if (table && this._key in table) {\r\n return delete table[this._key];\r\n }\r\n return false;\r\n },\r\n clear: function () {\r\n // NOTE: not a real clear, just makes the previous data unreachable\r\n this._key = CreateUniqueKey();\r\n }\r\n };\r\n function FillRandomBytes(buffer, size) {\r\n for (var i = 0; i < size; ++i) {\r\n buffer[i] = Math.random() * 255 | 0;\r\n }\r\n }\r\n function GenRandomBytes(size) {\r\n if (nodeCrypto) {\r\n var data = nodeCrypto.randomBytes(size);\r\n return data;\r\n }\r\n else if (typeof Uint8Array === \"function\") {\r\n var data = new Uint8Array(size);\r\n if (typeof crypto !== \"undefined\") {\r\n crypto.getRandomValues(data);\r\n }\r\n else if (typeof msCrypto !== \"undefined\") {\r\n msCrypto.getRandomValues(data);\r\n }\r\n else {\r\n FillRandomBytes(data, size);\r\n }\r\n return data;\r\n }\r\n else {\r\n var data = new Array(size);\r\n FillRandomBytes(data, size);\r\n return data;\r\n }\r\n }\r\n function CreateUUID() {\r\n var data = GenRandomBytes(UUID_SIZE);\r\n // mark as random - RFC 4122 § 4.4\r\n data[6] = data[6] & 0x4f | 0x40;\r\n data[8] = data[8] & 0xbf | 0x80;\r\n var result = \"\";\r\n for (var offset = 0; offset < UUID_SIZE; ++offset) {\r\n var byte = data[offset];\r\n if (offset === 4 || offset === 6 || offset === 8) {\r\n result += \"-\";\r\n }\r\n if (byte < 16) {\r\n result += \"0\";\r\n }\r\n result += byte.toString(16).toLowerCase();\r\n }\r\n return result;\r\n }\r\n function CreateUniqueKey() {\r\n var key;\r\n do {\r\n key = \"@@WeakMap@@\" + CreateUUID();\r\n } while (hasOwn.call(keys, key));\r\n keys[key] = true;\r\n return key;\r\n }\r\n function GetOrCreateWeakMapTable(target, create) {\r\n if (!hasOwn.call(target, rootKey)) {\r\n if (!create) {\r\n return undefined;\r\n }\r\n Object.defineProperty(target, rootKey, { value: Object.create(null) });\r\n }\r\n return target[rootKey];\r\n }\r\n return WeakMap;\r\n }\r\n // hook global Reflect\r\n (function (__global) {\r\n if (typeof __global.Reflect !== \"undefined\") {\r\n if (__global.Reflect !== Reflect) {\r\n for (var p in Reflect) {\r\n __global.Reflect[p] = Reflect[p];\r\n }\r\n }\r\n }\r\n else {\r\n __global.Reflect = Reflect;\r\n }\r\n })(typeof window !== \"undefined\" ? window :\r\n typeof WorkerGlobalScope !== \"undefined\" ? self :\r\n typeof global !== \"undefined\" ? global :\r\n Function(\"return this;\")());\r\n})(Reflect || (Reflect = {}));\r\n//# sourceMappingURL=Reflect.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/reflect-metadata/Reflect.js\n ** module id = 443\n ** module chunks = 0\n **/","\"use strict\";\nexports.empty = {\n isUnsubscribed: true,\n next: function (value) { },\n error: function (err) { throw err; },\n complete: function () { }\n};\n//# sourceMappingURL=Observer.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/rxjs/Observer.js\n ** module id = 444\n ** module chunks = 0\n **/","\"use strict\";\nvar __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};\nvar Subscription_1 = require('./Subscription');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SubjectSubscription = (function (_super) {\n __extends(SubjectSubscription, _super);\n function SubjectSubscription(subject, observer) {\n _super.call(this);\n this.subject = subject;\n this.observer = observer;\n this.isUnsubscribed = false;\n }\n SubjectSubscription.prototype.unsubscribe = function () {\n if (this.isUnsubscribed) {\n return;\n }\n this.isUnsubscribed = true;\n var subject = this.subject;\n var observers = subject.observers;\n this.subject = null;\n if (!observers || observers.length === 0 || subject.isUnsubscribed) {\n return;\n }\n var subscriberIndex = observers.indexOf(this.observer);\n if (subscriberIndex !== -1) {\n observers.splice(subscriberIndex, 1);\n }\n };\n return SubjectSubscription;\n}(Subscription_1.Subscription));\nexports.SubjectSubscription = SubjectSubscription;\n//# sourceMappingURL=SubjectSubscription.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/rxjs/SubjectSubscription.js\n ** module id = 445\n ** module chunks = 0\n **/","\"use strict\";\nvar root_1 = require('../util/root');\nvar Symbol = root_1.root.Symbol;\nif (typeof Symbol === 'function') {\n if (Symbol.observable) {\n exports.$$observable = Symbol.observable;\n }\n else {\n if (typeof Symbol.for === 'function') {\n exports.$$observable = Symbol.for('observable');\n }\n else {\n exports.$$observable = Symbol('observable');\n }\n Symbol.observable = exports.$$observable;\n }\n}\nelse {\n exports.$$observable = '@@observable';\n}\n//# sourceMappingURL=observable.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/rxjs/symbol/observable.js\n ** module id = 446\n ** module chunks = 0\n **/","\"use strict\";\nvar __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/**\n * An error thrown when an action is invalid because the object has been\n * unsubscribed.\n *\n * @see {@link Subject}\n * @see {@link BehaviorSubject}\n *\n * @class ObjectUnsubscribedError\n */\nvar ObjectUnsubscribedError = (function (_super) {\n __extends(ObjectUnsubscribedError, _super);\n function ObjectUnsubscribedError() {\n _super.call(this, 'object unsubscribed');\n this.name = 'ObjectUnsubscribedError';\n }\n return ObjectUnsubscribedError;\n}(Error));\nexports.ObjectUnsubscribedError = ObjectUnsubscribedError;\n//# sourceMappingURL=ObjectUnsubscribedError.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/rxjs/util/ObjectUnsubscribedError.js\n ** module id = 447\n ** module chunks = 0\n **/","\"use strict\";\nvar __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/**\n * An error thrown when one or more errors have occurred during the\n * `unsubscribe` of a {@link Subscription}.\n */\nvar UnsubscriptionError = (function (_super) {\n __extends(UnsubscriptionError, _super);\n function UnsubscriptionError(errors) {\n _super.call(this);\n this.errors = errors;\n this.name = 'UnsubscriptionError';\n this.message = errors ? errors.length + \" errors occurred during unsubscription:\\n\" + errors.map(function (err, i) { return ((i + 1) + \") \" + err.toString()); }).join('\\n') : '';\n }\n return UnsubscriptionError;\n}(Error));\nexports.UnsubscriptionError = UnsubscriptionError;\n//# sourceMappingURL=UnsubscriptionError.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/rxjs/util/UnsubscriptionError.js\n ** module id = 448\n ** module chunks = 0\n **/","\"use strict\";\nexports.isArray = Array.isArray || (function (x) { return x && typeof x.length === 'number'; });\n//# sourceMappingURL=isArray.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/rxjs/util/isArray.js\n ** module id = 449\n ** module chunks = 0\n **/","\"use strict\";\nfunction isObject(x) {\n return x != null && typeof x === 'object';\n}\nexports.isObject = isObject;\n//# sourceMappingURL=isObject.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/rxjs/util/isObject.js\n ** module id = 450\n ** module chunks = 0\n **/","\"use strict\";\nfunction throwError(e) { throw e; }\nexports.throwError = throwError;\n//# sourceMappingURL=throwError.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/rxjs/util/throwError.js\n ** module id = 451\n ** module chunks = 0\n **/","\"use strict\";\nvar Subscriber_1 = require('../Subscriber');\nvar rxSubscriber_1 = require('../symbol/rxSubscriber');\nfunction toSubscriber(nextOrObserver, error, complete) {\n if (nextOrObserver && typeof nextOrObserver === 'object') {\n if (nextOrObserver instanceof Subscriber_1.Subscriber) {\n return nextOrObserver;\n }\n else if (typeof nextOrObserver[rxSubscriber_1.$$rxSubscriber] === 'function') {\n return nextOrObserver[rxSubscriber_1.$$rxSubscriber]();\n }\n }\n return new Subscriber_1.Subscriber(nextOrObserver, error, complete);\n}\nexports.toSubscriber = toSubscriber;\n//# sourceMappingURL=toSubscriber.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/rxjs/util/toSubscriber.js\n ** module id = 452\n ** module chunks = 0\n **/","\"use strict\";\nvar errorObject_1 = require('./errorObject');\nvar tryCatchTarget;\nfunction tryCatcher() {\n try {\n return tryCatchTarget.apply(this, arguments);\n }\n catch (e) {\n errorObject_1.errorObject.e = e;\n return errorObject_1.errorObject;\n }\n}\nfunction tryCatch(fn) {\n tryCatchTarget = fn;\n return tryCatcher;\n}\nexports.tryCatch = tryCatch;\n;\n//# sourceMappingURL=tryCatch.js.map\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/rxjs/util/tryCatch.js\n ** module id = 453\n ** module chunks = 0\n **/","module.exports = function() { throw new Error(\"define cannot be used indirect\"); };\r\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)/buildin/amd-define.js\n ** module id = 456\n ** module chunks = 0\n **/","/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\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\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/* 0 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {\"use strict\";\n\t__webpack_require__(1);\n\tvar event_target_1 = __webpack_require__(2);\n\tvar define_property_1 = __webpack_require__(4);\n\tvar register_element_1 = __webpack_require__(5);\n\tvar property_descriptor_1 = __webpack_require__(6);\n\tvar timers_1 = __webpack_require__(8);\n\tvar utils_1 = __webpack_require__(3);\n\tvar set = 'set';\n\tvar clear = 'clear';\n\tvar blockingMethods = ['alert', 'prompt', 'confirm'];\n\tvar _global = typeof window == 'undefined' ? global : window;\n\ttimers_1.patchTimer(_global, set, clear, 'Timeout');\n\ttimers_1.patchTimer(_global, set, clear, 'Interval');\n\ttimers_1.patchTimer(_global, set, clear, 'Immediate');\n\ttimers_1.patchTimer(_global, 'request', 'cancelMacroTask', 'AnimationFrame');\n\ttimers_1.patchTimer(_global, 'mozRequest', 'mozCancel', 'AnimationFrame');\n\ttimers_1.patchTimer(_global, 'webkitRequest', 'webkitCancel', 'AnimationFrame');\n\tfor (var i = 0; i < blockingMethods.length; i++) {\n\t var name = blockingMethods[i];\n\t utils_1.patchMethod(_global, name, function (delegate, symbol, name) {\n\t return function (s, args) {\n\t return Zone.current.run(delegate, _global, args, name);\n\t };\n\t });\n\t}\n\tevent_target_1.eventTargetPatch(_global);\n\tproperty_descriptor_1.propertyDescriptorPatch(_global);\n\tutils_1.patchClass('MutationObserver');\n\tutils_1.patchClass('WebKitMutationObserver');\n\tutils_1.patchClass('FileReader');\n\tdefine_property_1.propertyPatch();\n\tregister_element_1.registerElementPatch(_global);\n\t// Treat XMLHTTPRequest as a macrotask.\n\tpatchXHR(_global);\n\tvar XHR_TASK = utils_1.zoneSymbol('xhrTask');\n\tfunction patchXHR(window) {\n\t function findPendingTask(target) {\n\t var pendingTask = target[XHR_TASK];\n\t return pendingTask;\n\t }\n\t function scheduleTask(task) {\n\t var data = task.data;\n\t data.target.addEventListener('readystatechange', function () {\n\t if (data.target.readyState === XMLHttpRequest.DONE) {\n\t if (!data.aborted) {\n\t task.invoke();\n\t }\n\t }\n\t });\n\t var storedTask = data.target[XHR_TASK];\n\t if (!storedTask) {\n\t data.target[XHR_TASK] = task;\n\t }\n\t setNative.apply(data.target, data.args);\n\t return task;\n\t }\n\t function placeholderCallback() {\n\t }\n\t function clearTask(task) {\n\t var data = task.data;\n\t // Note - ideally, we would call data.target.removeEventListener here, but it's too late\n\t // to prevent it from firing. So instead, we store info for the event listener.\n\t data.aborted = true;\n\t return clearNative.apply(data.target, data.args);\n\t }\n\t var setNative = utils_1.patchMethod(window.XMLHttpRequest.prototype, 'send', function () { return function (self, args) {\n\t var zone = Zone.current;\n\t var options = {\n\t target: self,\n\t isPeriodic: false,\n\t delay: null,\n\t args: args,\n\t aborted: false\n\t };\n\t return zone.scheduleMacroTask('XMLHttpRequest.send', placeholderCallback, options, scheduleTask, clearTask);\n\t }; });\n\t var clearNative = utils_1.patchMethod(window.XMLHttpRequest.prototype, 'abort', function (delegate) { return function (self, args) {\n\t var task = findPendingTask(self);\n\t if (task && typeof task.type == 'string') {\n\t // If the XHR has already completed, do nothing.\n\t if (task.cancelFn == null) {\n\t return;\n\t }\n\t task.zone.cancelTask(task);\n\t }\n\t // Otherwise, we are trying to abort an XHR which has not yet been sent, so there is no task to cancel. Do nothing.\n\t }; });\n\t}\n\t/// GEO_LOCATION\n\tif (_global['navigator'] && _global['navigator'].geolocation) {\n\t utils_1.patchPrototype(_global['navigator'].geolocation, [\n\t 'getCurrentPosition',\n\t 'watchPosition'\n\t ]);\n\t}\n\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n/* 1 */\n/***/ function(module, exports) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {;\n\t;\n\tvar Zone = (function (global) {\n\t var Zone = (function () {\n\t function Zone(parent, zoneSpec) {\n\t this._properties = null;\n\t this._parent = parent;\n\t this._name = zoneSpec ? zoneSpec.name || 'unnamed' : '';\n\t this._properties = zoneSpec && zoneSpec.properties || {};\n\t this._zoneDelegate = new ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec);\n\t }\n\t Object.defineProperty(Zone, \"current\", {\n\t get: function () { return _currentZone; },\n\t enumerable: true,\n\t configurable: true\n\t });\n\t ;\n\t Object.defineProperty(Zone, \"currentTask\", {\n\t get: function () { return _currentTask; },\n\t enumerable: true,\n\t configurable: true\n\t });\n\t ;\n\t Object.defineProperty(Zone.prototype, \"parent\", {\n\t get: function () { return this._parent; },\n\t enumerable: true,\n\t configurable: true\n\t });\n\t ;\n\t Object.defineProperty(Zone.prototype, \"name\", {\n\t get: function () { return this._name; },\n\t enumerable: true,\n\t configurable: true\n\t });\n\t ;\n\t Zone.prototype.get = function (key) {\n\t var current = this;\n\t while (current) {\n\t if (current._properties.hasOwnProperty(key)) {\n\t return current._properties[key];\n\t }\n\t current = current._parent;\n\t }\n\t };\n\t Zone.prototype.fork = function (zoneSpec) {\n\t if (!zoneSpec)\n\t throw new Error('ZoneSpec required!');\n\t return this._zoneDelegate.fork(this, zoneSpec);\n\t };\n\t Zone.prototype.wrap = function (callback, source) {\n\t if (typeof callback !== 'function') {\n\t throw new Error('Expecting function got: ' + callback);\n\t }\n\t var _callback = this._zoneDelegate.intercept(this, callback, source);\n\t var zone = this;\n\t return function () {\n\t return zone.runGuarded(_callback, this, arguments, source);\n\t };\n\t };\n\t Zone.prototype.run = function (callback, applyThis, applyArgs, source) {\n\t if (applyThis === void 0) { applyThis = null; }\n\t if (applyArgs === void 0) { applyArgs = null; }\n\t if (source === void 0) { source = null; }\n\t var oldZone = _currentZone;\n\t _currentZone = this;\n\t try {\n\t return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);\n\t }\n\t finally {\n\t _currentZone = oldZone;\n\t }\n\t };\n\t Zone.prototype.runGuarded = function (callback, applyThis, applyArgs, source) {\n\t if (applyThis === void 0) { applyThis = null; }\n\t if (applyArgs === void 0) { applyArgs = null; }\n\t if (source === void 0) { source = null; }\n\t var oldZone = _currentZone;\n\t _currentZone = this;\n\t try {\n\t try {\n\t return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);\n\t }\n\t catch (error) {\n\t if (this._zoneDelegate.handleError(this, error)) {\n\t throw error;\n\t }\n\t }\n\t }\n\t finally {\n\t _currentZone = oldZone;\n\t }\n\t };\n\t Zone.prototype.runTask = function (task, applyThis, applyArgs) {\n\t task.runCount++;\n\t if (task.zone != this)\n\t throw new Error('A task can only be run in the zone which created it! (Creation: ' +\n\t task.zone.name + '; Execution: ' + this.name + ')');\n\t var previousTask = _currentTask;\n\t _currentTask = task;\n\t var oldZone = _currentZone;\n\t _currentZone = this;\n\t try {\n\t if (task.type == 'macroTask' && task.data && !task.data.isPeriodic) {\n\t task.cancelFn = null;\n\t }\n\t try {\n\t return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs);\n\t }\n\t catch (error) {\n\t if (this._zoneDelegate.handleError(this, error)) {\n\t throw error;\n\t }\n\t }\n\t }\n\t finally {\n\t _currentZone = oldZone;\n\t _currentTask = previousTask;\n\t }\n\t };\n\t Zone.prototype.scheduleMicroTask = function (source, callback, data, customSchedule) {\n\t return this._zoneDelegate.scheduleTask(this, new ZoneTask('microTask', this, source, callback, data, customSchedule, null));\n\t };\n\t Zone.prototype.scheduleMacroTask = function (source, callback, data, customSchedule, customCancel) {\n\t return this._zoneDelegate.scheduleTask(this, new ZoneTask('macroTask', this, source, callback, data, customSchedule, customCancel));\n\t };\n\t Zone.prototype.scheduleEventTask = function (source, callback, data, customSchedule, customCancel) {\n\t return this._zoneDelegate.scheduleTask(this, new ZoneTask('eventTask', this, source, callback, data, customSchedule, customCancel));\n\t };\n\t Zone.prototype.cancelTask = function (task) {\n\t var value = this._zoneDelegate.cancelTask(this, task);\n\t task.runCount = -1;\n\t task.cancelFn = null;\n\t return value;\n\t };\n\t Zone.__symbol__ = __symbol__;\n\t return Zone;\n\t }());\n\t ;\n\t var ZoneDelegate = (function () {\n\t function ZoneDelegate(zone, parentDelegate, zoneSpec) {\n\t this._taskCounts = { microTask: 0, macroTask: 0, eventTask: 0 };\n\t this.zone = zone;\n\t this._parentDelegate = parentDelegate;\n\t this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS);\n\t this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt);\n\t this._interceptZS = zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS);\n\t this._interceptDlgt = zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt);\n\t this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS);\n\t this._invokeDlgt = zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt);\n\t this._handleErrorZS = zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS);\n\t this._handleErrorDlgt = zoneSpec && (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt);\n\t this._scheduleTaskZS = zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS);\n\t this._scheduleTaskDlgt = zoneSpec && (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt);\n\t this._invokeTaskZS = zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS);\n\t this._invokeTaskDlgt = zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt);\n\t this._cancelTaskZS = zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS);\n\t this._cancelTaskDlgt = zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt);\n\t this._hasTaskZS = zoneSpec && (zoneSpec.onHasTask ? zoneSpec : parentDelegate._hasTaskZS);\n\t this._hasTaskDlgt = zoneSpec && (zoneSpec.onHasTask ? parentDelegate : parentDelegate._hasTaskDlgt);\n\t }\n\t ZoneDelegate.prototype.fork = function (targetZone, zoneSpec) {\n\t return this._forkZS\n\t ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec)\n\t : new Zone(targetZone, zoneSpec);\n\t };\n\t ZoneDelegate.prototype.intercept = function (targetZone, callback, source) {\n\t return this._interceptZS\n\t ? this._interceptZS.onIntercept(this._interceptDlgt, this.zone, targetZone, callback, source)\n\t : callback;\n\t };\n\t ZoneDelegate.prototype.invoke = function (targetZone, callback, applyThis, applyArgs, source) {\n\t return this._invokeZS\n\t ? this._invokeZS.onInvoke(this._invokeDlgt, this.zone, targetZone, callback, applyThis, applyArgs, source)\n\t : callback.apply(applyThis, applyArgs);\n\t };\n\t ZoneDelegate.prototype.handleError = function (targetZone, error) {\n\t return this._handleErrorZS\n\t ? this._handleErrorZS.onHandleError(this._handleErrorDlgt, this.zone, targetZone, error)\n\t : true;\n\t };\n\t ZoneDelegate.prototype.scheduleTask = function (targetZone, task) {\n\t try {\n\t if (this._scheduleTaskZS) {\n\t return this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt, this.zone, targetZone, task);\n\t }\n\t else if (task.scheduleFn) {\n\t task.scheduleFn(task);\n\t }\n\t else if (task.type == 'microTask') {\n\t scheduleMicroTask(task);\n\t }\n\t else {\n\t throw new Error('Task is missing scheduleFn.');\n\t }\n\t return task;\n\t }\n\t finally {\n\t if (targetZone == this.zone) {\n\t this._updateTaskCount(task.type, 1);\n\t }\n\t }\n\t };\n\t ZoneDelegate.prototype.invokeTask = function (targetZone, task, applyThis, applyArgs) {\n\t try {\n\t return this._invokeTaskZS\n\t ? this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt, this.zone, targetZone, task, applyThis, applyArgs)\n\t : task.callback.apply(applyThis, applyArgs);\n\t }\n\t finally {\n\t if (targetZone == this.zone && (task.type != 'eventTask') && !(task.data && task.data.isPeriodic)) {\n\t this._updateTaskCount(task.type, -1);\n\t }\n\t }\n\t };\n\t ZoneDelegate.prototype.cancelTask = function (targetZone, task) {\n\t var value;\n\t if (this._cancelTaskZS) {\n\t value = this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt, this.zone, targetZone, task);\n\t }\n\t else if (!task.cancelFn) {\n\t throw new Error('Task does not support cancellation, or is already canceled.');\n\t }\n\t else {\n\t value = task.cancelFn(task);\n\t }\n\t if (targetZone == this.zone) {\n\t // this should not be in the finally block, because exceptions assume not canceled.\n\t this._updateTaskCount(task.type, -1);\n\t }\n\t return value;\n\t };\n\t ZoneDelegate.prototype.hasTask = function (targetZone, isEmpty) {\n\t return this._hasTaskZS && this._hasTaskZS.onHasTask(this._hasTaskDlgt, this.zone, targetZone, isEmpty);\n\t };\n\t ZoneDelegate.prototype._updateTaskCount = function (type, count) {\n\t var counts = this._taskCounts;\n\t var prev = counts[type];\n\t var next = counts[type] = prev + count;\n\t if (next < 0) {\n\t throw new Error('More tasks executed then were scheduled.');\n\t }\n\t if (prev == 0 || next == 0) {\n\t var isEmpty = {\n\t microTask: counts.microTask > 0,\n\t macroTask: counts.macroTask > 0,\n\t eventTask: counts.eventTask > 0,\n\t change: type\n\t };\n\t try {\n\t this.hasTask(this.zone, isEmpty);\n\t }\n\t finally {\n\t if (this._parentDelegate) {\n\t this._parentDelegate._updateTaskCount(type, count);\n\t }\n\t }\n\t }\n\t };\n\t return ZoneDelegate;\n\t }());\n\t var ZoneTask = (function () {\n\t function ZoneTask(type, zone, source, callback, options, scheduleFn, cancelFn) {\n\t this.runCount = 0;\n\t this.type = type;\n\t this.zone = zone;\n\t this.source = source;\n\t this.data = options;\n\t this.scheduleFn = scheduleFn;\n\t this.cancelFn = cancelFn;\n\t this.callback = callback;\n\t var self = this;\n\t this.invoke = function () {\n\t try {\n\t return zone.runTask(self, this, arguments);\n\t }\n\t finally {\n\t drainMicroTaskQueue();\n\t }\n\t };\n\t }\n\t return ZoneTask;\n\t }());\n\t function __symbol__(name) { return '__zone_symbol__' + name; }\n\t ;\n\t var symbolSetTimeout = __symbol__('setTimeout');\n\t var symbolPromise = __symbol__('Promise');\n\t var symbolThen = __symbol__('then');\n\t var _currentZone = new Zone(null, null);\n\t var _currentTask = null;\n\t var _microTaskQueue = [];\n\t var _isDrainingMicrotaskQueue = false;\n\t var _uncaughtPromiseErrors = [];\n\t var _drainScheduled = false;\n\t function scheduleQueueDrain() {\n\t if (!_drainScheduled && !_currentTask && _microTaskQueue.length == 0) {\n\t // We are not running in Task, so we need to kickstart the microtask queue.\n\t if (global[symbolPromise]) {\n\t global[symbolPromise].resolve(0)[symbolThen](drainMicroTaskQueue);\n\t }\n\t else {\n\t global[symbolSetTimeout](drainMicroTaskQueue, 0);\n\t }\n\t }\n\t }\n\t function scheduleMicroTask(task) {\n\t scheduleQueueDrain();\n\t _microTaskQueue.push(task);\n\t }\n\t function consoleError(e) {\n\t var rejection = e && e.rejection;\n\t if (rejection) {\n\t console.error('Unhandled Promise rejection:', rejection instanceof Error ? rejection.message : rejection, '; Zone:', e.zone.name, '; Task:', e.task && e.task.source, '; Value:', rejection);\n\t }\n\t console.error(e);\n\t }\n\t function drainMicroTaskQueue() {\n\t if (!_isDrainingMicrotaskQueue) {\n\t _isDrainingMicrotaskQueue = true;\n\t while (_microTaskQueue.length) {\n\t var queue = _microTaskQueue;\n\t _microTaskQueue = [];\n\t for (var i = 0; i < queue.length; i++) {\n\t var task = queue[i];\n\t try {\n\t task.zone.runTask(task, null, null);\n\t }\n\t catch (e) {\n\t consoleError(e);\n\t }\n\t }\n\t }\n\t while (_uncaughtPromiseErrors.length) {\n\t var uncaughtPromiseErrors = _uncaughtPromiseErrors;\n\t _uncaughtPromiseErrors = [];\n\t var _loop_1 = function(i) {\n\t var uncaughtPromiseError = uncaughtPromiseErrors[i];\n\t try {\n\t uncaughtPromiseError.zone.runGuarded(function () { throw uncaughtPromiseError; });\n\t }\n\t catch (e) {\n\t consoleError(e);\n\t }\n\t };\n\t for (var i = 0; i < uncaughtPromiseErrors.length; i++) {\n\t _loop_1(i);\n\t }\n\t }\n\t _isDrainingMicrotaskQueue = false;\n\t _drainScheduled = false;\n\t }\n\t }\n\t function isThenable(value) {\n\t return value && value.then;\n\t }\n\t function forwardResolution(value) { return value; }\n\t function forwardRejection(rejection) { return ZoneAwarePromise.reject(rejection); }\n\t var symbolState = __symbol__('state');\n\t var symbolValue = __symbol__('value');\n\t var source = 'Promise.then';\n\t var UNRESOLVED = null;\n\t var RESOLVED = true;\n\t var REJECTED = false;\n\t var REJECTED_NO_CATCH = 0;\n\t function makeResolver(promise, state) {\n\t return function (v) {\n\t resolvePromise(promise, state, v);\n\t // Do not return value or you will break the Promise spec.\n\t };\n\t }\n\t function resolvePromise(promise, state, value) {\n\t if (promise[symbolState] === UNRESOLVED) {\n\t if (value instanceof ZoneAwarePromise && value[symbolState] !== UNRESOLVED) {\n\t clearRejectedNoCatch(value);\n\t resolvePromise(promise, value[symbolState], value[symbolValue]);\n\t }\n\t else if (isThenable(value)) {\n\t value.then(makeResolver(promise, state), makeResolver(promise, false));\n\t }\n\t else {\n\t promise[symbolState] = state;\n\t var queue = promise[symbolValue];\n\t promise[symbolValue] = value;\n\t for (var i = 0; i < queue.length;) {\n\t scheduleResolveOrReject(promise, queue[i++], queue[i++], queue[i++], queue[i++]);\n\t }\n\t if (queue.length == 0 && state == REJECTED) {\n\t promise[symbolState] = REJECTED_NO_CATCH;\n\t try {\n\t throw new Error(\"Uncaught (in promise): \" + value);\n\t }\n\t catch (e) {\n\t var error = e;\n\t error.rejection = value;\n\t error.promise = promise;\n\t error.zone = Zone.current;\n\t error.task = Zone.currentTask;\n\t _uncaughtPromiseErrors.push(error);\n\t scheduleQueueDrain();\n\t }\n\t }\n\t }\n\t }\n\t // Resolving an already resolved promise is a noop.\n\t return promise;\n\t }\n\t function clearRejectedNoCatch(promise) {\n\t if (promise[symbolState] === REJECTED_NO_CATCH) {\n\t promise[symbolState] = REJECTED;\n\t for (var i = 0; i < _uncaughtPromiseErrors.length; i++) {\n\t if (promise === _uncaughtPromiseErrors[i].promise) {\n\t _uncaughtPromiseErrors.splice(i, 1);\n\t break;\n\t }\n\t }\n\t }\n\t }\n\t function scheduleResolveOrReject(promise, zone, chainPromise, onFulfilled, onRejected) {\n\t clearRejectedNoCatch(promise);\n\t var delegate = promise[symbolState] ? onFulfilled || forwardResolution : onRejected || forwardRejection;\n\t zone.scheduleMicroTask(source, function () {\n\t try {\n\t resolvePromise(chainPromise, true, zone.run(delegate, null, [promise[symbolValue]]));\n\t }\n\t catch (error) {\n\t resolvePromise(chainPromise, false, error);\n\t }\n\t });\n\t }\n\t var ZoneAwarePromise = (function () {\n\t function ZoneAwarePromise(executor) {\n\t var promise = this;\n\t promise[symbolState] = UNRESOLVED;\n\t promise[symbolValue] = []; // queue;\n\t try {\n\t executor && executor(makeResolver(promise, RESOLVED), makeResolver(promise, REJECTED));\n\t }\n\t catch (e) {\n\t resolvePromise(promise, false, e);\n\t }\n\t }\n\t ZoneAwarePromise.resolve = function (value) {\n\t return resolvePromise(new this(null), RESOLVED, value);\n\t };\n\t ZoneAwarePromise.reject = function (error) {\n\t return resolvePromise(new this(null), REJECTED, error);\n\t };\n\t ZoneAwarePromise.race = function (values) {\n\t var resolve;\n\t var reject;\n\t var promise = new this(function (res, rej) { resolve = res; reject = rej; });\n\t function onResolve(value) { promise && (promise = null || resolve(value)); }\n\t function onReject(error) { promise && (promise = null || reject(error)); }\n\t for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {\n\t var value = values_1[_i];\n\t if (!isThenable(value)) {\n\t value = this.resolve(value);\n\t }\n\t value.then(onResolve, onReject);\n\t }\n\t return promise;\n\t };\n\t ZoneAwarePromise.all = function (values) {\n\t var resolve;\n\t var reject;\n\t var promise = new this(function (res, rej) { resolve = res; reject = rej; });\n\t var count = 0;\n\t var resolvedValues = [];\n\t function onReject(error) { promise && reject(error); promise = null; }\n\t for (var _i = 0, values_2 = values; _i < values_2.length; _i++) {\n\t var value = values_2[_i];\n\t if (!isThenable(value)) {\n\t value = this.resolve(value);\n\t }\n\t value.then((function (index) { return function (value) {\n\t resolvedValues[index] = value;\n\t count--;\n\t if (promise && !count) {\n\t resolve(resolvedValues);\n\t }\n\t promise == null;\n\t }; })(count), onReject);\n\t count++;\n\t }\n\t if (!count)\n\t resolve(resolvedValues);\n\t return promise;\n\t };\n\t ZoneAwarePromise.prototype.then = function (onFulfilled, onRejected) {\n\t var chainPromise = new ZoneAwarePromise(null);\n\t var zone = Zone.current;\n\t if (this[symbolState] == UNRESOLVED) {\n\t this[symbolValue].push(zone, chainPromise, onFulfilled, onRejected);\n\t }\n\t else {\n\t scheduleResolveOrReject(this, zone, chainPromise, onFulfilled, onRejected);\n\t }\n\t return chainPromise;\n\t };\n\t ZoneAwarePromise.prototype.catch = function (onRejected) {\n\t return this.then(null, onRejected);\n\t };\n\t return ZoneAwarePromise;\n\t }());\n\t var NativePromise = global[__symbol__('Promise')] = global.Promise;\n\t global.Promise = ZoneAwarePromise;\n\t if (NativePromise) {\n\t var NativePromiseProtototype = NativePromise.prototype;\n\t var NativePromiseThen_1 = NativePromiseProtototype[__symbol__('then')]\n\t = NativePromiseProtototype.then;\n\t NativePromiseProtototype.then = function (onResolve, onReject) {\n\t var nativePromise = this;\n\t return new ZoneAwarePromise(function (resolve, reject) {\n\t NativePromiseThen_1.call(nativePromise, resolve, reject);\n\t }).then(onResolve, onReject);\n\t };\n\t }\n\t return global.Zone = Zone;\n\t})(typeof window === 'undefined' ? global : window);\n\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n/* 2 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar utils_1 = __webpack_require__(3);\n\tvar WTF_ISSUE_555 = 'Anchor,Area,Audio,BR,Base,BaseFont,Body,Button,Canvas,Content,DList,Directory,Div,Embed,FieldSet,Font,Form,Frame,FrameSet,HR,Head,Heading,Html,IFrame,Image,Input,Keygen,LI,Label,Legend,Link,Map,Marquee,Media,Menu,Meta,Meter,Mod,OList,Object,OptGroup,Option,Output,Paragraph,Pre,Progress,Quote,Script,Select,Source,Span,Style,TableCaption,TableCell,TableCol,Table,TableRow,TableSection,TextArea,Title,Track,UList,Unknown,Video';\n\tvar NO_EVENT_TARGET = 'ApplicationCache,EventSource,FileReader,InputMethodContext,MediaController,MessagePort,Node,Performance,SVGElementInstance,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebKitNamedFlow,Worker,WorkerGlobalScope,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload,IDBRequest,IDBOpenDBRequest,IDBDatabase,IDBTransaction,IDBCursor,DBIndex'.split(',');\n\tvar EVENT_TARGET = 'EventTarget';\n\tfunction eventTargetPatch(_global) {\n\t var apis = [];\n\t var isWtf = _global['wtf'];\n\t if (isWtf) {\n\t // Workaround for: https://github.com/google/tracing-framework/issues/555\n\t apis = WTF_ISSUE_555.split(',').map(function (v) { return 'HTML' + v + 'Element'; }).concat(NO_EVENT_TARGET);\n\t }\n\t else if (_global[EVENT_TARGET]) {\n\t apis.push(EVENT_TARGET);\n\t }\n\t else {\n\t // Note: EventTarget is not available in all browsers,\n\t // if it's not available, we instead patch the APIs in the IDL that inherit from EventTarget\n\t apis = NO_EVENT_TARGET;\n\t }\n\t for (var i = 0; i < apis.length; i++) {\n\t var type = _global[apis[i]];\n\t utils_1.patchEventTargetMethods(type && type.prototype);\n\t }\n\t}\n\texports.eventTargetPatch = eventTargetPatch;\n\n\n/***/ },\n/* 3 */\n/***/ function(module, exports) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {/**\n\t * Suppress closure compiler errors about unknown 'process' variable\n\t * @fileoverview\n\t * @suppress {undefinedVars}\n\t */\n\t\"use strict\";\n\texports.zoneSymbol = Zone['__symbol__'];\n\tvar _global = typeof window == 'undefined' ? global : window;\n\tfunction bindArguments(args, source) {\n\t for (var i = args.length - 1; i >= 0; i--) {\n\t if (typeof args[i] === 'function') {\n\t args[i] = Zone.current.wrap(args[i], source + '_' + i);\n\t }\n\t }\n\t return args;\n\t}\n\texports.bindArguments = bindArguments;\n\t;\n\tfunction patchPrototype(prototype, fnNames) {\n\t var source = prototype.constructor['name'];\n\t var _loop_1 = function(i) {\n\t var name_1 = fnNames[i];\n\t var delegate = prototype[name_1];\n\t if (delegate) {\n\t prototype[name_1] = (function (delegate) {\n\t return function () {\n\t return delegate.apply(this, bindArguments(arguments, source + '.' + name_1));\n\t };\n\t })(delegate);\n\t }\n\t };\n\t for (var i = 0; i < fnNames.length; i++) {\n\t _loop_1(i);\n\t }\n\t}\n\texports.patchPrototype = patchPrototype;\n\t;\n\texports.isWebWorker = (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope);\n\texports.isNode = (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]');\n\texports.isBrowser = !exports.isNode && !exports.isWebWorker && !!(typeof window !== 'undefined' && window['HTMLElement']);\n\tfunction patchProperty(obj, prop) {\n\t var desc = Object.getOwnPropertyDescriptor(obj, prop) || {\n\t enumerable: true,\n\t configurable: true\n\t };\n\t // A property descriptor cannot have getter/setter and be writable\n\t // deleting the writable and value properties avoids this error:\n\t //\n\t // TypeError: property descriptors must not specify a value or be writable when a\n\t // getter or setter has been specified\n\t delete desc.writable;\n\t delete desc.value;\n\t // substr(2) cuz 'onclick' -> 'click', etc\n\t var eventName = prop.substr(2);\n\t var _prop = '_' + prop;\n\t desc.set = function (fn) {\n\t if (this[_prop]) {\n\t this.removeEventListener(eventName, this[_prop]);\n\t }\n\t if (typeof fn === 'function') {\n\t var wrapFn = function (event) {\n\t var result;\n\t result = fn.apply(this, arguments);\n\t if (result != undefined && !result)\n\t event.preventDefault();\n\t };\n\t this[_prop] = wrapFn;\n\t this.addEventListener(eventName, wrapFn, false);\n\t }\n\t else {\n\t this[_prop] = null;\n\t }\n\t };\n\t desc.get = function () {\n\t return this[_prop];\n\t };\n\t Object.defineProperty(obj, prop, desc);\n\t}\n\texports.patchProperty = patchProperty;\n\t;\n\tfunction patchOnProperties(obj, properties) {\n\t var onProperties = [];\n\t for (var prop in obj) {\n\t if (prop.substr(0, 2) == 'on') {\n\t onProperties.push(prop);\n\t }\n\t }\n\t for (var j = 0; j < onProperties.length; j++) {\n\t patchProperty(obj, onProperties[j]);\n\t }\n\t if (properties) {\n\t for (var i = 0; i < properties.length; i++) {\n\t patchProperty(obj, 'on' + properties[i]);\n\t }\n\t }\n\t}\n\texports.patchOnProperties = patchOnProperties;\n\t;\n\tvar EVENT_TASKS = exports.zoneSymbol('eventTasks');\n\tvar ADD_EVENT_LISTENER = 'addEventListener';\n\tvar REMOVE_EVENT_LISTENER = 'removeEventListener';\n\tvar SYMBOL_ADD_EVENT_LISTENER = exports.zoneSymbol(ADD_EVENT_LISTENER);\n\tvar SYMBOL_REMOVE_EVENT_LISTENER = exports.zoneSymbol(REMOVE_EVENT_LISTENER);\n\tfunction findExistingRegisteredTask(target, handler, name, capture, remove) {\n\t var eventTasks = target[EVENT_TASKS];\n\t if (eventTasks) {\n\t for (var i = 0; i < eventTasks.length; i++) {\n\t var eventTask = eventTasks[i];\n\t var data = eventTask.data;\n\t if (data.handler === handler\n\t && data.useCapturing === capture\n\t && data.eventName === name) {\n\t if (remove) {\n\t eventTasks.splice(i, 1);\n\t }\n\t return eventTask;\n\t }\n\t }\n\t }\n\t return null;\n\t}\n\tfunction attachRegisteredEvent(target, eventTask) {\n\t var eventTasks = target[EVENT_TASKS];\n\t if (!eventTasks) {\n\t eventTasks = target[EVENT_TASKS] = [];\n\t }\n\t eventTasks.push(eventTask);\n\t}\n\tfunction scheduleEventListener(eventTask) {\n\t var meta = eventTask.data;\n\t attachRegisteredEvent(meta.target, eventTask);\n\t return meta.target[SYMBOL_ADD_EVENT_LISTENER](meta.eventName, eventTask.invoke, meta.useCapturing);\n\t}\n\tfunction cancelEventListener(eventTask) {\n\t var meta = eventTask.data;\n\t findExistingRegisteredTask(meta.target, eventTask.invoke, meta.eventName, meta.useCapturing, true);\n\t meta.target[SYMBOL_REMOVE_EVENT_LISTENER](meta.eventName, eventTask.invoke, meta.useCapturing);\n\t}\n\tfunction zoneAwareAddEventListener(self, args) {\n\t var eventName = args[0];\n\t var handler = args[1];\n\t var useCapturing = args[2] || false;\n\t // - Inside a Web Worker, `this` is undefined, the context is `global`\n\t // - When `addEventListener` is called on the global context in strict mode, `this` is undefined\n\t // see https://github.com/angular/zone.js/issues/190\n\t var target = self || _global;\n\t var delegate = null;\n\t if (typeof handler == 'function') {\n\t delegate = handler;\n\t }\n\t else if (handler && handler.handleEvent) {\n\t delegate = function (event) { return handler.handleEvent(event); };\n\t }\n\t var validZoneHandler = false;\n\t try {\n\t // In cross site contexts (such as WebDriver frameworks like Selenium),\n\t // accessing the handler object here will cause an exception to be thrown which\n\t // will fail tests prematurely.\n\t validZoneHandler = handler && handler.toString() === \"[object FunctionWrapper]\";\n\t }\n\t catch (e) {\n\t // Returning nothing here is fine, because objects in a cross-site context are unusable\n\t return;\n\t }\n\t // Ignore special listeners of IE11 & Edge dev tools, see https://github.com/angular/zone.js/issues/150\n\t if (!delegate || validZoneHandler) {\n\t return target[SYMBOL_ADD_EVENT_LISTENER](eventName, handler, useCapturing);\n\t }\n\t var eventTask = findExistingRegisteredTask(target, handler, eventName, useCapturing, false);\n\t if (eventTask) {\n\t // we already registered, so this will have noop.\n\t return target[SYMBOL_ADD_EVENT_LISTENER](eventName, eventTask.invoke, useCapturing);\n\t }\n\t var zone = Zone.current;\n\t var source = target.constructor['name'] + '.addEventListener:' + eventName;\n\t var data = {\n\t target: target,\n\t eventName: eventName,\n\t name: eventName,\n\t useCapturing: useCapturing,\n\t handler: handler\n\t };\n\t zone.scheduleEventTask(source, delegate, data, scheduleEventListener, cancelEventListener);\n\t}\n\tfunction zoneAwareRemoveEventListener(self, args) {\n\t var eventName = args[0];\n\t var handler = args[1];\n\t var useCapturing = args[2] || false;\n\t // - Inside a Web Worker, `this` is undefined, the context is `global`\n\t // - When `addEventListener` is called on the global context in strict mode, `this` is undefined\n\t // see https://github.com/angular/zone.js/issues/190\n\t var target = self || _global;\n\t var eventTask = findExistingRegisteredTask(target, handler, eventName, useCapturing, true);\n\t if (eventTask) {\n\t eventTask.zone.cancelTask(eventTask);\n\t }\n\t else {\n\t target[SYMBOL_REMOVE_EVENT_LISTENER](eventName, handler, useCapturing);\n\t }\n\t}\n\tfunction patchEventTargetMethods(obj) {\n\t if (obj && obj.addEventListener) {\n\t patchMethod(obj, ADD_EVENT_LISTENER, function () { return zoneAwareAddEventListener; });\n\t patchMethod(obj, REMOVE_EVENT_LISTENER, function () { return zoneAwareRemoveEventListener; });\n\t return true;\n\t }\n\t else {\n\t return false;\n\t }\n\t}\n\texports.patchEventTargetMethods = patchEventTargetMethods;\n\t;\n\tvar originalInstanceKey = exports.zoneSymbol('originalInstance');\n\t// wrap some native API on `window`\n\tfunction patchClass(className) {\n\t var OriginalClass = _global[className];\n\t if (!OriginalClass)\n\t return;\n\t _global[className] = function () {\n\t var a = bindArguments(arguments, className);\n\t switch (a.length) {\n\t case 0:\n\t this[originalInstanceKey] = new OriginalClass();\n\t break;\n\t case 1:\n\t this[originalInstanceKey] = new OriginalClass(a[0]);\n\t break;\n\t case 2:\n\t this[originalInstanceKey] = new OriginalClass(a[0], a[1]);\n\t break;\n\t case 3:\n\t this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2]);\n\t break;\n\t case 4:\n\t this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2], a[3]);\n\t break;\n\t default: throw new Error('Arg list too long.');\n\t }\n\t };\n\t var instance = new OriginalClass(function () { });\n\t var prop;\n\t for (prop in instance) {\n\t (function (prop) {\n\t if (typeof instance[prop] === 'function') {\n\t _global[className].prototype[prop] = function () {\n\t return this[originalInstanceKey][prop].apply(this[originalInstanceKey], arguments);\n\t };\n\t }\n\t else {\n\t Object.defineProperty(_global[className].prototype, prop, {\n\t set: function (fn) {\n\t if (typeof fn === 'function') {\n\t this[originalInstanceKey][prop] = Zone.current.wrap(fn, className + '.' + prop);\n\t }\n\t else {\n\t this[originalInstanceKey][prop] = fn;\n\t }\n\t },\n\t get: function () {\n\t return this[originalInstanceKey][prop];\n\t }\n\t });\n\t }\n\t }(prop));\n\t }\n\t for (prop in OriginalClass) {\n\t if (prop !== 'prototype' && OriginalClass.hasOwnProperty(prop)) {\n\t _global[className][prop] = OriginalClass[prop];\n\t }\n\t }\n\t}\n\texports.patchClass = patchClass;\n\t;\n\tfunction createNamedFn(name, delegate) {\n\t try {\n\t return (Function('f', \"return function \" + name + \"(){return f(this, arguments)}\"))(delegate);\n\t }\n\t catch (e) {\n\t // if we fail, we must be CSP, just return delegate.\n\t return function () {\n\t return delegate(this, arguments);\n\t };\n\t }\n\t}\n\texports.createNamedFn = createNamedFn;\n\tfunction patchMethod(target, name, patchFn) {\n\t var proto = target;\n\t while (proto && !proto.hasOwnProperty(name)) {\n\t proto = Object.getPrototypeOf(proto);\n\t }\n\t if (!proto && target[name]) {\n\t // somehow we did not find it, but we can see it. This happens on IE for Window properties.\n\t proto = target;\n\t }\n\t var delegateName = exports.zoneSymbol(name);\n\t var delegate;\n\t if (proto && !(delegate = proto[delegateName])) {\n\t delegate = proto[delegateName] = proto[name];\n\t proto[name] = createNamedFn(name, patchFn(delegate, delegateName, name));\n\t }\n\t return delegate;\n\t}\n\texports.patchMethod = patchMethod;\n\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n/* 4 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar utils_1 = __webpack_require__(3);\n\t/*\n\t * This is necessary for Chrome and Chrome mobile, to enable\n\t * things like redefining `createdCallback` on an element.\n\t */\n\tvar _defineProperty = Object.defineProperty;\n\tvar _getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\tvar _create = Object.create;\n\tvar unconfigurablesKey = utils_1.zoneSymbol('unconfigurables');\n\tfunction propertyPatch() {\n\t Object.defineProperty = function (obj, prop, desc) {\n\t if (isUnconfigurable(obj, prop)) {\n\t throw new TypeError('Cannot assign to read only property \\'' + prop + '\\' of ' + obj);\n\t }\n\t if (prop !== 'prototype') {\n\t desc = rewriteDescriptor(obj, prop, desc);\n\t }\n\t return _defineProperty(obj, prop, desc);\n\t };\n\t Object.defineProperties = function (obj, props) {\n\t Object.keys(props).forEach(function (prop) {\n\t Object.defineProperty(obj, prop, props[prop]);\n\t });\n\t return obj;\n\t };\n\t Object.create = function (obj, proto) {\n\t if (typeof proto === 'object') {\n\t Object.keys(proto).forEach(function (prop) {\n\t proto[prop] = rewriteDescriptor(obj, prop, proto[prop]);\n\t });\n\t }\n\t return _create(obj, proto);\n\t };\n\t Object.getOwnPropertyDescriptor = function (obj, prop) {\n\t var desc = _getOwnPropertyDescriptor(obj, prop);\n\t if (isUnconfigurable(obj, prop)) {\n\t desc.configurable = false;\n\t }\n\t return desc;\n\t };\n\t}\n\texports.propertyPatch = propertyPatch;\n\t;\n\tfunction _redefineProperty(obj, prop, desc) {\n\t desc = rewriteDescriptor(obj, prop, desc);\n\t return _defineProperty(obj, prop, desc);\n\t}\n\texports._redefineProperty = _redefineProperty;\n\t;\n\tfunction isUnconfigurable(obj, prop) {\n\t return obj && obj[unconfigurablesKey] && obj[unconfigurablesKey][prop];\n\t}\n\tfunction rewriteDescriptor(obj, prop, desc) {\n\t desc.configurable = true;\n\t if (!desc.configurable) {\n\t if (!obj[unconfigurablesKey]) {\n\t _defineProperty(obj, unconfigurablesKey, { writable: true, value: {} });\n\t }\n\t obj[unconfigurablesKey][prop] = true;\n\t }\n\t return desc;\n\t}\n\n\n/***/ },\n/* 5 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar define_property_1 = __webpack_require__(4);\n\tvar utils_1 = __webpack_require__(3);\n\tfunction registerElementPatch(_global) {\n\t if (!utils_1.isBrowser || !('registerElement' in _global.document)) {\n\t return;\n\t }\n\t var _registerElement = document.registerElement;\n\t var callbacks = [\n\t 'createdCallback',\n\t 'attachedCallback',\n\t 'detachedCallback',\n\t 'attributeChangedCallback'\n\t ];\n\t document.registerElement = function (name, opts) {\n\t if (opts && opts.prototype) {\n\t callbacks.forEach(function (callback) {\n\t var source = 'Document.registerElement::' + callback;\n\t if (opts.prototype.hasOwnProperty(callback)) {\n\t var descriptor = Object.getOwnPropertyDescriptor(opts.prototype, callback);\n\t if (descriptor && descriptor.value) {\n\t descriptor.value = Zone.current.wrap(descriptor.value, source);\n\t define_property_1._redefineProperty(opts.prototype, callback, descriptor);\n\t }\n\t else {\n\t opts.prototype[callback] = Zone.current.wrap(opts.prototype[callback], source);\n\t }\n\t }\n\t else if (opts.prototype[callback]) {\n\t opts.prototype[callback] = Zone.current.wrap(opts.prototype[callback], source);\n\t }\n\t });\n\t }\n\t return _registerElement.apply(document, [name, opts]);\n\t };\n\t}\n\texports.registerElementPatch = registerElementPatch;\n\n\n/***/ },\n/* 6 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar webSocketPatch = __webpack_require__(7);\n\tvar utils_1 = __webpack_require__(3);\n\tvar eventNames = 'copy cut paste abort blur focus canplay canplaythrough change click contextmenu dblclick drag dragend dragenter dragleave dragover dragstart drop durationchange emptied ended input invalid keydown keypress keyup load loadeddata loadedmetadata loadstart message mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup pause play playing progress ratechange reset scroll seeked seeking select show stalled submit suspend timeupdate volumechange waiting mozfullscreenchange mozfullscreenerror mozpointerlockchange mozpointerlockerror error webglcontextrestored webglcontextlost webglcontextcreationerror'.split(' ');\n\tfunction propertyDescriptorPatch(_global) {\n\t if (utils_1.isNode) {\n\t return;\n\t }\n\t var supportsWebSocket = typeof WebSocket !== 'undefined';\n\t if (canPatchViaPropertyDescriptor()) {\n\t // for browsers that we can patch the descriptor: Chrome & Firefox\n\t if (utils_1.isBrowser) {\n\t utils_1.patchOnProperties(HTMLElement.prototype, eventNames);\n\t }\n\t utils_1.patchOnProperties(XMLHttpRequest.prototype, null);\n\t if (typeof IDBIndex !== 'undefined') {\n\t utils_1.patchOnProperties(IDBIndex.prototype, null);\n\t utils_1.patchOnProperties(IDBRequest.prototype, null);\n\t utils_1.patchOnProperties(IDBOpenDBRequest.prototype, null);\n\t utils_1.patchOnProperties(IDBDatabase.prototype, null);\n\t utils_1.patchOnProperties(IDBTransaction.prototype, null);\n\t utils_1.patchOnProperties(IDBCursor.prototype, null);\n\t }\n\t if (supportsWebSocket) {\n\t utils_1.patchOnProperties(WebSocket.prototype, null);\n\t }\n\t }\n\t else {\n\t // Safari, Android browsers (Jelly Bean)\n\t patchViaCapturingAllTheEvents();\n\t utils_1.patchClass('XMLHttpRequest');\n\t if (supportsWebSocket) {\n\t webSocketPatch.apply(_global);\n\t }\n\t }\n\t}\n\texports.propertyDescriptorPatch = propertyDescriptorPatch;\n\tfunction canPatchViaPropertyDescriptor() {\n\t if (utils_1.isBrowser && !Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'onclick')\n\t && typeof Element !== 'undefined') {\n\t // WebKit https://bugs.webkit.org/show_bug.cgi?id=134364\n\t // IDL interface attributes are not configurable\n\t var desc = Object.getOwnPropertyDescriptor(Element.prototype, 'onclick');\n\t if (desc && !desc.configurable)\n\t return false;\n\t }\n\t Object.defineProperty(XMLHttpRequest.prototype, 'onreadystatechange', {\n\t get: function () {\n\t return true;\n\t }\n\t });\n\t var req = new XMLHttpRequest();\n\t var result = !!req.onreadystatechange;\n\t Object.defineProperty(XMLHttpRequest.prototype, 'onreadystatechange', {});\n\t return result;\n\t}\n\t;\n\tvar unboundKey = utils_1.zoneSymbol('unbound');\n\t// Whenever any eventListener fires, we check the eventListener target and all parents\n\t// for `onwhatever` properties and replace them with zone-bound functions\n\t// - Chrome (for now)\n\tfunction patchViaCapturingAllTheEvents() {\n\t var _loop_1 = function(i) {\n\t var property = eventNames[i];\n\t var onproperty = 'on' + property;\n\t document.addEventListener(property, function (event) {\n\t var elt = event.target, bound, source;\n\t if (elt) {\n\t source = elt.constructor['name'] + '.' + onproperty;\n\t }\n\t else {\n\t source = 'unknown.' + onproperty;\n\t }\n\t while (elt) {\n\t if (elt[onproperty] && !elt[onproperty][unboundKey]) {\n\t bound = Zone.current.wrap(elt[onproperty], source);\n\t bound[unboundKey] = elt[onproperty];\n\t elt[onproperty] = bound;\n\t }\n\t elt = elt.parentElement;\n\t }\n\t }, true);\n\t };\n\t for (var i = 0; i < eventNames.length; i++) {\n\t _loop_1(i);\n\t }\n\t ;\n\t}\n\t;\n\n\n/***/ },\n/* 7 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar utils_1 = __webpack_require__(3);\n\t// we have to patch the instance since the proto is non-configurable\n\tfunction apply(_global) {\n\t var WS = _global.WebSocket;\n\t // On Safari window.EventTarget doesn't exist so need to patch WS add/removeEventListener\n\t // On older Chrome, no need since EventTarget was already patched\n\t if (!_global.EventTarget) {\n\t utils_1.patchEventTargetMethods(WS.prototype);\n\t }\n\t _global.WebSocket = function (a, b) {\n\t var socket = arguments.length > 1 ? new WS(a, b) : new WS(a);\n\t var proxySocket;\n\t // Safari 7.0 has non-configurable own 'onmessage' and friends properties on the socket instance\n\t var onmessageDesc = Object.getOwnPropertyDescriptor(socket, 'onmessage');\n\t if (onmessageDesc && onmessageDesc.configurable === false) {\n\t proxySocket = Object.create(socket);\n\t ['addEventListener', 'removeEventListener', 'send', 'close'].forEach(function (propName) {\n\t proxySocket[propName] = function () {\n\t return socket[propName].apply(socket, arguments);\n\t };\n\t });\n\t }\n\t else {\n\t // we can patch the real socket\n\t proxySocket = socket;\n\t }\n\t utils_1.patchOnProperties(proxySocket, ['close', 'error', 'message', 'open']);\n\t return proxySocket;\n\t };\n\t for (var prop in WS) {\n\t _global.WebSocket[prop] = WS[prop];\n\t }\n\t}\n\texports.apply = apply;\n\n\n/***/ },\n/* 8 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\tvar utils_1 = __webpack_require__(3);\n\tfunction patchTimer(window, setName, cancelName, nameSuffix) {\n\t var setNative = null;\n\t var clearNative = null;\n\t setName += nameSuffix;\n\t cancelName += nameSuffix;\n\t function scheduleTask(task) {\n\t var data = task.data;\n\t data.args[0] = task.invoke;\n\t data.handleId = setNative.apply(window, data.args);\n\t return task;\n\t }\n\t function clearTask(task) {\n\t return clearNative(task.data.handleId);\n\t }\n\t setNative = utils_1.patchMethod(window, setName, function (delegate) { return function (self, args) {\n\t if (typeof args[0] === 'function') {\n\t var zone = Zone.current;\n\t var options = {\n\t handleId: null,\n\t isPeriodic: nameSuffix === 'Interval',\n\t delay: (nameSuffix === 'Timeout' || nameSuffix === 'Interval') ? args[1] || 0 : null,\n\t args: args\n\t };\n\t return zone.scheduleMacroTask(setName, args[0], options, scheduleTask, clearTask);\n\t }\n\t else {\n\t // cause an error by calling it directly.\n\t return delegate.apply(window, args);\n\t }\n\t }; });\n\t clearNative = utils_1.patchMethod(window, cancelName, function (delegate) { return function (self, args) {\n\t var task = args[0];\n\t if (task && typeof task.type === 'string') {\n\t if (task.cancelFn && task.data.isPeriodic || task.runCount === 0) {\n\t // Do not cancel already canceled functions\n\t task.zone.cancelTask(task);\n\t }\n\t }\n\t else {\n\t // cause an error by calling it directly.\n\t delegate.apply(window, args);\n\t }\n\t }; });\n\t}\n\texports.patchTimer = patchTimer;\n\n\n/***/ }\n/******/ ]);\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/zone.js/dist/zone.js\n ** module id = 457\n ** module chunks = 0\n **/","/* (ignored) */\n\n\n/*****************\n ** WEBPACK FOOTER\n ** vertx (ignored)\n ** module id = 458\n ** module chunks = 0\n **/","\"use strict\";\nvar __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};\nvar lang_1 = require('./lang');\nvar promise_1 = require('./promise');\nexports.PromiseWrapper = promise_1.PromiseWrapper;\nexports.PromiseCompleter = promise_1.PromiseCompleter;\nvar Subject_1 = require('rxjs/Subject');\nvar PromiseObservable_1 = require('rxjs/observable/PromiseObservable');\nvar toPromise_1 = require('rxjs/operator/toPromise');\nvar Observable_1 = require('rxjs/Observable');\nexports.Observable = Observable_1.Observable;\nvar Subject_2 = require('rxjs/Subject');\nexports.Subject = Subject_2.Subject;\nvar TimerWrapper = (function () {\n function TimerWrapper() {\n }\n TimerWrapper.setTimeout = function (fn, millis) {\n return lang_1.global.setTimeout(fn, millis);\n };\n TimerWrapper.clearTimeout = function (id) { lang_1.global.clearTimeout(id); };\n TimerWrapper.setInterval = function (fn, millis) {\n return lang_1.global.setInterval(fn, millis);\n };\n TimerWrapper.clearInterval = function (id) { lang_1.global.clearInterval(id); };\n return TimerWrapper;\n}());\nexports.TimerWrapper = TimerWrapper;\nvar ObservableWrapper = (function () {\n function ObservableWrapper() {\n }\n // TODO(vsavkin): when we use rxnext, try inferring the generic type from the first arg\n ObservableWrapper.subscribe = function (emitter, onNext, onError, onComplete) {\n if (onComplete === void 0) { onComplete = function () { }; }\n onError = (typeof onError === \"function\") && onError || lang_1.noop;\n onComplete = (typeof onComplete === \"function\") && onComplete || lang_1.noop;\n return emitter.subscribe({ next: onNext, error: onError, complete: onComplete });\n };\n ObservableWrapper.isObservable = function (obs) { return !!obs.subscribe; };\n /**\n * Returns whether `obs` has any subscribers listening to events.\n */\n ObservableWrapper.hasSubscribers = function (obs) { return obs.observers.length > 0; };\n ObservableWrapper.dispose = function (subscription) { subscription.unsubscribe(); };\n /**\n * @deprecated - use callEmit() instead\n */\n ObservableWrapper.callNext = function (emitter, value) { emitter.next(value); };\n ObservableWrapper.callEmit = function (emitter, value) { emitter.emit(value); };\n ObservableWrapper.callError = function (emitter, error) { emitter.error(error); };\n ObservableWrapper.callComplete = function (emitter) { emitter.complete(); };\n ObservableWrapper.fromPromise = function (promise) {\n return PromiseObservable_1.PromiseObservable.create(promise);\n };\n ObservableWrapper.toPromise = function (obj) { return toPromise_1.toPromise.call(obj); };\n return ObservableWrapper;\n}());\nexports.ObservableWrapper = ObservableWrapper;\n/**\n * Use by directives and components to emit custom Events.\n *\n * ### Examples\n *\n * In the following example, `Zippy` alternatively emits `open` and `close` events when its\n * title gets clicked:\n *\n * ```\n * @Component({\n * selector: 'zippy',\n * template: `\n *
\n *
Toggle
\n *
\n * \n *
\n *