/**

* @license

* Copyright Google Inc. All Rights Reserved.

*

* Use of this source code is governed by an MIT-style license that can be

* found in the LICENSE file at https://angular.io/license

*/

(function (global, factory) {

typeof exports === 'object' && typeof module !== 'undefined' ? factory() :

typeof define === 'function' && define.amd ? define(factory) :

(factory());

}(this, (function () { 'use strict';

/**

* @license

* Copyright Google Inc. All Rights Reserved.

*

* Use of this source code is governed by an MIT-style license that can be

* found in the LICENSE file at https://angular.io/license

*/

var Zone$1 = (function (global) {

if (global['Zone']) {

throw new Error('Zone already loaded.');

}

var NO_ZONE = { name: 'NO ZONE' };

var notScheduled = 'notScheduled', scheduling = 'scheduling', scheduled = 'scheduled', running = 'running', canceling = 'canceling';

var microTask = 'microTask', macroTask = 'macroTask', eventTask = 'eventTask';

var Zone = (function () {

function Zone(parent, zoneSpec) {

this._properties = null;

this._parent = parent;

this._name = zoneSpec ? zoneSpec.name || 'unnamed' : '<root>';

this._properties = zoneSpec && zoneSpec.properties || {};

this._zoneDelegate =

new ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec);

}

Zone.assertZonePatched = function () {

if (global.Promise !== ZoneAwarePromise) {

throw new Error('Zone.js has detected that ZoneAwarePromise `(window|global).Promise` ' +

'has been overwritten.\n' +

'Most likely cause is that a Promise polyfill has been loaded ' +

'after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. ' +

'If you must load one, do so before loading zone.js.)');

}

};

Object.defineProperty(Zone, "root", {

get: function () {

var zone = Zone.current;

while (zone.parent) {

zone = zone.parent;

}

return zone;

},

enumerable: true,

configurable: true

});

Object.defineProperty(Zone, "current", {

get: function () {

return _currentZoneFrame.zone;

},

enumerable: true,

configurable: true

});

Object.defineProperty(Zone, "currentTask", {

get: function () {

return _currentTask;

},

enumerable: true,

configurable: true

});

Object.defineProperty(Zone.prototype, "parent", {

get: function () {

return this._parent;

},

enumerable: true,

configurable: true

});

Object.defineProperty(Zone.prototype, "name", {

get: function () {

return this._name;

},

enumerable: true,

configurable: true

});

Zone.prototype.get = function (key) {

var zone = this.getZoneWith(key);

if (zone)

return zone._properties[key];

};

Zone.prototype.getZoneWith = function (key) {

var current = this;

while (current) {

if (current._properties.hasOwnProperty(key)) {

return current;

}

current = current._parent;

}

return null;

};

Zone.prototype.fork = function (zoneSpec) {

if (!zoneSpec)

throw new Error('ZoneSpec required!');

return this._zoneDelegate.fork(this, zoneSpec);

};

Zone.prototype.wrap = function (callback, source) {

if (typeof callback !== 'function') {

throw new Error('Expecting function got: ' + callback);

}

var _callback = this._zoneDelegate.intercept(this, callback, source);

var zone = this;

return function () {

return zone.runGuarded(_callback, this, arguments, source);

};

};

Zone.prototype.run = function (callback, applyThis, applyArgs, source) {

if (applyThis === void 0) { applyThis = undefined; }

if (applyArgs === void 0) { applyArgs = null; }

if (source === void 0) { source = null; }

_currentZoneFrame = new ZoneFrame(_currentZoneFrame, this);

try {

return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);

}

finally {

_currentZoneFrame = _currentZoneFrame.parent;

}

};

Zone.prototype.runGuarded = function (callback, applyThis, applyArgs, source) {

if (applyThis === void 0) { applyThis = null; }

if (applyArgs === void 0) { applyArgs = null; }

if (source === void 0) { source = null; }

_currentZoneFrame = new ZoneFrame(_currentZoneFrame, this);

try {

try {

return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);

}

catch (error) {

if (this._zoneDelegate.handleError(this, error)) {

throw error;

}

}

}

finally {

_currentZoneFrame = _currentZoneFrame.parent;

}

};

Zone.prototype.runTask = function (task, applyThis, applyArgs) {

if (task.zone != this)

throw new Error('A task can only be run in the zone of creation! (Creation: ' +

(task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')');

var reEntryGuard = task.state != running;

reEntryGuard && task._transitionTo(running, scheduled);

task.runCount++;

var previousTask = _currentTask;

_currentTask = task;

_currentZoneFrame = new ZoneFrame(_currentZoneFrame, this);

try {

if (task.type == macroTask && task.data && !task.data.isPeriodic) {

task.cancelFn = null;

}

try {

return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs);

}

catch (error) {

if (this._zoneDelegate.handleError(this, error)) {

throw error;

}

}

}

finally {

if (task.type == eventTask || (task.data && task.data.isPeriodic)) {

reEntryGuard && task._transitionTo(scheduled, running, notScheduled);

}

else {

task.runCount = 0;

this._updateTaskCount(task, -1);

reEntryGuard && task._transitionTo(notScheduled, running, notScheduled);

}

_currentZoneFrame = _currentZoneFrame.parent;

_currentTask = previousTask;

}

};

Zone.prototype.scheduleTask = function (task) {

task._transitionTo(scheduling, notScheduled);

var zoneDelegates = [];

task._zoneDelegates = zoneDelegates;

task.zone = this;

task = this._zoneDelegate.scheduleTask(this, task);

if (task._zoneDelegates === zoneDelegates) {

// we have to check because internally the delegate can reschedule the task.

this._updateTaskCount(task, 1);

}

if (task.state == scheduling) {

task._transitionTo(scheduled, scheduling);

}

return task;

};

Zone.prototype.scheduleMicroTask = function (source, callback, data, customSchedule) {

return this.scheduleTask(new ZoneTask(microTask, source, callback, data, customSchedule, null));

};

Zone.prototype.scheduleMacroTask = function (source, callback, data, customSchedule, customCancel) {

return this.scheduleTask(new ZoneTask(macroTask, source, callback, data, customSchedule, customCancel));

};

Zone.prototype.scheduleEventTask = function (source, callback, data, customSchedule, customCancel) {

return this.scheduleTask(new ZoneTask(eventTask, source, callback, data, customSchedule, customCancel));

};

Zone.prototype.cancelTask = function (task) {

task._transitionTo(canceling, scheduled, running);

this._zoneDelegate.cancelTask(this, task);

this._updateTaskCount(task, -1);

task._transitionTo(notScheduled, canceling);

task.runCount = 0;

return task;

};

Zone.prototype._updateTaskCount = function (task, count) {

var zoneDelegates = task._zoneDelegates;

if (count == -1) {

task._zoneDelegates = null;

}

for (var i = 0; i < zoneDelegates.length; i++) {

zoneDelegates[i]._updateTaskCount(task.type, count);

}

};

Zone.__symbol__ = __symbol__;

return Zone;

}());

var DELEGATE_ZS = {

name: '',

onHasTask: function (delegate, _, target, hasTaskState) {

return delegate.hasTask(target, hasTaskState);

},

onScheduleTask: function (delegate, _, target, task) {

return delegate.scheduleTask(target, task);

},

onInvokeTask: function (delegate, _, target, task, applyThis, applyArgs) {

return delegate.invokeTask(target, task, applyThis, applyArgs);

},

onCancelTask: function (delegate, _, target, task) {

return delegate.cancelTask(target, task);

}

};

var ZoneDelegate = (function () {

function ZoneDelegate(zone, parentDelegate, zoneSpec) {

this._taskCounts = { microTask: 0, macroTask: 0, eventTask: 0 };

this.zone = zone;

this._parentDelegate = parentDelegate;

this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS);

this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt);

this._forkCurrZone = zoneSpec && (zoneSpec.onFork ? this.zone : parentDelegate.zone);

this._interceptZS =

zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS);

this._interceptDlgt =

zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt);

this._interceptCurrZone =

zoneSpec && (zoneSpec.onIntercept ? this.zone : parentDelegate.zone);

this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS);

this._invokeDlgt =

zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt);

