A Reset Event.
@constructor
@param {boolean} isSignaled - if true then the reset event starts signaled (all calls to wait will pass through)
@param {object} options - optional set of options for this reset event
184993
function (isSignaled, options) {
    this.queue = [];
    this.isSignaled = Boolean(isSignaled);
    this.options = _.extend({}, ResetEvent.defaultOptions, options);
}
513191
function(options) {
      options = options || {};
      var changing = this._changing;
      this._changing = true;

      // Silent changes become pending changes.
      var self = this;
      Parse._objectEach(this._silent, function(attr) {
        self._pending[attr] = true;
      });

      // Silent changes are triggered.
      var changes = _.extend({}, options.changes, this._silent);
      this._silent = {};
      Parse._objectEach(changes, function(unused_value, attr) {
        self.trigger('change:' + attr, self, self.get(attr), options);
      });
      if (changing) {
        return this;
      }

      // This is to get around lint not letting us make a function in a loop.
      var deleteChanged = function(value, attr) {
        if (!self._pending[attr] && !self._silent[attr]) {
          delete self.changed[attr];
        }
      };

      // Continue firing `"change"` events while there are pending changes.
      while (!_.isEmpty(this._pending)) {
        this._pending = {};
        this.trigger('change', this, options);
        // Pending and silent changes still remain.
        Parse._objectEach(this.changed, deleteChanged);
        self._previousAttributes = _.clone(this.attributes);
      }

      this._changing = false;
      return this;
    }
1008405
private boolean tryToNotifyReset() {
        if ((mStatus == PTR_STATUS_COMPLETE || mStatus == PTR_STATUS_PREPARE) && mPtrIndicator.isInStartPosition()) {
            if (mPtrUIHandlerHolder.hasHandler()) {
                mPtrUIHandlerHolder.onUIReset(this);
                if (DEBUG) {
                    PtrCLog.i(LOG_TAG, "PtrUIHandler: onUIReset");
                }
            }
            mStatus = PTR_STATUS_INIT;
            clearFlag();
            return true;
        }
        return false;
    }
258935
function (options) {
    this.queue = [];
    this.ownerTokenId = null;
    this.options = _.extend({}, AsyncLock.defaultOptions, options);
}
709602
function changeDelegatedHandler(eventOptions = {}) {
    const { key } = eventOptions;
    const def = defs.get(this);

    if (key && key in def.keys) {
        triggerOne(this, '_asterisk:set', eventOptions);
    }
}
40513
function abortSignal(signal) {
    if (abortedFlags.get(signal) !== false) {
        return;
    }
    abortedFlags.set(signal, true);
    signal.dispatchEvent({ type: "abort" });
}
422342
function(cls, options) {
            var d = Q.defer();

            cls = cls || DialogView;
            var diag = new cls(options);

            diag.once("close", function(result, e) {
                if (result != null) {
                    d.resolve(result);
                } else {
                    d.reject(result);
                }
            });
            setTimeout(function() {
                d.notify(diag);
            }, 1);
            diag.update();

            return d.promise;
        }
1073982
public void setReady(boolean ready)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setReady", Boolean.valueOf(ready));

        this.ready = ready;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setReady");
    }
688721
function(options) {
    options = options ? extend({}, options) : {};
    if (options.parse === void 0){
      options.parse = true;
    }
    var collection = this;
    var listener = {};
    var listenerKey;

    options.cb = options.callback;
    options.callback = function (err, response){
      callback(err, collection, response, options);
    };

    options.respCallback = function cb(data, cbServer){
      var method = options.reset ? 'reset' : 'set';
      collection.removeListeners([collection.events.onFetch]);
      if(cbServer){
        cbServer();
      }
      if(data.err){
        return callback(data.err, collection, data, options);
      }
      collection[method](data.response, options);
      callback(data.err, collection, data, options);
    };

    listenerKey = this.events.onFetch;
    listener[listenerKey] = {fn: options.respCallback, active: true};
    this.addListeners(listener);
    this.emit(this.events.fetch, this, options);
    return collection;
  }
