MiPush 消息发送类
@param options
@constructor
485471
function (options) {
  debug("MiPush:Sender init:", options);

  this.appSecret = options.appSecret;
  this.request   = request;
  this.urls      = new constants();
}
129363
function(type, options) {
		L.Util.setOptions(this, options);

		this._ready = google.maps.Map !== undefined;
		if (!this._ready) L.Google.asyncWait.push(this);

		this._type = type || 'SATELLITE';
	}
830028
function (options) {
                var self = this;

                self._requestQueue = []

                self._socketOptions = angular.extend({}, _socketDefaults, options);

                self._socket = new TmpSocket();

                if (self._socketOptions.autoConnect) self.connect();
            }
801556
function(options) {
  this.debug = options.debug;

  this.board = options.board;
  this.connection = options.connection;

  this.chip = new options.protocol({ quiet: true });
}
898576
@SuppressWarnings("unused")
    private void opSetOptionPush() {
        // option = code[ip++]; // final for now
        pushAlt(ip, s, sprev, pkeep);
        ip += OPSize.SET_OPTION + OPSize.FAIL;
    }
565503
function mpify (node, options) {
  var target = options.target; if ( target === void 0 ) target = 'wechat';
  var imports = options.imports; if ( imports === void 0 ) imports = {};
  var transformAssetUrls = options.transformAssetUrls; if ( transformAssetUrls === void 0 ) transformAssetUrls = {};
  var scopeId = options.scopeId; if ( scopeId === void 0 ) scopeId = '';
  sep = "'" + (LIST_TAIL_SEPS[target]) + "'";
  var preset = presets[target];
  var state = new State({
    rootNode: node,
    target: target,
    preset: preset,
    imports: imports,
    transformAssetUrls: transformAssetUrls,
    scopeId: scopeId
  });
  if (scopeId) {
    addAttr$1(node, 'sc_', ("\"" + scopeId + "\""));
  }
  walk(node, state);
}
715464
function IOStream(options) {
  if (!(this instanceof IOStream)) {
    return new IOStream(options);
  }

  IOStream.super_.call(this, options);

  this.options = options;
  this.id = uuid();
  this.socket = null;

  // Buffers
  this.pushBuffer = [];
  this.writeBuffer = [];

  // Op states
  this._readable = false;
  this._writable = false;
  this.destroyed = false;

  // default to *not* allowing half open sockets
  this.allowHalfOpen = options && options.allowHalfOpen || false;

  this.on('finish', this._onfinish);
  this.on('end', this._onend);
  this.on('error', this._onerror);
}
959474
function (options) {
			this.options = $.extend(this.defaults, options);
			this.$el = $.fn.mediumInsert.insert.$el;
			this.setEmbedButtonEvents();
			this.preparePreviousEmbeds();
		}
1264852
function add(opts, fn) {
    // Argument shuffling.
    if (!fn && typeof opts === 'function') {
      fn = opts;
      opts = undefined;
    }
    // Default options.
    opts = opts || {};
    opts.interval = opts.interval || 15 * 1000;
    opts.jitter = opts.jitter || 0.2;
    // Flag for stopping repeating interval.
    var stopFlag = false;
    // Recursive function.
    function rec() {
      // Start a new promise.
      return Promise.fromNode(function(cb) {
        // Apply jitter to interval to get next timeout duration.
        var duration = applyJitter(opts.jitter, opts.interval);
        // Init a timeout.
        setTimeout(function() {
          // Run handler function.
          return $q.try(fn)
          // Handle errors.
          .catch(function(err) {
            return errorHandler(err);
          })
          // Resolve promise.
          .nodeify(cb);
        }, duration);
      })
      // Recurse unless top flag has been set.
      .then(function() {
        if (!stopFlag) {
          return rec();
        }
      });
    }
    // Hold onto promise returned by recursive function so caller can wait on it.
    var prm = rec();
    // Return micro api so called can turn it off and wait for it to finish.
    var api = {
      fn: fn,
      stop: function() {
        // Tell recursive function to stop.
        stopFlag = true;
        // Return promise.
        return prm;
      }
    };
    // Add api to list of apis.
    fns.push(api);
    // Return api.
    return api;
  }