this._invokeCurrZone = zoneSpec && (zoneSpec.onInvoke ? this.zone : parentDelegate.zone);

this._handleErrorZS =

zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS);

this._handleErrorDlgt =

zoneSpec && (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt);

this._handleErrorCurrZone =

zoneSpec && (zoneSpec.onHandleError ? this.zone : parentDelegate.zone);

this._scheduleTaskZS =

zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS);

this._scheduleTaskDlgt =

zoneSpec && (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt);

this._scheduleTaskCurrZone =

zoneSpec && (zoneSpec.onScheduleTask ? this.zone : parentDelegate.zone);

this._invokeTaskZS =

zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS);

this._invokeTaskDlgt =

zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt);

this._invokeTaskCurrZone =

zoneSpec && (zoneSpec.onInvokeTask ? this.zone : parentDelegate.zone);

this._cancelTaskZS =

zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS);

this._cancelTaskDlgt =

zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt);

this._cancelTaskCurrZone =

zoneSpec && (zoneSpec.onCancelTask ? this.zone : parentDelegate.zone);

this._hasTaskZS = null;

this._hasTaskDlgt = null;

this._hasTaskDlgtOwner = null;

this._hasTaskCurrZone = null;

var zoneSpecHasTask = zoneSpec && zoneSpec.onHasTask;

