text: /**
  * @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 ProxyZoneSpec = /** @class */ (function () {
      function ProxyZoneSpec(defaultSpecDelegate) {
          if (defaultSpecDelegate === void 0) { defaultSpecDelegate = null; }
          this.defaultSpecDelegate = defaultSpecDelegate;
          this.name = 'ProxyZone';
          this.properties = { 'ProxyZoneSpec': this };
          this.propertyKeys = null;
          this.lastTaskState = null;
          this.isNeedToTriggerHasTask = false;
          this.tasks = [];
          this.setDelegate(defaultSpecDelegate);
      }
      ProxyZoneSpec.get = function () {
          return Zone.current.get('ProxyZoneSpec');
      };
      ProxyZoneSpec.isLoaded = function () {
          return ProxyZoneSpec.get() instanceof ProxyZoneSpec;
      };
      ProxyZoneSpec.assertPresent = function () {
          if (!ProxyZoneSpec.isLoaded()) {
              throw new Error("Expected to be running in 'ProxyZone', but it was not found.");
          }
          return ProxyZoneSpec.get();
      };
      ProxyZoneSpec.prototype.setDelegate = function (delegateSpec) {
          var _this = this;
          var isNewDelegate = this._delegateSpec !== delegateSpec;
          this._delegateSpec = delegateSpec;
          this.propertyKeys && this.propertyKeys.forEach(function (key) { return delete _this.properties[key]; });
          this.propertyKeys = null;
          if (delegateSpec && delegateSpec.properties) {
              this.propertyKeys = Object.keys(delegateSpec.properties);
              this.propertyKeys.forEach(function (k) { return _this.properties[k] = delegateSpec.properties[k]; });
          }
          // if set a new delegateSpec, shoulde check whether need to
          // trigger hasTask or not
          if (isNewDelegate && this.lastTaskState &&
              (this.lastTaskState.macroTask || this.lastTaskState.microTask)) {
              this.isNeedToTriggerHasTask = true;
          }
      };
      ProxyZoneSpec.prototype.getDelegate = function () {
          return this._delegateSpec;
      };
      ProxyZoneSpec.prototype.resetDelegate = function () {
          this.setDelegate(this.defaultSpecDelegate);
      };
      ProxyZoneSpec.prototype.tryTriggerHasTask = function (parentZoneDelegate, currentZone, targetZone) {
          if (this.isNeedToTriggerHasTask && this.lastTaskState) {
              // last delegateSpec has microTask or macroTask
              // should call onHasTask in current delegateSpec
              this.isNeedToTriggerHasTask = false;
              this.onHasTask(parentZoneDelegate, currentZone, targetZone, this.lastTaskState);
          }
      };
      ProxyZoneSpec.prototype.removeFromTasks = function (task) {
          if (!this.tasks) {
              return;
          }
          for (var i = 0; i < this.tasks.length; i++) {
              if (this.tasks[i] === task) {
                  this.tasks.splice(i, 1);
                  return;
              }
          }
      };
      ProxyZoneSpec.prototype.getAndClearPendingTasksInfo = function () {
          if (this.tasks.length === 0) {
              return '';
          }
          var taskInfo = this.tasks.map(function (task) {
              var dataInfo = task.data &&
                  Object.keys(task.data)
                      .map(function (key) {
                      return key + ':' + task.data[key];
                  })
                      .join(',');
              return "type: " + task.type + ", source: " + task.source + ", args: {" + dataInfo + "}";
          });
          var pendingTasksInfo = '--Pendng async tasks are: [' + taskInfo + ']';
          // clear tasks
          this.tasks = [];
          return pendingTasksInfo;
      };
      ProxyZoneSpec.prototype.onFork = function (parentZoneDelegate, currentZone, targetZone, zoneSpec) {
          if (this._delegateSpec && this._delegateSpec.onFork) {
              return this._delegateSpec.onFork(parentZoneDelegate, currentZone, targetZone, zoneSpec);
          }
          else {
              return parentZoneDelegate.fork(targetZone, zoneSpec);
          }
      };
      ProxyZoneSpec.prototype.onIntercept = function (parentZoneDelegate, currentZone, targetZone, delegate, source) {
          if (this._delegateSpec && this._delegateSpec.onIntercept) {
              return this._delegateSpec.onIntercept(parentZoneDelegate, currentZone, targetZone, delegate, source);
          }
          else {
              return parentZoneDelegate.intercept(targetZone, delegate, source);
          }
      };
      ProxyZoneSpec.prototype.onInvoke = function (parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source) {
          this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
          if (this._delegateSpec && this._delegateSpec.onInvoke) {
              return this._delegateSpec.onInvoke(parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source);
          }
          else {
              return parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source);
          }
      };
      ProxyZoneSpec.prototype.onHandleError = function (parentZoneDelegate, currentZone, targetZone, error) {
          if (this._delegateSpec && this._delegateSpec.onHandleError) {
              return this._delegateSpec.onHandleError(parentZoneDelegate, currentZone, targetZone, error);
          }
          else {
              return parentZoneDelegate.handleError(targetZone, error);
          }
      };
      ProxyZoneSpec.prototype.onScheduleTask = function (parentZoneDelegate, currentZone, targetZone, task) {
          if (task.type !== 'eventTask') {
              this.tasks.push(task);
          }
          if (this._delegateSpec && this._delegateSpec.onScheduleTask) {
              return this._delegateSpec.onScheduleTask(parentZoneDelegate, currentZone, targetZone, task);
          }
          else {
              return parentZoneDelegate.scheduleTask(targetZone, task);
          }
      };
      ProxyZoneSpec.prototype.onInvokeTask = function (parentZoneDelegate, currentZone, targetZone, task, applyThis, applyArgs) {
          if (task.type !== 'eventTask') {
              this.removeFromTasks(task);
          }
          this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
          if (this._delegateSpec && this._delegateSpec.onInvokeTask) {
              return this._delegateSpec.onInvokeTask(parentZoneDelegate, currentZone, targetZone, task, applyThis, applyArgs);
          }
          else {
              return parentZoneDelegate.invokeTask(targetZone, task, applyThis, applyArgs);
          }
      };
      ProxyZoneSpec.prototype.onCancelTask = function (parentZoneDelegate, currentZone, targetZone, task) {
          if (task.type !== 'eventTask') {
              this.removeFromTasks(task);
          }
          this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
          if (this._delegateSpec && this._delegateSpec.onCancelTask) {
              return this._delegateSpec.onCancelTask(parentZoneDelegate, currentZone, targetZone, task);
          }
          else {
              return parentZoneDelegate.cancelTask(targetZone, task);
          }
      };
      ProxyZoneSpec.prototype.onHasTask = function (delegate, current, target, hasTaskState) {
          this.lastTaskState = hasTaskState;
          if (this._delegateSpec && this._delegateSpec.onHasTask) {
              this._delegateSpec.onHasTask(delegate, current, target, hasTaskState);
          }
          else {
              delegate.hasTask(target, hasTaskState);
          }
      };
      return ProxyZoneSpec;
  }());
  // Export the class so that new instances can be created with proper
  // constructor params.
  Zone['ProxyZoneSpec'] = ProxyZoneSpec;
  
  })));
  