830779
function flow(options) {
	const result = spawnSync(bin, [
		'check-contents',
		'--json',
		`--root=${options.root}`,
		options.fileName
	], {
		input: options.source,
		encoding: 'utf-8'
	});

	if (result.status !== 0) {
		return [{
			message: result.stderr,
			loc: {
				start: {
					line: 1
				},
				end: {
					line: 1
				}
			}
		}];
	}

	const {errors} = JSON.parse(result.stdout);

	return errors.map(error => {
		const [leading, ...rest] = error.message;
		const payload = rest.map(m => format(m, {
			root: options.root
		}));

		return {
			message: [leading.descr, ...payload].join(': '),
			path: leading.path,
			start: leading.loc.start.line,
			end: leading.loc.end.line,
			loc: leading.loc
		};
	});
}
1282113
function(options) {
        this.position = new OpenLayers.Pixel(OpenLayers.Control.PanZoom.X,
                                             OpenLayers.Control.PanZoom.Y);
        OpenLayers.Control.prototype.initialize.apply(this, arguments);
    }
961969
function GELFManager(options) {

  if (typeof options === 'undefined') options = {};
  for (k in GELFManager.options)
    if (typeof options[k] === 'undefined')
      options[k] = GELFManager.options[k];

  this.debug        = options.debug;
  this.chunkTimeout = options.chunkTimeout;
  this.gcTimeout    = options.gcTimeout;

  EventEmitter.call(this);
  this.chunksPool = {};

  process.nextTick(this._gc.bind(this));

}
219429
function MucProxy(options) {
    this.service = options.service;
    this.helpers = options.helpers;
    this.connection = options.stropheClient;
    this.Client = options.xmppClient;
    this.nodeStanzasCallbacks = options.nodeStanzasCallbacks;
    //
    this.joinedRooms = {};
}
1229273
function(options) {
			this.inputStream = options.inputStream || process.stdin;
			this.outputStream = options.outputStream || process.stdout;
		}
624690
function Aliyun_Push(opts) {
  opts = opts || {};

  this.AccessKeyId = opts.AccessKeyId;
  this.AccessKeySecret = opts.AccessKeySecret;
  this.AccountName = opts.AccountName;
  this.dmHost = 'https://dm.aliyuncs.com/';
  this.smsHost = 'https://sms.aliyuncs.com/';

  this.publicParams = {
    Format: 'JSON',
    AccessKeyId: opts.AccessKeyId,
    SignatureMethod: 'HMAC-SHA1',
    Timestamp: '',
    SignatureVersion: '1.0',
    SignatureNonce: '',
  };
  this.singleOptions = {
    Action: 'SingleSendMail',
    AccountName: opts.AccountName,
    ReplyToAddress: true,
    AddressType: 1
  }
  this.batchOptions = {
    Action: 'BatchSendMail',
    AccountName: opts.AccountName,
    ReplyToAddress: true,
    AddressType: 1
  }
  this.smsOptions = {
    Action: 'SingleSendSms'
  }
}
448798
function pushSingle(arr, element) {
    var index = arr.sortedIndex(element),
        _ = arr._sortedArray;

    // original push and unshift are faster than splice
    if (index === 0) {
        _.unshift.call(arr, element);
    } else if (index === arr.length) {
        _.push.call(arr, element);
    } else {
        _.splice.call(arr, index, 0, element);
    }
}
61132
function gitPush () {
      var branch = options.branch;
      var withForce = options.force ? ' --force ' : '';

      if (options.remoteBranch) branch += ':' + options.remoteBranch;

      log.subhead('Pushing ' + options.branch + ' to ' + options.remote + withForce);
      execWrap('git push ' + withForce + remoteName + ' ' + branch, false, true);

      if (options.tag) {
        execWrap('git push ' + remoteName + ' ' + options.tag);
      }
    }