var parentHasTask = parentDelegate && parentDelegate._hasTaskZS;

if (zoneSpecHasTask || parentHasTask) {

// If we need to report hasTask, than this ZS needs to do ref counting on tasks. In such

// a case all task related interceptors must go through this ZD. We can't short circuit it.

this._hasTaskZS = zoneSpecHasTask ? zoneSpec : DELEGATE_ZS;

this._hasTaskDlgt = parentDelegate;

this._hasTaskDlgtOwner = this;

this._hasTaskCurrZone = zone;

if (!zoneSpec.onScheduleTask) {

this._scheduleTaskZS = DELEGATE_ZS;

this._scheduleTaskDlgt = parentDelegate;

this._scheduleTaskCurrZone = this.zone;

}

if (!zoneSpec.onInvokeTask) {

this._invokeTaskZS = DELEGATE_ZS;

this._invokeTaskDlgt = parentDelegate;

this._invokeTaskCurrZone = this.zone;

}

if (!zoneSpec.onCancelTask) {

this._cancelTaskZS = DELEGATE_ZS;

this._cancelTaskDlgt = parentDelegate;

this._cancelTaskCurrZone = this.zone;

}

}

}

ZoneDelegate.prototype.fork = function (targetZone, zoneSpec) {

return this._forkZS ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) :

new Zone(targetZone, zoneSpec);

};

ZoneDelegate.prototype.intercept = function (targetZone, callback, source) {

return this._interceptZS ?

this._interceptZS.onIntercept(this._interceptDlgt, this._interceptCurrZone, targetZone, callback, source) :

callback;

};

ZoneDelegate.prototype.invoke = function (targetZone, callback, applyThis, applyArgs, source) {

return this._invokeZS ?

this._invokeZS.onInvoke(this._invokeDlgt, this._invokeCurrZone, targetZone, callback, applyThis, applyArgs, source) :

callback.apply(applyThis, applyArgs);

};

ZoneDelegate.prototype.handleError = function (targetZone, error) {

return this._handleErrorZS ?

this._handleErrorZS.onHandleError(this._handleErrorDlgt, this._handleErrorCurrZone, targetZone, error) :

true;

};

ZoneDelegate.prototype.scheduleTask = function (targetZone, task) {

var returnTask = task;

if (this._scheduleTaskZS) {

if (this._hasTaskZS) {

returnTask._zoneDelegates.push(this._hasTaskDlgtOwner);

}

returnTask = this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt, this._scheduleTaskCurrZone, targetZone, task);

if (!returnTask)

returnTask = task;

}