476261
function(callOpts) {
			var flag = this.isSelected();

			//		this.debug("fixSelection3AfterClick()");

			this.visit(function(node) {
				node._changeSelectStatusAttrs(flag);
			});
			this.fixSelection3FromEndNodes(callOpts);
		}
455478
function (filteredIn) {
                if (filteredIn == null) {
                    filteredIn = true;
                }
                // if not already done, we must first refresh the initial array before marking all elements:
                this._refreshInitialArray();
                var items = this.items;
                var itemsLength = items.length;
                for (var i = 0; i < itemsLength; i++) {
                    json.setValue(items[i], "filteredIn", filteredIn, this._jsonChangeCallback);
                }
                this.notifyChange(this._CHANGED_FILTERED_IN);
            }
624230
function PointerEvent(options) {
    var _this = this;

    _classCallCheck(this, PointerEvent);

    this.startHandlers = {};
    this.lastHandlerId = 0;
    this.curPointerClass = null;
    this.curTouchId = null;
    this.lastPointerXY = { clientX: 0, clientY: 0 };
    this.lastTouchTime = 0;

    // Options
    this.options = { // Default
      preventDefault: true,
      stopPropagation: true
    };
    if (options) {
      ['preventDefault', 'stopPropagation'].forEach(function (option) {
        if (typeof options[option] === 'boolean') {
          _this.options[option] = options[option];
        }
      });
    }
  }
932847
function(time) {
    var self = this;
    self.eventDetection.recordRelease(time);

    if (self.eventDetection.isLongPress()) {
      // this is a "long-press" -  reset detection states and notify the "long-press" observers
      self.eventDetection.reset();
      self._notifyObservers(self.onLongPressCallbackRegistry);
    } else {
      if (self.eventDetection.onReleaseCount >= 2) {
        // this is a double-press (or more) event, so notify the "double-press" observers
        self.eventDetection.reset();
        self._notifyObservers(self.onDoublePressCallbackRegistry);
      }

      setTimeout(function(){
        if (self.eventDetection.onReleaseCount == 1) {
          // second press did not occur within the allotted time, so notify the "short-press" observers
          self.eventDetection.reset();
          self._notifyObservers(self.onShortPressCallbackRegistry);
        }
      }, 300); // @-@:p0 make this configurable?
    }
  }
491195
function Event (type, cancelable) {
    if (cancelable) {
        Object.defineProperty(this, 'cancelable', { value: true, writable: false })
    }
    this.type = type
}
106277
function(options) {
      options || (options = {});
      var changing = this._changing;
      this._changing = true;

      // Silent changes become pending changes.
      for (var attr in this._silent) this._pending[attr] = true;

      // Silent changes are triggered.
      var changes = _.extend({}, options.changes, this._silent);
      this._silent = {};
      for (var attr in changes) {
        this.trigger('change:' + attr, this, this.get(attr), options);
      }
      if (changing) return this;

      // Continue firing `"change"` events while there are pending changes.
      while (!_.isEmpty(this._pending)) {
        this._pending = {};
        this.trigger('change', this, options);
        // Pending and silent changes still remain.
        for (var attr in this.changed) {
          if (this._pending[attr] || this._silent[attr]) continue;
          delete this.changed[attr];
        }
        this._previousAttributes = _.clone(this.attributes);
      }

      this._changing = false;
      return this;
    }
858283
async function reset () {
    // catch async errors
    try {
        if (immutableApp && immutableApp.server && immutableApp.started) {
            await stop()
        }
        // create global app instance with defaults set
        immutableApp = global.__immutable_app__ = _.cloneDeep(defaultGlobalConfig)
        // create new express app
        immutableApp.express = express()
    }
    catch (err) {
        throw err
    }
}
179001
function (items, options) {
            items = items || [];
            var self = this;
            this.each(function (item) {
                if (item instanceof EventDispatcher) {
                    item.unbind('*', self._onItemEvent, self);
                    item.unbind('change', self._onItemChange, self);
                }
            });

            this.$items = items || [];

            this.each(function (item) {
                if (item instanceof EventDispatcher) {
                    item.bind('*', self._onItemEvent, self);
                    item.bind('change', self._onItemChange, self);
                }
            });

            options = options || {};
            if (!options.silent) {
                this.trigger('reset', {items: items});
            }
        }