else {

if (task.scheduleFn) {

task.scheduleFn(task);

}

else if (task.type == microTask) {

scheduleMicroTask(task);

}

else {

throw new Error('Task is missing scheduleFn.');

}

}

return returnTask;

};

ZoneDelegate.prototype.invokeTask = function (targetZone, task, applyThis, applyArgs) {

return this._invokeTaskZS ?

this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt, this._invokeTaskCurrZone, targetZone, task, applyThis, applyArgs) :

task.callback.apply(applyThis, applyArgs);

};

ZoneDelegate.prototype.cancelTask = function (targetZone, task) {

var value;

if (this._cancelTaskZS) {

value = this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt, this._cancelTaskCurrZone, targetZone, task);

}

else {

value = task.cancelFn(task);

}

return value;

};

ZoneDelegate.prototype.hasTask = function (targetZone, isEmpty) {

return this._hasTaskZS &&

this._hasTaskZS.onHasTask(this._hasTaskDlgt, this._hasTaskCurrZone, targetZone, isEmpty);

};

ZoneDelegate.prototype._updateTaskCount = function (type, count) {

var counts = this._taskCounts;

var prev = counts[type];

var next = counts[type] = prev + count;

if (next < 0) {

throw new Error('More tasks executed then were scheduled.');

}

if (prev == 0 || next == 0) {

var isEmpty = {

microTask: counts.microTask > 0,

macroTask: counts.macroTask > 0,

eventTask: counts.eventTask > 0,

change: type

};

// TODO(misko): what should happen if it throws?

this.hasTask(this.zone, isEmpty);

}

};

return ZoneDelegate;

}());

var ZoneTask = (function () {

function ZoneTask(type, source, callback, options, scheduleFn, cancelFn) {

this.zone = null;

this.runCount = 0;

this._zoneDelegates = null;

this._state = 'notScheduled';

this.type = type;

this.source = source;

this.data = options;

this.scheduleFn = scheduleFn;

this.cancelFn = cancelFn;

this.callback = callback;

var self = this;

this.invoke = function () {

_numberOfNestedTaskFrames++;

try {

self.runCount++;

return self.zone.runTask(self, this, arguments);

}

finally {

if (_numberOfNestedTaskFrames == 1) {

drainMicroTaskQueue();

}

_numberOfNestedTaskFrames--;

}

};

}

Object.defineProperty(ZoneTask.prototype, "state", {

get: function () {

return this._state;

},

enumerable: true,

configurable: true

});

ZoneTask.prototype.cancelScheduleRequest = function () {

this._transitionTo(notScheduled, scheduling);

};

ZoneTask.prototype._transitionTo = function (toState, fromState1, fromState2) {

console.log(this, /*Object.id(this),*/ toState, fromState1, fromState2);

if (this._state === fromState1 || this._state === fromState2) {

this._state = toState;

if (toState == notScheduled) {

this._zoneDelegates = null;

}

}

else {

debugger;

throw new Error(this.type + " '" + this.source + "': can not transition to '" + toState + "', expecting state '" + fromState1 + "'" + (fromState2 ?

' or \'' + fromState2 + '\'' :

'') + ", was '" + this._state + "'.");

}

};

ZoneTask.prototype.toString = function () {

if (this.data && typeof this.data.handleId !== 'undefined') {

return this.data.handleId;

}

else {

return Object.prototype.toString.call(this);

}

};

// add toJSON method to prevent cyclic error when

// call JSON.stringify(zoneTask)

ZoneTask.prototype.toJSON = function () {

return {

type: this.type,

state: this.state,

source: this.source,

data: this.data,

zone: this.zone.name,

invoke: this.invoke,

scheduleFn: this.scheduleFn,

cancelFn: this.cancelFn,

runCount: this.runCount,

callback: this.callback

};

};

return ZoneTask;

}());

var ZoneFrame = (function () {

function ZoneFrame(parent, zone) {

this.parent = parent;

this.zone = zone;

}

return ZoneFrame;

}());

function __symbol__(name) {

return '__zone_symbol__' + name;

}

var symbolSetTimeout = __symbol__('setTimeout');

var symbolPromise = __symbol__('Promise');

var symbolThen = __symbol__('then');

var _currentZoneFrame = new ZoneFrame(null, new Zone(null, null));

var _currentTask = null;

var _microTaskQueue = [];

var _isDrainingMicrotaskQueue = false;

var _uncaughtPromiseErrors = [];

var _numberOfNestedTaskFrames = 0;

function scheduleQueueDrain() {

// if we are not running in any task, and there has not been anything scheduled

// we must bootstrap the initial task creation by manually scheduling the drain

if (_numberOfNestedTaskFrames === 0 && _microTaskQueue.length === 0) {

// We are not running in Task, so we need to kickstart the microtask queue.

if (global[symbolPromise]) {

global[symbolPromise].resolve(0)[symbolThen](drainMicroTaskQueue);

}

else {

global[symbolSetTimeout](drainMicroTaskQueue, 0);

}

}

}

function scheduleMicroTask(task) {

scheduleQueueDrain();

_microTaskQueue.push(task);

}

function consoleError(e) {

var rejection = e && e.rejection;

if (rejection) {

console.error('Unhandled Promise rejection:', rejection instanceof Error ? rejection.message : rejection, '; Zone:', e.zone.name, '; Task:', e.task && e.task.source, '; Value:', rejection, rejection instanceof Error ? rejection.stack : undefined);

}

console.error(e);

}

function drainMicroTaskQueue() {

if (!_isDrainingMicrotaskQueue) {

_isDrainingMicrotaskQueue = true;

while (_microTaskQueue.length) {

var queue = _microTaskQueue;

_microTaskQueue = [];

for (var i = 0; i < queue.length; i++) {

var task = queue[i];

try {

task.zone.runTask(task, null, null);

}

catch (error) {

consoleError(error);

}

}

}

while (_uncaughtPromiseErrors.length) {

var _loop_1 = function() {

var uncaughtPromiseError = _uncaughtPromiseErrors.shift();

try {

uncaughtPromiseError.zone.runGuarded(function () {

throw uncaughtPromiseError;

});

}

catch (error) {

consoleError(error);

}

};

while (_uncaughtPromiseErrors.length) {

_loop_1();

}

}

_isDrainingMicrotaskQueue = false;

}

}

function isThenable(value) {

return value && value.then;

}

function forwardResolution(value) {

return value;

}

function forwardRejection(rejection) {

return ZoneAwarePromise.reject(rejection);

}

var symbolState = __symbol__('state');

var symbolValue = __symbol__('value');

var source = 'Promise.then';

var UNRESOLVED = null;

var RESOLVED = true;

var REJECTED = false;

var REJECTED_NO_CATCH = 0;

function makeResolver(promise, state) {

return function (v) {

try {

resolvePromise(promise, state, v);

}

catch (err) {

resolvePromise(promise, false, err);

}

// Do not return value or you will break the Promise spec.

};

}

var once = function () {

var wasCalled = false;

return function wrapper(wrappedFunction) {

return function () {

if (wasCalled) {

return;

}

wasCalled = true;

wrappedFunction.apply(null, arguments);

};

};

};

// Promise Resolution

function resolvePromise(promise, state, value) {

var onceWrapper = once();

if (promise === value) {

throw new TypeError('Promise resolved with itself');

}

if (promise[symbolState] === UNRESOLVED) {

// should only get value.then once based on promise spec.

var then = null;

try {

if (typeof value === 'object' || typeof value === 'function') {

then = value && value.then;

}

}

catch (err) {

onceWrapper(function () {

resolvePromise(promise, false, err);

})();

return promise;

}

// if (value instanceof ZoneAwarePromise) {

if (state !== REJECTED && value instanceof ZoneAwarePromise &&

value.hasOwnProperty(symbolState) && value.hasOwnProperty(symbolValue) &&

value[symbolState] !== UNRESOLVED) {

clearRejectedNoCatch(value);

resolvePromise(promise, value[symbolState], value[symbolValue]);

}

else if (state !== REJECTED && typeof then === 'function') {

try {

then.apply(value, [

onceWrapper(makeResolver(promise, state)), onceWrapper(makeResolver(promise, false))

]);

}

catch (err) {

onceWrapper(function () {

resolvePromise(promise, false, err);

})();

}

}

else {

promise[symbolState] = state;

var queue = promise[symbolValue];

promise[symbolValue] = value;

for (var i = 0; i < queue.length;) {

scheduleResolveOrReject(promise, queue[i++], queue[i++], queue[i++], queue[i++]);

}

if (queue.length == 0 && state == REJECTED) {

promise[symbolState] = REJECTED_NO_CATCH;

try {

throw new Error('Uncaught (in promise): ' + value +

(value && value.stack ? '\n' + value.stack : ''));

}

catch (err) {

var error_1 = err;

error_1.rejection = value;

error_1.promise = promise;

error_1.zone = Zone.current;

error_1.task = Zone.currentTask;

_uncaughtPromiseErrors.push(error_1);

scheduleQueueDrain();

}

}

}

}

// Resolving an already resolved promise is a noop.

return promise;

}

function clearRejectedNoCatch(promise) {

if (promise[symbolState] === REJECTED_NO_CATCH) {

promise[symbolState] = REJECTED;

for (var i = 0; i < _uncaughtPromiseErrors.length; i++) {

if (promise === _uncaughtPromiseErrors[i].promise) {

_uncaughtPromiseErrors.splice(i, 1);

break;

}

}

}

}

function scheduleResolveOrReject(promise, zone, chainPromise, onFulfilled, onRejected) {

clearRejectedNoCatch(promise);

var delegate = promise[symbolState] ?

(typeof onFulfilled === 'function') ? onFulfilled : forwardResolution :

(typeof onRejected === 'function') ? onRejected : forwardRejection;

zone.scheduleMicroTask(source, function () {

try {

resolvePromise(chainPromise, true, zone.run(delegate, undefined, [promise[symbolValue]]));

}

catch (error) {

resolvePromise(chainPromise, false, error);

}

});

}

var ZoneAwarePromise = (function () {

function ZoneAwarePromise(executor) {

var promise = this;

if (!(promise instanceof ZoneAwarePromise)) {

throw new Error('Must be an instanceof Promise.');

}

promise[symbolState] = UNRESOLVED;

promise[symbolValue] = []; // queue;

try {

executor && executor(makeResolver(promise, RESOLVED), makeResolver(promise, REJECTED));

}

catch (error) {

resolvePromise(promise, false, error);

}

}

ZoneAwarePromise.toString = function () {

return 'function ZoneAwarePromise() { [native code] }';

};

ZoneAwarePromise.resolve = function (value) {

return resolvePromise(new this(null), RESOLVED, value);

};

ZoneAwarePromise.reject = function (error) {

return resolvePromise(new this(null), REJECTED, error);

};

ZoneAwarePromise.race = function (values) {

var resolve;

var reject;

var promise = new this(function (res, rej) {

_a = [res, rej], resolve = _a[0], reject = _a[1];

var _a;

});

function onResolve(value) {

promise && (promise = null || resolve(value));

}

function onReject(error) {

promise && (promise = null || reject(error));

}

for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {

var value = values_1[_i];

if (!isThenable(value)) {

value = this.resolve(value);

}

value.then(onResolve, onReject);

}

return promise;

};

ZoneAwarePromise.all = function (values) {

var resolve;

var reject;

var promise = new this(function (res, rej) {

resolve = res;

reject = rej;

});

var count = 0;

var resolvedValues = [];

for (var _i = 0, values_2 = values; _i < values_2.length; _i++) {

var value = values_2[_i];

if (!isThenable(value)) {

value = this.resolve(value);

}

value.then((function (index) { return function (value) {

resolvedValues[index] = value;

count--;

if (!count) {

resolve(resolvedValues);

}

}; })(count), reject);

count++;

}

if (!count)

resolve(resolvedValues);

return promise;

};

ZoneAwarePromise.prototype.then = function (onFulfilled, onRejected) {

var chainPromise = new this.constructor(null);

var zone = Zone.current;

if (this[symbolState] == UNRESOLVED) {

this[symbolValue].push(zone, chainPromise, onFulfilled, onRejected);

}

else {

scheduleResolveOrReject(this, zone, chainPromise, onFulfilled, onRejected);

}

return chainPromise;

};

ZoneAwarePromise.prototype.catch = function (onRejected) {

return this.then(null, onRejected);

};

return ZoneAwarePromise;

}());

// Protect against aggressive optimizers dropping seemingly unused properties.

// E.g. Closure Compiler in advanced mode.

ZoneAwarePromise['resolve'] = ZoneAwarePromise.resolve;

ZoneAwarePromise['reject'] = ZoneAwarePromise.reject;

ZoneAwarePromise['race'] = ZoneAwarePromise.race;

ZoneAwarePromise['all'] = ZoneAwarePromise.all;

var NativePromise = global[symbolPromise] = global['Promise'];

global['Promise'] = ZoneAwarePromise;

var symbolThenPatched = __symbol__('thenPatched');

function patchThen(Ctor) {

var proto = Ctor.prototype;

var originalThen = proto.then;

// Keep a reference to the original method.

proto[symbolThen] = originalThen;

Ctor.prototype.then = function (onResolve, onReject) {

var _this = this;

var wrapped = new ZoneAwarePromise(function (resolve, reject) {

originalThen.call(_this, resolve, reject);

});

return wrapped.then(onResolve, onReject);

};

Ctor[symbolThenPatched] = true;

}

function zoneify(fn) {

return function () {

var resultPromise = fn.apply(this, arguments);

if (resultPromise instanceof ZoneAwarePromise) {

return resultPromise;

}

var Ctor = resultPromise.constructor;

if (!Ctor[symbolThenPatched]) {

patchThen(Ctor);

}

return resultPromise;

};

}

if (NativePromise) {

patchThen(NativePromise);

var fetch = global['fetch'];

if (typeof fetch == 'function') {

global['fetch'] = zoneify(fetch);

}

}

// This is not part of public API, but it is usefull for tests, so we expose it.

Promise[Zone.__symbol__('uncaughtPromiseErrors')] = _uncaughtPromiseErrors;

/*

* This code patches Error so that:

* - It ignores un-needed stack frames.

* - It Shows the associated Zone for reach frame.

*/

var FrameType;

(function (FrameType) {

/// Skip this frame when printing out stack

FrameType[FrameType["blackList"] = 0] = "blackList";

/// This frame marks zone transition

FrameType[FrameType["transition"] = 1] = "transition";

})(FrameType || (FrameType = {}));

var NativeError = global[__symbol__('Error')] = global.Error;

// Store the frames which should be removed from the stack frames

var blackListedStackFrames = {};

// We must find the frame where Error was created, otherwise we assume we don't understand stack

var zoneAwareFrame;

global.Error = ZoneAwareError;

// How should the stack frames be parsed.

var frameParserStrategy = null;

var stackRewrite = 'stackRewrite';

// fix #595, create property descriptor

// for error properties

var createProperty = function (props, key) {

// if property is already defined, skip it.

if (props[key]) {

return;

}

// define a local property

// in case error property is not settable

var name = __symbol__(key);

props[key] = {

configurable: true,

enumerable: true,

get: function () {

// if local property has no value

// use internal error's property value

if (!this[name]) {

var error_2 = this[__symbol__('error')];

if (error_2) {

this[name] = error_2[key];

}

}

return this[name];

},

set: function (value) {

// setter will set value to local property value

this[name] = value;

}

};

};

// fix #595, create property descriptor

// for error method properties

var createMethodProperty = function (props, key) {

if (props[key]) {

return;

}

props[key] = {

configurable: true,

enumerable: true,

writable: true,

value: function () {

var error = this[__symbol__('error')];

var errorMethod = (error && error[key]) || this[key];

if (errorMethod) {

return errorMethod.apply(error, arguments);

}

}

};

};

var createErrorProperties = function () {

var props = Object.create(null);

var error = new NativeError();

var keys = Object.getOwnPropertyNames(error);

for (var i = 0; i < keys.length; i++) {

var key = keys[i];

// Avoid bugs when hasOwnProperty is shadowed

if (Object.prototype.hasOwnProperty.call(error, key)) {

createProperty(props, key);

}

}

var proto = NativeError.prototype;

if (proto) {

var pKeys = Object.getOwnPropertyNames(proto);

for (var i = 0; i < pKeys.length; i++) {

var key = pKeys[i];

// skip constructor

if (key !== 'constructor' && key !== 'toString' && key !== 'toSource') {

createProperty(props, key);

}

}

}

// some other properties are not

// in NativeError

createProperty(props, 'originalStack');

createProperty(props, 'zoneAwareStack');

// define toString, toSource as method property

createMethodProperty(props, 'toString');

createMethodProperty(props, 'toSource');

return props;

};

var errorProperties = createErrorProperties();

// for derived Error class which extends ZoneAwareError

// we should not override the derived class's property

// so we create a new props object only copy the properties

// from errorProperties which not exist in derived Error's prototype

var getErrorPropertiesForPrototype = function (prototype) {

// if the prototype is ZoneAwareError.prototype

// we just return the prebuilt errorProperties.

if (prototype === ZoneAwareError.prototype) {

return errorProperties;

}

var newProps = Object.create(null);

var cKeys = Object.getOwnPropertyNames(errorProperties);

var keys = Object.getOwnPropertyNames(prototype);

cKeys.forEach(function (cKey) {

if (keys.filter(function (key) {

return key === cKey;

})

.length === 0) {

newProps[cKey] = errorProperties[cKey];

}

});

return newProps;

};

/**

* This is ZoneAwareError which processes the stack frame and cleans up extra frames as well as

* adds zone information to it.

*/

function ZoneAwareError() {

// make sure we have a valid this

// if this is undefined(call Error without new) or this is global

// or this is some other objects, we should force to create a

// valid ZoneAwareError by call Object.create()

if (!(this instanceof ZoneAwareError)) {

return ZoneAwareError.apply(Object.create(ZoneAwareError.prototype), arguments);

}

// Create an Error.

var error = NativeError.apply(this, arguments);

this[__symbol__('error')] = error;

// Save original stack trace

error.originalStack = error.stack;

// Process the stack trace and rewrite the frames.

if (ZoneAwareError[stackRewrite] && error.originalStack) {

var frames_1 = error.originalStack.split('\n');

var zoneFrame = _currentZoneFrame;

var i = 0;

// Find the first frame

while (frames_1[i] !== zoneAwareFrame && i < frames_1.length) {

i++;

}

for (; i < frames_1.length && zoneFrame; i++) {

var frame = frames_1[i];

if (frame.trim()) {

var frameType = blackListedStackFrames.hasOwnProperty(frame) && blackListedStackFrames[frame];

if (frameType === FrameType.blackList) {

frames_1.splice(i, 1);

i--;

}

else if (frameType === FrameType.transition) {

if (zoneFrame.parent) {

// This is the special frame where zone changed. Print and process it accordingly

frames_1[i] += " [" + zoneFrame.parent.zone.name + " => " + zoneFrame.zone.name + "]";

zoneFrame = zoneFrame.parent;

}

else {

zoneFrame = null;

}

}

else {

frames_1[i] += " [" + zoneFrame.zone.name + "]";

}

}

}

error.stack = error.zoneAwareStack = frames_1.join('\n');

}

// use defineProperties here instead of copy property value

// because of issue #595 which will break angular2.

Object.defineProperties(this, getErrorPropertiesForPrototype(Object.getPrototypeOf(this)));

return this;