jrtechs
/
jrtechs-vis
mirror of https://github.com/jrtechs/vis.git
1
0
Fork 0
Code Issues 0 Releases 82 Wiki Activity
vis.js is a dynamic, browser-based visualization library
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
309 Commits
33 Branches
634 MiB
 
 
 
Tree: 3219c5d726
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3219c5d726'
${ noResults }
jrtechs-vis/showcase/projects/bridge/js/eve.js

26999 lines
807 KiB
Raw Blame History

(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory(require("amqp"));
else if(typeof define === 'function' && define.amd)
define(["amqp"], factory);
else if(typeof exports === 'object')
exports["eve"] = factory(require("amqp"));
else
root["eve"] = factory(root["amqp"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_23__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
exports.Agent = __webpack_require__(1);
exports.ServiceManager = __webpack_require__(2);
exports.TransportManager = __webpack_require__(3);
exports.module = {
BabbleModule: __webpack_require__(5),
PatternModule: __webpack_require__(6),
RequestModule: __webpack_require__(7),
RPCModule: __webpack_require__(8)
};
exports.transport = {
Transport: __webpack_require__(9),
AMQPTransport: __webpack_require__(11),
DistribusTransport: __webpack_require__(13),
HTTPTransport: __webpack_require__(15),
LocalTransport: __webpack_require__(17),
PubNubTransport: __webpack_require__(19),
WebSocketTransport: __webpack_require__(21),
connection: {
Connection: __webpack_require__(10),
AMQPConnection: __webpack_require__(12),
DistribusConnection: __webpack_require__(14),
HTTPConnection: __webpack_require__(16),
LocalConnection: __webpack_require__(18),
PubNubConnection: __webpack_require__(20),
WebSocketConnection: __webpack_require__(22)
}
};
exports.hypertimer = __webpack_require__(24);
exports.util = __webpack_require__(4);
// register all modules at the Agent
exports.Agent.registerModule(exports.module.BabbleModule);
exports.Agent.registerModule(exports.module.PatternModule);
exports.Agent.registerModule(exports.module.RequestModule);
exports.Agent.registerModule(exports.module.RPCModule);
// register all transports at the TransportManager
exports.TransportManager.registerType(exports.transport.AMQPTransport);
exports.TransportManager.registerType(exports.transport.DistribusTransport);
exports.TransportManager.registerType(exports.transport.HTTPTransport);
exports.TransportManager.registerType(exports.transport.LocalTransport);
exports.TransportManager.registerType(exports.transport.PubNubTransport);
exports.TransportManager.registerType(exports.transport.WebSocketTransport);
// load the default ServiceManager, a singleton, initialized with a LocalTransport
exports.system = new exports.ServiceManager();
exports.system.transports.add(new exports.transport.LocalTransport());
// override Agent.getTransportById in order to support Agent.connect(transportId)
exports.Agent.getTransportById = function (id) {
return exports.system.transports.get(id);
};
/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(27);
var uuid = __webpack_require__(28);
var util = __webpack_require__(4);
/**
* Agent
* @param {string} [id] Id for the agent. If not provided, the agent
* will be given a uuid.
* @constructor
*/
function Agent (id) {
this.id = id ? id.toString() : uuid();
// a list with all connected transports
this.connections = [];
this.defaultConnection = null;
this.ready = Promise.resolve([]);
}
// an object with modules which can be used to extend the agent
Agent.modules = {};
/**
* Register a new type of module. This module can then be loaded via
* Agent.extend() and Agent.loadModule().
* @param {Function} constructor A module constructor
*/
Agent.registerModule = function (constructor) {
var type = constructor.prototype.type;
if (typeof constructor !== 'function') {
throw new Error('Constructor function expected');
}
if (!type) {
throw new Error('Field "prototype.type" missing in transport constructor');
}
if (type in Agent.modules) {
if (Agent.modules[type] !== constructor) {
throw new Error('Module of type "' + type + '" already exists');
}
}
Agent.modules[type] = constructor;
};
/**
* Get a transport by id.
* This static method can be overloaded for example by the get function of
* a singleton TransportManager.
* @param {string} id
* @return {Transport}
*/
Agent.getTransportById = function (id) {
throw new Error('Transport with id "' + id + '" not found');
};
/**
* Extend an agent with modules (mixins).
* The modules new functions are added to the Agent itself.
* See also function `loadModule`.
* @param {string | string[]} module A module name or an Array with module
* names. Available modules:
* 'pattern', 'request', 'babble'
* @param {Object} [options] Additional options for loading the module
* @return {Agent} Returns the agent itself
*/
Agent.prototype.extend = function (module, options) {
if (Array.isArray(module)) {
var modules = [].concat(module);
// order the modules such that 'pattern' comes first, this module must be
// loaded before other modules ('request' specifically)
modules.sort(function (a, b) {
if (a == 'pattern') return -1;
if (b == 'pattern') return 1;
return 0;
});
// an array with module names
for (var i = 0; i < modules.length; i++) {
this.extend(modules[i], options)
}
}
else {
// a single module name
var constructor = _getModuleConstructor(module);
var instance = new constructor(this, options);
var mixin = instance.mixin();
// check for conflicts in the modules mixin functions
var me = this;
Object.keys(mixin).forEach(function (name) {
if (me[name] !== undefined && name !== '_receive') {
throw new Error('Conflict: agent already has a property "' + prop + '"');
}
});
// extend the agent with all mixin functions provided by the module
Object.keys(mixin).forEach(function (name) {
me[name] = mixin[name];
});
}
return this;
};
/**
* Load a module onto an agent.
* See also function `extend`.
* @param {string | string[]} module A module name or an Array with module
* names. Available modules:
* 'pattern', 'request', 'babble'
* @param {Object} [options] Additional options for loading the module
* @return {Object} Returns the created module
*/
Agent.prototype.loadModule = function (module, options, additionalOptions) {
var _options = options !== undefined ? Object.create(options) : {};
_options.extend = false;
var constructor = _getModuleConstructor(module);
var instance = new constructor(this, options, additionalOptions);
var mixin = instance.mixin();
// only replace the _receive function, do not add other mixin functions
this._receive = mixin._receive;
return instance;
};
/**
* Get a module constructor by it's name.
* Throws an error when the module is not found.
* @param {string} name
* @return {function} Returns the modules constructor function
* @private
*/
function _getModuleConstructor(name) {
var constructor = Agent.modules[name];
if (!constructor) {
throw new Error('Unknown module "' + name + '". ' +
'Choose from: ' + Object.keys(Agent.modules).map(JSON.stringify).join(', '));
}
return constructor;
}
/**
* Send a message to an agent
* @param {string} to
* to is either:
* - A string "agentId", the id of the recipient. Will be send
* via the default transport or when there is no default
* transport via the first connected transport.
* - A string "agentId@transportId" Only usable locally, not
* for sharing an address with remote agents.
* - A string "protocol://networkId/agentId". This is a sharable
* identifier for an agent.
* @param {*} message Message to be send
* @return {Promise} Returns a promise which resolves when the message as
* successfully been sent, or rejected when sending the
* message failed
*/
Agent.prototype.send = function(to, message) {
var colon = to.indexOf('://');
if (colon !== -1) {
// to is an url like "protocol://networkId/agentId"
var url = util.parseUrl(to);
if (url.protocol == 'http' || url.protocol == 'ws' || url.protocol == 'https') { // TODO: ugly fixed listing here...
return this._sendByProtocol(url.protocol, to, message);
}
else {
return this._sendByNetworkId(url.domain, url.path, message);
}
}
// TODO: deprecate this notation "agentId@transportId"?
var at = to.indexOf('@');
if (at != -1) {
// to is an id like "agentId@transportId"
var _to = to.substring(0, at);
var _transportId = to.substring(at + 1);
return this._sendByTransportId(_transportId, _to, message);
}
// to is an id like "agentId". Send via the default transport
var conn = this.defaultConnection;
if (conn) {
return conn.send(to, message);
}
else {
return Promise.reject(new Error('No transport found'));
}
};
/**
* Send a transport to an agent given a networkId
* @param {string} networkId A network id
* @param {string} to An agents id
* @param {string} message Message to be send
* @return {Promise} Returns a promise which resolves when the message as
* successfully been sent, or rejected when sending the
* message failed
* @private
*/
Agent.prototype._sendByNetworkId = function(networkId, to, message) {
// TODO: change this.connections to a map with networkId as keys, much faster
for (var i = 0; i < this.connections.length; i++) {
var connection = this.connections[i];
if (connection.transport.networkId == networkId) {
return connection.send(to, message);
}
}
return Promise.reject(new Error('No transport found with networkId "' + networkId + '"'));
};
/**
* Send a message by a transport by protocol.
* The message will be send via the first found transport having the specified
* protocol.
* @param {string} protocol A protocol, for example 'http' or 'ws'
* @param {string} to An agents id
* @param {string} message Message to be send
* @return {Promise} Returns a promise which resolves when the message as
* successfully been sent, or rejected when sending the
* message failed
* @private
*/
Agent.prototype._sendByProtocol = function(protocol, to, message) {
// the https addresses also make use of the http protocol.
protocol = protocol == 'https' ? 'http' : protocol;
for (var i = 0; i < this.connections.length; i++) {
var connection = this.connections[i];
if (connection.transport.type == protocol) {
return connection.send(to, message);
}
}
return Promise.reject(new Error('No transport found for protocol "' + protocol + '"'));
};
/**
* Send a transport to an agent via a specific transport
* @param {string} transportId The configured id of a transport.
* @param {string} to An agents id
* @param {string} message Message to be send
* @return {Promise} Returns a promise which resolves when the message as
* successfully been sent, or rejected when sending the
* message failed
* @private
*/
Agent.prototype._sendByTransportId = function(transportId, to, message) {
for (var i = 0; i < this.connections.length; i++) {
var connection = this.connections[i];
if (connection.transport.id == transportId) {
return connection.send(to, message);
}
}
return Promise.reject(new Error('No transport found with id "' + transportId + '"'));
};
/**
* Receive a message.
* @param {string} from Id of sender
* @param {*} message Received message, a JSON object (often a string)
*/
Agent.prototype.receive = function(from, message) {
// ... to be overloaded
};
/**
* The method _receive is overloaded in a cascaded way by modules, and calls
* the public method Agent.receive at the end of the chain.
* @param {string} from Id of sender
* @param {*} message Received message, a JSON object (often a string)
* @returns {*} Returns the return value of Agent.receive
* @private
*/
Agent.prototype._receive = function (from, message) {
return this.receive(from, message);
};
/**
* Connect to a transport. The agent will subscribe itself to
* messages sent to his id.
* @param {string | Transport | Transport[] | string[]} transport
* A Transport instance, or the id of a
* transport loaded in eve.system.
* @param {string} [id] An optional alternative id to be used
* for the connection. By default, the agents
* own id is used.
* @return {Connection | Connection[]} Returns a connection or, in case of
* multiple transports, returns an
* array with connections. The connections
* have a promise .ready which resolves
* as soon as the connection is ready for
* use.
*/
Agent.prototype.connect = function(transport, id) {
if (Array.isArray(transport)) {
var me = this;
return transport.map(function (_transport) {
return me._connect(_transport, id);
});
}
else if (typeof transport === 'string') {
// get transport by id
return this._connect(Agent.getTransportById(transport), id);
}
else {
// a transport instance
return this._connect(transport, id);
}
};
/**
* Connect to a transport
* @param {Transport} transport A Transport instance
* @param {string} [id] An optional alternative id to be used
* for the connection. By default, the agents
* own id is used.
* @return {Connection} Returns a connection.
* @private
*/
Agent.prototype._connect = function (transport, id) {
// create a receive function which is bound to the _receive function.
// the _receive function can be replaced in by modules in a cascaded way,
// and in the end calls this.receive of the agent.
// note: we don't do receive = this._receive.bind(this) as the _receive
// function can be overloaded after a connection is made.
var me = this;
var receive = function (from, message) {
return me._receive(from, message);
};
var connection = transport.connect(id || this.id, receive);
this.connections.push(connection);
// set or replace the defaultConnection
if (!this.defaultConnection) {
this.defaultConnection = connection;
}
else if (transport['default']) {
if (this.defaultConnection['default']) {
throw new Error('Cannot connect to a second default transport');
}
this.defaultConnection = connection;
}
this._updateReady();
return connection;
};
/**
* Disconnect from one or multiple transports
* @param {string | Transport | string[] | Transport[]} [transport]
* A transport or an array with transports.
* parameter transport can be an instance of a Transport, or the
* id of a transport.
* When transport is undefined, the agent will be disconnected
* from all connected transports.
*/
Agent.prototype.disconnect = function(transport) {
var i, connection;
if (!transport) {
// disconnect all transports
while (connection = this.connections[0]) {
this._disconnect(connection);
}
}
else if (Array.isArray(transport)) {
// an array with transports
i = 0;
while (i < this.connections.length) {
connection = this.connections[i];
if (transport.indexOf(connection.transport) !== -1) {
this._disconnect(connection);
}
else {
i++;
}
}
}
else if (typeof transport === 'string') {
// transport by id
this.disconnect(Agent.getTransportById(transport));
}
else {
// a single transport
for (i = 0; i < this.connections.length; i++) {
connection = this.connections[i];
if (connection.transport === transport) {
this._disconnect(connection);
break;
}
}
}
};
/**
* Close a connection
* @param {Connection} connection
* @private
*/
Agent.prototype._disconnect = function (connection) {
// find the connection
var index = this.connections.indexOf(connection);
if (index !== -1) {
// close the connection
connection.close();
// remove from the list with connections
this.connections.splice(index, 1);
// replace the defaultConnection if needed
if (this.defaultConnection === connection) {
this.defaultConnection = this.connections[this.connections.length - 1] || null;
}
}
this._updateReady();
};
/**
* Update the ready state of the agent
* @private
*/
Agent.prototype._updateReady = function () {
// FIXME: we should not replace with a new Promise,
// we have a problem when this.ready is requested before ready,
// and another connection is opened before ready
this.ready = Promise.all(this.connections.map(function (connection) {
return connection.ready;
}));
};
module.exports = Agent;
/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var seed = __webpack_require__(25);
var hypertimer = __webpack_require__(24);
var TransportManager = __webpack_require__(3);
// map with known configuration properties
var KNOWN_PROPERTIES = {
transports: true,
timer: true,
random: true
};
function ServiceManager(config) {
this.transports = new TransportManager();
this.timer = hypertimer();
this.random = Math.random;
this.init(config);
}
/**
* Initialize the service manager with services loaded from a configuration
* object. All current services are unloaded and removed.
* @param {Object} config
*/
ServiceManager.prototype.init = function (config) {
this.transports.clear();
if (config) {
if (config.transports) {
this.transports.load(config.transports);
}
if (config.timer) {
this.timer.config(config.timer);
}
if (config.random) {
if (config.random.deterministic) {
var key = config.random.seed || 'random seed';
this.random = seed(key, config.random);
}
else {
this.random = Math.random;
}
}
for (var prop in config) {
if (config.hasOwnProperty(prop) && !KNOWN_PROPERTIES[prop]) {
// TODO: should log this warning via a configured logger
console.log('WARNING: Unknown configuration option "' + prop + '"')
}
}
}
};
/**
* Clear all configured services
*/
ServiceManager.prototype.clear = function () {
this.transports.clear();
};
module.exports = ServiceManager;
/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
/**
* A manager for loading and finding transports.
* @param {Array} [config] Optional array containing configuration objects
* for transports.
* @constructor
*/
function TransportManager(config) {
this.transports = [];
if (config) {
this.load(config);
}
}
// map with all registered types of transports
// each transport must register itself at the TransportManager using registerType.
TransportManager.types = {};
/**
* Register a new type of transport. This transport can then be loaded via
* configuration.
* @param {Transport.prototype} constructor A transport constructor
*/
TransportManager.registerType = function (constructor) {
var type = constructor.prototype.type;
if (typeof constructor !== 'function') {
throw new Error('Constructor function expected');
}
if (!type) {
throw new Error('Field "prototype.type" missing in transport constructor');
}
if (type in TransportManager.types) {
if (TransportManager.types[type] !== constructor) {
throw new Error('Transport type "' + type + '" already exists');
}
}
TransportManager.types[type] = constructor;
};
/**
* Add a loaded transport to the manager
* @param {Transport} transport
* @return {Transport} returns the transport itself
*/
TransportManager.prototype.add = function (transport) {
this.transports.push(transport);
return transport;
};
/**
* Load one or multiple transports based on JSON configuration.
* New transports will be appended to current transports.
* @param {Object | Array} config
* @return {Transport | Transport[]} Returns the loaded transport(s)
*/
TransportManager.prototype.load = function (config) {
if (Array.isArray(config)) {
return config.map(this.load.bind(this));
}
var type = config.type;
if (!type) {
throw new Error('Property "type" missing');
}
var constructor = TransportManager.types[type];
if (!constructor) {
throw new Error('Unknown type of transport "' + type + '". ' +
'Choose from: ' + Object.keys(TransportManager.types).join(','))
}
var transport = new constructor(config);
this.transports.push(transport);
return transport;
};
/**
* Unload a transport.
* @param {Transport | Transport[] | string | string[]} transport
* A Transport instance or the id of a transport, or an Array
* with transports or transport ids.
*/
TransportManager.prototype.unload = function (transport) {
var _transport;
if (typeof transport === 'string') {
_transport = this.get(transport);
}
else if (Array.isArray(transport)) {
for (var i = 0; i < transport.length; i++) {
this.unload(transport[i]);
}
}
else {
_transport = transport;
}
if (_transport) {
_transport.close();
var index = this.transports.indexOf(_transport);
if (index !== -1) {
this.transports.splice(index, 1);
}
}
};
/**
* Get a transport by its id. The transport must have been created with an id
* @param {string} [id] The id of a transport
* @return {Transport} Returns the transport when found. Throws an error
* when not found.
*/
TransportManager.prototype.get = function (id) {
for (var i = 0; i < this.transports.length; i++) {
var transport = this.transports[i];
if (transport.id === id) {
return transport;
}
}
throw new Error('Transport with id "' + id + '" not found');
};
/**
* Get all transports.
* @return {Transport[]} Returns an array with all loaded transports.
*/
TransportManager.prototype.getAll = function () {
return this.transports.concat([]);
};
/**
* Find transports by type.
* @param {string} [type] Type of the transport. Choose from 'amqp',
* 'distribus', 'local', 'pubnub'.
* @return {Transport[]} When type is defined, the all transports of this
* type are returned. When undefined, all transports
* are returned.
*/
TransportManager.prototype.getByType = function (type) {
if (type) {
if (!(type in TransportManager.types)) {
throw new Error('Unknown type of transport "' + type + '". ' +
'Choose from: ' + Object.keys(TransportManager.types).join(','))
}
return this.transports.filter(function (transport) {
return transport.type === type;
});
}
else {
return [].concat(this.transports);
}
};
/**
* Close all configured transports and remove them from the manager.
*/
TransportManager.prototype.clear = function () {
this.transports.forEach(function (transport) {
transport.close();
});
this.transports = [];
};
module.exports = TransportManager;
/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
/**
* Test whether the provided value is a Promise.
* A value is marked as a Promise when it is an object containing functions
* `then` and `catch`.
* @param {*} value
* @return {boolean} Returns true when `value` is a Promise
*/
exports.isPromise = function (value) {
return value &&
typeof value['then'] === 'function' &&
typeof value['catch'] === 'function'
};
/**
* Splits an url like "protocol://domain/path"
* @param {string} url
* @return {{protocol: string, domain: string, path: string} | null}
* Returns an object with properties protocol, domain, and path
* when there is a match. Returns null if no valid url.
*
*/
exports.parseUrl = function (url) {
// match an url like "protocol://domain/path"
var match = /^([A-z]+):\/\/([^\/]+)(\/(.*)$|$)/.exec(url);
if (match) {
return {
protocol: match[1],
domain: match[2],
path: match[4]
}
}
return null;
};
/**
* Normalize a url. Removes trailing slash
* @param {string} url
* @return {string} Returns the normalized url
*/
exports.normalizeURL = function (url) {
if (url[url.length - 1] == '/') {
return url.substring(0, url.length - 1);
}
else {
return url;
}
};
/***/ },
/* 5 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var babble = __webpack_require__(26);
/**
* Create a Babble module for an agent.
* The agents _receive function is wrapped into a new handler.
* Creates a Babble instance with function `ask`, `tell`, `listen`, `listenOnce`
* @param {Agent} agent
* @param {Object} [options] Optional parameters. Not applicable for BabbleModule
* @constructor
*/
function BabbleModule(agent, options) {
// create a new babbler
var babbler = babble.babbler(agent.id);
babbler.connect({
connect: function (params) {},
disconnect: function(token) {},
send: function (to, message) {
agent.send(to, message);
}
});
this.babbler = babbler;
// create a receive function for the agent
var receiveOriginal = agent._receive;
this._receive = function (from, message) {
babbler._receive(message);
// TODO: only propagate to receiveOriginal if the message is not handled by the babbler
return receiveOriginal.call(agent, from, message);
};
}
BabbleModule.prototype.type = 'babble';
/**
* Get a map with mixin functions
* @return {{_receive: function, ask: function, tell: function, listen: function, listenOnce: function}}
* Returns mixin function, which can be used to extend the agent.
*/
BabbleModule.prototype.mixin = function () {
var babbler = this.babbler;
return {
_receive: this._receive,
ask: babbler.ask.bind(babbler),
tell: babbler.tell.bind(babbler),
listen: babbler.listen.bind(babbler),
listenOnce: babbler.listenOnce.bind(babbler)
}
};
module.exports = BabbleModule;
/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
/**
* Create a pattern listener onto an Agent.
* A new handler is added to the agents _receiver function.
* Creates a Pattern instance with functions `listen` and `unlisten`.
* @param {Agent} agent
* @param {Object} [options] Optional parameters. Can contain properties:
* - stopPropagation: boolean
* When false (default), a message
* will be delivered at all
* matching pattern listeners.
* When true, a message will be
* be delivered at the first
* matching pattern listener only.
*/
function PatternModule(agent, options) {
this.agent = agent;
this.stopPropagation = options && options.stopPropagation || false;
this.receiveOriginal = agent._receive;
this.listeners = [];
}
PatternModule.prototype.type = 'pattern';
/**
* Receive a message.
* All pattern listeners will be checked against their patterns, and if there
* is a match, the pattern listeners callback function is invoked.
* @param {string} from Id of sender
* @param {*} message Received message, a JSON object (often a string)
*/
PatternModule.prototype.receive = function(from, message) {
var response;
var responses = [];
for (var i = 0, ii = this.listeners.length; i < ii; i++) {
var listener = this.listeners[i];
var pattern = listener.pattern;
var match = (pattern instanceof Function && pattern(message)) ||
(pattern instanceof RegExp && pattern.test(message)) ||
(pattern == message);
if (match) {
response = listener.callback.call(this.agent, from, message);
responses.push(response);
if (this.stopPropagation) {
return responses[0];
}
}
}
response = this.receiveOriginal.call(this.agent, from, message);
responses.push(response);
return responses[0];
};
/**
* Add a pattern listener for incoming messages
* @param {string | RegExp | Function} pattern Message pattern
* @param {Function} callback Callback function invoked when
* a message matching the pattern
* is received.
* Invoked as callback(from, message)
*/
PatternModule.prototype.listen = function(pattern, callback) {
this.listeners.push({
pattern: pattern,
callback: callback
});
};
/**
* Remove a pattern listener for incoming messages
* @param {string | RegExp | Function} pattern Message pattern
* @param {Function} callback
*/
PatternModule.prototype.unlisten = function(pattern, callback) {
for (var i = 0, ii = this.listeners.length; i < ii; i++) {
var listener = this.listeners[i];
if (listener.pattern === pattern && listener.callback === callback) {
this.listeners.splice(i, 1);
break;
}
}
};
/**
* Get a map with mixin functions
* @return {{_receive: function, listen: function, unlisten: function}}
* Returns mixin function, which can be used to extend the agent.
*/
PatternModule.prototype.mixin = function () {
return {
_receive: this.receive.bind(this),
listen: this.listen.bind(this),
unlisten: this.unlisten.bind(this)
}
};
module.exports = PatternModule;
/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var uuid = __webpack_require__(28);
var Promise = __webpack_require__(27);
var util = __webpack_require__(4);
var TIMEOUT = 60000; // ms
/**
* Create a Request module.
* The module attaches a handler to the agents _receive function.
* Creates a Request instance with function `request`.
* @param {Agent} agent
* @param {Object} [options] Optional parameters. Can contain properties:
* - timeout: number A timeout for responses in
* milliseconds. 60000 ms by
* default.
*/
function RequestModule(agent, options) {
this.agent = agent;
this.receiveOriginal = agent._receive;
this.timeout = options && options.timeout || TIMEOUT;
this.queue = [];
}
RequestModule.prototype.type = 'request';
/**
* Event handler, handles incoming messages
* @param {String} from Id of the sender
* @param {*} message
* @return {boolean} Returns true when a message is handled, else returns false
*/
RequestModule.prototype.receive = function (from, message) {
var agent = this.agent;
if (typeof message === 'object') {
var envelope = message;
// match the request from the id in the response
var request = this.queue[envelope.id];
if (request) {
// remove the request from the queue
clearTimeout(request.timeout);
delete this.queue[envelope.id];
// resolve the requests promise with the response message
if (envelope.error) {
// TODO: turn this into an Error instance again
request.reject(new Error(envelope.error));
}
else {
request.resolve(envelope.message);
}
return true;
}
else if (message.type == 'request') {
try {
var response = this.receiveOriginal.call(agent, from, message.message);
if (util.isPromise(response)) {
// wait until the promise resolves
response
.then(function (result) {
agent.send(from, {type: 'request', id: message.id, message: result});
})
.catch(function (err) {
agent.send(from, {type: 'request', id: message.id, error: err.message || err.toString()});
});
}
else {
// immediately send a result
agent.send(from, {type: 'request', id: message.id, message: response });
}
}
catch (err) {
agent.send(from, {type: 'request', id: message.id, error: err.message || err.toString()});
}
}
}
else {
if (this.receiveOriginal) {
this.receiveOriginal.call(agent, from, message);
}
}
};
/**
* Send a request
* @param {string} to Id of the recipient
* @param {*} message
* @returns {Promise.<*, Error>} Returns a promise resolving with the response message
*/
RequestModule.prototype.request = function (to, message) {
var me = this;
return new Promise(function (resolve, reject) {
// put the data in an envelope with id
var id = uuid();
var envelope = {
type: 'request',
id: id,
message: message
};
// add the request to the list with requests in progress
me.queue[id] = {
resolve: resolve,
reject: reject,
timeout: setTimeout(function () {
delete me.queue[id];
reject(new Error('Timeout'));
}, me.timeout)
};
me.agent.send(to, envelope)
.catch(function (err) {
reject(err);
});
});
};
/**
* Get a map with mixin functions
* @return {{_receive: function, request: function}}
* Returns mixin function, which can be used to extend the agent.
*/
RequestModule.prototype.mixin = function () {
return {
_receive: this.receive.bind(this),
request: this.request.bind(this)
}
};
module.exports = RequestModule;
/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var uuid = __webpack_require__(28);
var Promise = __webpack_require__(27);
var util = __webpack_require__(4);
/**
*
* @param {Agent} agent
* @param {Object} availableFunctions
* @constructor
*/
function RPCModule(agent, availableFunctions, options) {
this.agent = agent;
this.receiveOriginal = agent._receive;
this.queue = {};
this.promiseTimeout = options && options.timeout || 1500; // 1 second
// check the available functions
if (availableFunctions instanceof Array) {
this.functionsFromArray(availableFunctions);
}
else if (availableFunctions instanceof Object) {
this.availableFunctions = availableFunctions;
}
else {
console.log('cannot use RPC with the supplied functions', availableFunctions);
}
}
RPCModule.prototype.type = 'rpc';
/**
*
* @param availableFunctions
*/
RPCModule.prototype.functionsFromArray = function (availableFunctions) {
this.availableFunctions = {};
for (var i = 0; i < availableFunctions.length; i++) {
var fn = availableFunctions[i];
this.availableFunctions[fn] = this.agent[fn];
}
};
/**
*
* @param to
* @param message
* @returns {Promise}
*/
RPCModule.prototype.request = function (to, message) {
var me = this;
return new Promise(function (resolve, reject) {
// prepare the envelope
if (typeof message != 'object' ) {reject(new TypeError('Message must be an object'));}
if (message.jsonrpc !== '2.0' ) {message.jsonrpc = '2.0';}
if (message.id === undefined) {message.id = uuid();}
if (message.method === undefined) {reject(new Error('Property "method" expected'));}
if (message.params === undefined) {message.params = {};}
// add the request to the list with requests in progress
me.queue[message.id] = {
resolve: resolve,
reject: reject,
timeout: setTimeout(function () {
delete me.queue[message.id];
reject(new Error('RPC Promise Timeout surpassed. Timeout: ' + me.promiseTimeout / 1000 + 's'));
}, me.promiseTimeout)
};
var sendRequest = me.agent.send(to, message);
if (util.isPromise(sendRequest) == true) {
sendRequest.catch(function (err) {reject(err);});
}
});
};
/**
*
* @param from
* @param message
* @returns {*}
*/
RPCModule.prototype.receive = function (from, message) {
if (typeof message == 'object') {
if (message.jsonrpc == '2.0') {
this._receive(from, message);
}
else {
this.receiveOriginal.call(this.agent, from, message);
}
}
else {
this.receiveOriginal.call(this.agent, from, message);
}
};
/**
*
* @param from
* @param message
* @returns {*}
* @private
*/
RPCModule.prototype._receive = function (from, message) {
// define structure of return message
var returnMessage = {jsonrpc:'2.0', id:message.id};
// check if this is a request
if (message.method !== undefined) {
// check is method is available for this agent
var method = this.availableFunctions[message.method];
if (method !== undefined) {
var response = method.call(this.agent, message.params, from) || null;
// check if response is a promise
if (util.isPromise(response)) {
var me = this;
response
.then(function (result) {
returnMessage.result = result;
me.agent.send(from, returnMessage)
})
.catch(function (error) {
returnMessage.error = error.message || error.toString();
me.agent.send(from, returnMessage);
})
}
else {
returnMessage.result = response;
this.agent.send(from, returnMessage);
}
}
else {
var error = new Error('Cannot find function: ' + message.method);
returnMessage.error = error.message || error.toString();
this.agent.send(from, returnMessage);
}
}
// check if this is a response
else if (message.result !== undefined || message.error !== undefined) {
var request = this.queue[message.id];
if (request !== undefined) {
// if an error is defined, reject promise
if (message.error != undefined) { // null or undefined
if (typeof message == 'object') {
request.reject(message.error);
}
else {
request.reject(new Error(message.error));
}
}
else {
request.resolve(message.result);
}
}
}
else {
// send error back to sender.
var error = new Error('No method or result defined. Message:' + JSON.stringify(message));
returnMessage.error = error.message || error.toString();
// FIXME: returned error should be an object {code: number, message: string}
this.agent.send(from, returnMessage);
}
};
/**
* Get a map with mixin functions
* @return {{_receive: function, request: function}}
* Returns mixin function, which can be used to extend the agent.
*/
RPCModule.prototype.mixin = function () {
return {
_receive: this.receive.bind(this),
request: this.request.bind(this)
}
};
module.exports = RPCModule;
/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
/**
* Abstract prototype of a transport
* @param {Object} [config]
* @constructor
*/
function Transport(config) {
this.id = config && config.id || null;
this['default'] = config && config['default'] || false;
}
Transport.prototype.type = null;
/**
* Connect an agent
* @param {String} id
* @param {Function} receive Invoked as receive(from, message)
* @return {Connection} Returns a connection
*/
Transport.prototype.connect = function(id, receive) {
throw new Error('Cannot invoke abstract function "connect"');
};
/**
* Close the transport
*/
Transport.prototype.close = function() {
throw new Error('Cannot invoke abstract function "close"');
};
module.exports = Transport;
/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(27);
/**
* An abstract Transport connection
* @param {Transport} transport
* @param {string} id
* @param {function} receive
* @constructor
* @abstract
*/
function Connection (transport, id, receive) {
throw new Error('Cannot create an abstract Connection');
}
Connection.prototype.ready = Promise.reject(new Error('Cannot get abstract property ready'));
/**
* Send a message to an agent.
* @param {string} to
* @param {*} message
* @return {Promise} returns a promise which resolves when the message has been sent
*/
Connection.prototype.send = function (to, message) {
throw new Error('Cannot call abstract function send');
};
/**
* Close the connection, disconnect from the transport.
*/
Connection.prototype.close = function () {
throw new Error('Cannot call abstract function "close"');
};
module.exports = Connection;
/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(27);
var Transport = __webpack_require__(9);
var AMQPConnection = __webpack_require__(12);
/**
* Use AMQP as transport
* @param {Object} config Config can contain the following properties:
* - `id: string`
* - `url: string`
* - `host: string`
* The config must contain either `url` or `host`.
* For example: {url: 'amqp://localhost'} or
* {host: 'dev.rabbitmq.com'}
* @constructor
*/
function AMQPTransport(config) {
this.id = config.id || null;
this.networkId = config.url || config.host || null;
this['default'] = config['default'] || false;
this.config = config;
this.connection = null;
this.exchange = null;
this.subscriptions = [];
}
AMQPTransport.prototype = new Transport();
AMQPTransport.prototype.type = 'amqp';
/**
* Connect an agent
* @param {String} id
* @param {Function} receive Invoked as receive(from, message)
* @return {AMQPConnection} Returns a connection.
*/
AMQPTransport.prototype.connect = function(id, receive) {
return new AMQPConnection(this, id, receive);
};
/**
* Get an AMQP connection. If there is not yet a connection, a connection will
* be made.
* @param {Function} callback Invoked as callback(connection)
* @private
*/
AMQPTransport.prototype._getConnection = function(callback) {
var me = this;
if (this.connection) {
// connection is available
callback(this.connection);
}
else {
if (this._onConnected) {
// connection is being opened but not yet ready
this._onConnected.push(callback);
}
else {
// no connection, create one
this._onConnected = [callback];
var amqp = __webpack_require__(23); // lazy load the amqp library
var connection = amqp.createConnection(this.config);
connection.on('ready', function () {
var exchange = connection.exchange('', {confirm: true}, function () {
var _onConnected = me._onConnected;
delete me._onConnected;
me.connection = connection;
me.exchange = exchange;
_onConnected.forEach(function (callback) {
callback(me.connection);
});
});
});
}
}
};
/**
* Open a connection
* @param {string} id
* @param {Function} receive Invoked as receive(from, message)
*/
AMQPTransport.prototype._connect = function(id, receive) {
var me = this;
return new Promise(function (resolve, reject) {
function subscribe(connection) {
var queue = connection.queue(id, {}, function() {
queue
.subscribe(function(message) {
var body = message.body;
receive(body.from, body.message);
})
.addCallback(function (ok) {
// register this subscription
me.subscriptions.push({
id: id,
consumerTag: ok.consumerTag
});
resolve(me);
});
});
}
me._getConnection(subscribe);
});
};
/**
* Close a connection an agent by its id
* @param {String} id
*/
AMQPTransport.prototype._close = function(id) {
var i = 0;
while (i < this.subscriptions.length) {
var subscription = this.subscriptions[i];
if (subscription.id == id) {
// remove this entry
this.subscriptions.splice(i, 1);
}
else {
i++;
}
}
if (this.subscriptions.length == 0) {
// fully disconnect if there are no subscribers left
this.exchange.destroy();
this.connection.disconnect();
this.connection = null;
this.exchange = null;
}
};
/**
* Close the transport.
*/
AMQPTransport.prototype.close = function() {
this.connection.destroy();
this.connection = null;
};
module.exports = AMQPTransport;
/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(27);
var Connection = __webpack_require__(10);
/**
* A local connection.
* @param {AMQPTransport} transport
* @param {string | number} id
* @param {function} receive
* @constructor
*/
function AMQPConnection(transport, id, receive) {
this.transport = transport;
this.id = id;
// ready state
this.ready = this.transport._connect(id, receive);
}
/**
* Send a message to an agent.
* @param {string} to
* @param {*} message
* @return {Promise} returns a promise which resolves when the message has been sent
*/
AMQPConnection.prototype.send = function (to, message) {
var me = this;
return new Promise(function (resolve, reject) {
var msg = {
body: {
from: me.id,
to: to,
message: message
}
};
var options = {
//immediate: true
};
me.transport.exchange.publish(to, msg, options, function () {
// FIXME: callback is not called. See https://github.com/postwait/node-amqp#exchangepublishroutingkey-message-options-callback
//console.log('sent', arguments)
});
resolve();
});
};
/**
* Close the connection
*/
AMQPConnection.prototype.close = function () {
this.transport._close(this.id);
};
module.exports = AMQPConnection;
/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var distribus = __webpack_require__(29);
var Transport = __webpack_require__(9);
var DistribusConnection = __webpack_require__(14);
/**
* Use distribus as transport
* @param {Object} config Config can contain the following properties:
* - `id: string`. Optional
* - `host: distribus.Host`. Optional
* If `host` is not provided,
* a new local distribus Host is created.
* @constructor
*/
function DistribusTransport(config) {
this.id = config && config.id || null;
this['default'] = config && config['default'] || false;
this.host = config && config.host || new distribus.Host(config);
this.networkId = this.host.networkId; // FIXME: networkId can change when host connects to another host.
}
DistribusTransport.prototype = new Transport();
DistribusTransport.prototype.type = 'distribus';
/**
* Connect an agent
* @param {String} id
* @param {Function} receive Invoked as receive(from, message)
* @return {DistribusConnection} Returns a connection.
*/
DistribusTransport.prototype.connect = function(id, receive) {
return new DistribusConnection(this, id, receive);
};
/**
* Close the transport.
*/
DistribusTransport.prototype.close = function() {
this.host.close();
this.host = null;
};
module.exports = DistribusTransport;
/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(27);
var Connection = __webpack_require__(10);
/**
* A local connection.
* @param {DistribusTransport} transport
* @param {string | number} id
* @param {function} receive
* @constructor
*/
function DistribusConnection(transport, id, receive) {
this.transport = transport;
this.id = id;
// create a peer
var peer = this.transport.host.create(id);
peer.on('message', receive);
// ready state
this.ready = Promise.resolve(this);
}
/**
* Send a message to an agent.
* @param {string} to
* @param {*} message
* @return {Promise} returns a promise which resolves when the message has been sent
*/
DistribusConnection.prototype.send = function (to, message) {
return this.transport.host.send(this.id, to, message);
};
/**
* Close the connection
*/
DistribusConnection.prototype.close = function () {
this.transport.host.remove(this.id);
};
module.exports = DistribusConnection;
/***/ },
/* 15 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var http = __webpack_require__(30);
var Promise = __webpack_require__(27);
var Transport = __webpack_require__(9);
var HTTPConnection = __webpack_require__(16);
var uuid = __webpack_require__(28);
/**
* HTTP Transport layer:
*
* Supported Options:
*
* {Number} config.port Port to listen on.
* {String} config.path Path, with or without leading and trailing slash (/)
* {Boolean} config.localShortcut If the agentId exists locally, use local transport. (local)
*
* Address: http://127.0.0.1:PORTNUMBER/PATH
*/
function HTTPTransport(config) {
this.id = config && config.id || null;
this.networkId = null;
this.agents = {};
this.outstandingRequests = {}; // these are received messages that are expecting a response
this.outstandingMessages = {};
this.url = config && config.url || "http://127.0.0.1:3000/agents/:id";
this.remoteUrl = config && config.remoteUrl;
this.localShortcut = (config && config.localShortcut === false) ? false : true;
this.httpTimeout = config && config.httpTimeout || 2000; // 1 second - timeout to send message
this.httpResponseTimeout = config && config.httpResponseTimeout || 200; // 0.5 second - timeout to expect reply after delivering request
this.regexHosts = /[http]{4}s?:\/\/([a-z\-\.A-Z0-9]*):?([0-9]*)(\/[a-z\/:A-Z0-9._\-% \\\(\)\*\+\.\^\$]*)/;
this.urlHostData = this.regexHosts.exec(this.url);
this.regexPath = this.getRegEx(this.urlHostData[3]);
this.port = config && config.port || this.urlHostData[2] || 3000;
this.path = this.urlHostData[3].replace(':id', '');
if (typeof window !== 'undefined') {
this.send = this.webSend;
}
}
HTTPTransport.prototype = new Transport();
HTTPTransport.prototype.type = 'http';
HTTPTransport.prototype.getRegEx = function(url) {
return new RegExp(url.replace(/[\\\(\)\*\+\.\^\$]/g,function(match) {return '\\' + match;}).replace(':id','([:a-zA-Z_0-9\-]*)'));
};
/**
* Connect an agent
* @param {String} id
* @param {Function} receive Invoked as receive(from, message)
* @return {HTTPConnection} Returns a connection.
*/
HTTPTransport.prototype.connect = function(id, receive) {
if (this.server === undefined && typeof window === 'undefined') {
this.initiateServer();
}
this.outstandingRequests[id] = {};
this.outstandingMessages[id] = {};
return new HTTPConnection(this, id, receive);
};
/**
* Send a message to an agent
* @param {String} from Id of sender
* @param {String} to Id of addressed peer
* @param {String} message
*/
HTTPTransport.prototype.send = function(from, to, message) {
var me = this;
return new Promise(function (resolve,reject) {
var hostData = me.regexHosts.exec(to);
var fromRegexpCheck = me.regexPath.exec(from);
var fromAgentId = fromRegexpCheck[1];
var outstandingMessageID = uuid();
// check for local shortcut possibility
if (me.localShortcut == true) {
var toRegexpCheck = me.regexPath.exec(to);
var toAgentId = toRegexpCheck[1];
var toPath = hostData[3].replace(toAgentId,"");
// check if the "to" address is on the same URL, port and path as the "from"
if ((hostData[1] == '127.0.0.1' && hostData[2] == me.urlHostData[2] && toPath == me.path) ||
(me.urlHostData[1] == hostData[1] && hostData[2] == me.urlHostData[2] && toPath == me.path)) {
// by definition true but check anyway
if (me.agents[toAgentId] !== undefined) {
me.agents[toAgentId](fromAgentId, message);
resolve();
return;
}
}
}
// stringify the message. If the message is an object, it can have an ID so it may be part of a req/rep.
if (typeof message == 'object') {
// check if the send is a reply to an outstanding request and if so, deliver
var outstanding = me.outstandingRequests[fromAgentId];
if (outstanding[message.id] !== undefined) {
var callback = outstanding[message.id];
callback.response.end(JSON.stringify(message));
clearTimeout(callback.timeout);
delete outstanding[message.id];
resolve();
return;
}
// stringify the message.
message = JSON.stringify(message)
}
// all post options
var options = {
host: hostData[1],
port: hostData[2],
path: hostData[3],
method: 'POST',
headers: {
'x-eve-senderurl' : from, // used to get senderID
'Content-type' : 'text/plain'
}
};
var request = http.request(options, function(res) {
res.setEncoding('utf8');
// message was delivered, clear the cannot deliver timeout.
clearTimeout(me.outstandingMessages[fromAgentId][outstandingMessageID].timeout);
// listen to incoming data
res.on('data', function (response) {
var parsedResponse;
try {parsedResponse = JSON.parse(response);} catch (err) {parsedResponse = response;}
if (typeof parsedResponse == 'object') {
if (parsedResponse.__httpError__ !== undefined) {
reject(new Error(parsedResponse.__httpError__));
return;
}
}
me.agents[fromAgentId](to, parsedResponse);
resolve();
});
});
me.outstandingMessages[fromAgentId][outstandingMessageID] = {
timeout: setTimeout(function () {
request.abort();
reject(new Error("Cannot connect to " + to))
}, me.httpTimeout),
reject: reject
};
request.on('error', function(e) {
reject(e);
});
// write data to request body
request.write(message);
request.end();
});
};
/**
* Send a request to an url. Only for web.
* @param {String} from Id of sender
* @param {String} to Id of addressed peer
* @param {String} message
*/
HTTPTransport.prototype.webSend = function(from, to, message) {
var me = this;
return new Promise(function (resolve, reject) {
if (typeof message == 'object') {
message = JSON.stringify(message);
}
var fromRegexpCheck = me.regexPath.exec(from);
var fromAgentId = fromRegexpCheck[1];
// create XMLHttpRequest object to send the POST request
var http = new XMLHttpRequest();
// insert the callback function. This is called when the message has been delivered and a response has been received
http.onreadystatechange = function () {
if (http.readyState == 4 && http.status == 200) {
var response = "";
if (http.responseText.length > 0) {
response = JSON.parse(http.responseText);
}
me.agents[fromAgentId](to, response);
// launch callback function
resolve();
}
else if (http.readyState == 4) {
reject(new Error("http.status:" + http.status));
}
};
// open an asynchronous POST connection
http.open("POST", to, true);
// include header so the receiving code knows its a JSON object
http.setRequestHeader("Content-Type", "text/plain");
// send
http.send(message);
});
};
/**
* This is the HTTP equivalent of receiveMessage.
*
* @param request
* @param response
*/
HTTPTransport.prototype.processRequest = function(request, response) {
var url = request.url;
// define headers
var headers = {};
headers['Access-Control-Allow-Origin'] = '*';
headers['Access-Control-Allow-Credentials'] = true;
headers['Content-Type'] = 'text/plain';
var regexpCheck = this.regexPath.exec(url);
if (regexpCheck !== null) {
var agentId = regexpCheck[1];
var senderId = 'unknown';
if (request.headers['x-eve-senderurl'] !== undefined) {
senderId = request.headers['x-eve-senderurl'];
}
var body = '';
request.on('data', function (data) {
body += data;
if (body.length > 30e6) { // 30e6 == 30MB
request.connection.destroy(); // FLOOD ATTACK OR FAULTY CLIENT, NUKE REQUEST
}
});
var me = this;
request.on('end', function () {
var expectReply = false;
var message;
try {message = JSON.parse(body);} catch (err) {message = body;}
// check if JSON RPC
expectReply = message.jsonrpc && message.jsonrpc == '2.0' || expectReply;
// check if type == 'request'
expectReply = message.type && message.type == 'request' || expectReply;
response.writeHead(200, headers);
// construct callback
var callback = me.agents[agentId];
if (callback === undefined) {
var error = new Error('Agent: "' + agentId + '" does not exist.');
response.end(JSON.stringify({__httpError__:error.message || error.toString()}));
}
else {
if (expectReply == true) {
me.outstandingRequests[agentId][message.id] = {
response: response,
timeout: setTimeout(function () {
response.end("timeout");
delete me.outstandingRequests[agentId][message.id];
}, me.httpResponseTimeout)
};
callback(senderId, message);
}
else {
// if we're not expecting a response, we first close the connection, then receive the message
response.end('');
if (callback !== undefined) {
callback(senderId, message);
}
}
}
});
}
};
/**
* Configure a HTTP server listener
*/
HTTPTransport.prototype.initiateServer = function() {
if (this.server === undefined) {
var me = this;
this.server = http.createServer(function (request, response) {
if (request.method == 'OPTIONS') {
var headers = {};
headers['Access-Control-Allow-Origin'] = '*';
headers['Access-Control-Allow-Methods'] = 'POST, OPTIONS';
headers['Access-Control-Allow-Credentials'] = true;
headers['Access-Control-Max-Age'] = '86400'; // 24 hours
headers['Access-Control-Allow-Headers'] = 'X-Requested-With, Access-Control-Allow-Origin, X-HTTP-Method-Override, Content-Type, Authorization, Accept';
// respond to the request
response.writeHead(200, headers);
response.end();
}
else if (request.method == 'POST') {
me.processRequest(request, response);
}
});
this.server.on('error', function(err) {
if (err.code == 'EADDRINUSE') {
throw new Error('ERROR: Could not start HTTP server. Port ' + me.port + ' is occupied.');
}
else {
throw new Error(err);
}
});
// Listen on port (default: 3000), IP defaults to 127.0.0.1
this.server.listen(this.port, function() {
// Put a friendly message on the terminal
console.log('Server listening at ', me.url);
});
}
else {
this.server.close();
this.server = undefined;
this.initiateServer();
}
};
/**
* Close the HTTP server
*/
HTTPTransport.prototype.close = function() {
// close all open connections
for (var agentId in this.outstandingRequests) {
if (this.outstandingRequests.hasOwnProperty(agentId)) {
var agentRequests = this.outstandingRequests[agentId];
for (var messageId in agentRequests) {
if (agentRequests.hasOwnProperty(messageId)) {
var openMessage = agentRequests[messageId];
var error = new Error('Server shutting down.');
openMessage.response.end(JSON.stringify({__httpError__:error.message || error.toString()}));
}
}
}
}
// close server
if (this.server) {
this.server.close();
}
this.server = null;
};
module.exports = HTTPTransport;
/***/ },
/* 16 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(27);
var Connection = __webpack_require__(10);
/**
* A HTTP connection.
* @param {HTTPTransport} transport
* @param {string | number} id
* @param {function} receive
* @constructor
*/
function HTTPConnection(transport, id, receive) {
this.transport = transport;
this.id = id;
// register the agents receive function
if (this.id in this.transport.agents) {
throw new Error('Agent with id ' + id + ' already exists');
}
this.transport.agents[this.id] = receive;
// ready state
this.ready = Promise.resolve(this);
}
/**
* Send a message to an agent.
* @param {string} to
* @param {*} message
*/
HTTPConnection.prototype.send = function (to, message) {
var fromURL = this.transport.url.replace(':id', this.id);
var isURL = to.indexOf('://') !== -1;
var toURL;
if (isURL) {
toURL = to;
}
else {
if (this.transport.remoteUrl !== undefined) {
toURL = this.transport.remoteUrl.replace(':id', to);
}
else {
console.log('ERROR: no remote URL specified. Cannot send over HTTP.', to);
}
}
return this.transport.send(fromURL, toURL, message);
};
/**
* Close the connection
*/
HTTPConnection.prototype.close = function () {
delete this.transport.agents[this.id];
};
module.exports = HTTPConnection;
/***/ },
/* 17 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Transport = __webpack_require__(9);
var LocalConnection = __webpack_require__(18);
/**
* Create a local transport.
* @param {Object} config Config can contain the following properties:
* - `id: string`. Optional
* @constructor
*/
function LocalTransport(config) {
this.id = config && config.id || null;
this.networkId = this.id || null;
this['default'] = config && config['default'] || false;
this.agents = {};
}
LocalTransport.prototype = new Transport();
LocalTransport.prototype.type = 'local';
/**
* Connect an agent
* @param {String} id
* @param {Function} receive Invoked as receive(from, message)
* @return {LocalConnection} Returns a promise which resolves when
* connected.
*/
LocalTransport.prototype.connect = function(id, receive) {
return new LocalConnection(this, id, receive);
};
/**
* Close the transport. Removes all agent connections.
*/
LocalTransport.prototype.close = function() {
this.agents = {};
};
module.exports = LocalTransport;
/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(27);
var Connection = __webpack_require__(10);
/**
* A local connection.
* @param {LocalTransport} transport
* @param {string | number} id
* @param {function} receive
* @constructor
*/
function LocalConnection(transport, id, receive) {
this.transport = transport;
this.id = id;
// register the agents receive function
if (this.id in this.transport.agents) {
throw new Error('Agent with id ' + id + ' already exists');
}
this.transport.agents[this.id] = receive;
// ready state
this.ready = Promise.resolve(this);
}
/**
* Send a message to an agent.
* @param {string} to
* @param {*} message
* @return {Promise} returns a promise which resolves when the message has been sent
*/
LocalConnection.prototype.send = function (to, message) {
var callback = this.transport.agents[to];
if (!callback) {
return Promise.reject(new Error('Agent with id ' + to + ' not found'));
}
// invoke the agents receiver as callback(from, message)
callback(this.id, message);
return Promise.resolve();
};
/**
* Close the connection
*/
LocalConnection.prototype.close = function () {
delete this.transport.agents[this.id];
};
module.exports = LocalConnection;
/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Transport = __webpack_require__(9);
var PubNubConnection = __webpack_require__(20);
/**
* Use pubnub as transport
* @param {Object} config Config can contain the following properties:
* - `id: string`. Optional
* - `publish_key: string`. Required
* - `subscribe_key: string`. Required
* @constructor
*/
function PubNubTransport(config) {
this.id = config.id || null;
this.networkId = config.publish_key || null;
this['default'] = config['default'] || false;
this.pubnub = PUBNUB().init(config);
}
PubNubTransport.prototype = new Transport();
PubNubTransport.prototype.type = 'pubnub';
/**
* Connect an agent
* @param {String} id
* @param {Function} receive Invoked as receive(from, message)
* @return {PubNubConnection} Returns a connection
*/
PubNubTransport.prototype.connect = function(id, receive) {
return new PubNubConnection(this, id, receive)
};
/**
* Close the transport.
*/
PubNubTransport.prototype.close = function() {
// FIXME: how to correctly close a pubnub connection?
this.pubnub = null;
};
/**
* Load the PubNub library
* @returns {Object} PUBNUB
*/
function PUBNUB() {
if (typeof window !== 'undefined') {
// browser
if (typeof window['PUBNUB'] === 'undefined') {
throw new Error('Please load pubnub first in the browser');
}
return window['PUBNUB'];
}
else {
// node.js
return __webpack_require__(32);
}
}
module.exports = PubNubTransport;
/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(27);
var Connection = __webpack_require__(10);
/**
* A connection. The connection is ready when the property .ready resolves.
* @param {PubNubTransport} transport
* @param {string | number} id
* @param {function} receive
* @constructor
*/
function PubNubConnection(transport, id, receive) {
this.id = id;
this.transport = transport;
// ready state
var me = this;
this.ready = new Promise(function (resolve, reject) {
transport.pubnub.subscribe({
channel: id,
message: function (message) {
receive(message.from, message.message);
},
connect: function () {
resolve(me);
}
});
});
}
/**
* Send a message to an agent.
* @param {string} to
* @param {*} message
* @return {Promise} returns a promise which resolves when the message has been sent
*/
PubNubConnection.prototype.send = function (to, message) {
var me = this;
return new Promise(function (resolve, reject) {
me.transport.pubnub.publish({
channel: to,
message: {
from: me.id,
to: to,
message: message
},
callback: resolve,
error: reject
});
});
};
/**
* Close the connection
*/
PubNubConnection.prototype.close = function () {
this.transport.pubnub.unsubscribe({
channel: this.id
});
};
module.exports = PubNubConnection;
/***/ },
/* 21 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var urlModule = __webpack_require__(31);
var uuid = __webpack_require__(28);
var Promise = __webpack_require__(27);
var WebSocketServer = __webpack_require__(34).Server;
var util = __webpack_require__(4);
var Transport = __webpack_require__(9);
var WebSocketConnection = __webpack_require__(22);
/**
* Create a web socket transport.
* @param {Object} config Config can contain the following properties:
* - `id: string`. Optional
* - `default: boolean`. Optional
* - `url: string`. Optional. If provided,
* A WebSocket server is started on given
* url.
* - `localShortcut: boolean`. Optional. If true
* (default), messages to local agents are not
* send via WebSocket but delivered immediately
* - `reconnectDelay: number` Optional. Delay in
* milliseconds for reconnecting a broken
* connection. 10000 ms by default. Connections
* are only automatically reconnected after
* there has been an established connection.
* @constructor
*/
function WebSocketTransport(config) {
this.id = config && config.id || null;
this.networkId = this.id || null;
this['default'] = config && config['default'] || false;
this.localShortcut = (config && config.localShortcut === false) ? false : true;
this.reconnectDelay = config && config.reconnectDelay || 10000;
this.httpTransport = config && config.httpTransport;
this.url = config && config.url || null;
this.server = null;
if (this.url != null) {
var urlParts = urlModule.parse(this.url);
if (urlParts.protocol != 'ws:') throw new Error('Invalid protocol, "ws:" expected');
if (this.url.indexOf(':id') == -1) throw new Error('":id" placeholder missing in url');
this.address = urlParts.protocol + '//' + urlParts.host; // the url without path, for example 'ws://localhost:3000'
this.ready = this._initServer(this.url);
}
else {
this.address = null;
this.ready = Promise.resolve(this);
}
this.agents = {}; // WebSocketConnections of all registered agents. The keys are the urls of the agents
}
WebSocketTransport.prototype = new Transport();
WebSocketTransport.prototype.type = 'ws';
/**
* Build an url for given id. Example:
* var url = getUrl('agent1'); // 'ws://localhost:3000/agents/agent1'
* @param {String} id
* @return {String} Returns the url, or returns null when no url placeholder
* is defined.
*/
WebSocketTransport.prototype.getUrl = function (id) {
return this.url ? this.url.replace(':id', id) : null;
};
/**
* Initialize a server on given url
* @param {String} url For example 'http://localhost:3000'
* @return {Promise} Returns a promise which resolves when the server is up
* and running
* @private
*/
WebSocketTransport.prototype._initServer = function (url) {
var urlParts = urlModule.parse(url);
var port = urlParts.port || 80;
var me = this;
return new Promise(function (resolve, reject) {
if (me.httpTransport !== undefined) {
console.log("WEBSOCKETS: using available server.");
me.server = new WebSocketServer({server: me.httpTransport.server}, function () {
resolve(me);
});
}
else {
me.server = new WebSocketServer({port: port}, function () {
resolve(me);
});
}
me.server.on('connection', me._onConnection.bind(me));
me.server.on('error', function (err) {
reject(err)
});
})
};
/**
* Handle a new connection. The connection is added to the addressed agent.
* @param {WebSocket} conn
* @private
*/
WebSocketTransport.prototype._onConnection = function (conn) {
var url = conn.upgradeReq.url;
var urlParts = urlModule.parse(url, true);
var toPath = urlParts.pathname;
var to = util.normalizeURL(this.address + toPath);
// read sender id from query parameters or generate a random uuid
var queryParams = urlParts.query;
var from = queryParams.id || uuid();
// TODO: make a config option to allow/disallow anonymous connections?
//console.log('onConnection, to=', to, ', from=', from, ', agents:', Object.keys(this.agents)); // TODO: cleanup
var agent = this.agents[to];
if (agent) {
agent._onConnection(from, conn);
}
else {
// reject the connection
// conn.send('Error: Agent with id "' + to + '" not found'); // TODO: can we send back a message before closing?
conn.close();
}
};
/**
* Connect an agent
* @param {string} id The id or url of the agent. In case of an
* url, this url should match the url of the
* WebSocket server.
* @param {Function} receive Invoked as receive(from, message)
* @return {WebSocketConnection} Returns a promise which resolves when
* connected.
*/
WebSocketTransport.prototype.connect = function(id, receive) {
var isURL = (id.indexOf('://') !== -1);
// FIXME: it's confusing right now what the final url will be based on the provided id...
var url = isURL ? id : (this.getUrl(id) || id);
if (url) url = util.normalizeURL(url);
// register the agents receive function
if (this.agents[url]) {
throw new Error('Agent with id ' + this.id + ' already exists');
}
var conn = new WebSocketConnection(this, url, receive);
this.agents[conn.url] = conn; // use conn.url, url can be changed when it was null
return conn;
};
/**
* Close the transport. Removes all agent connections.
*/
WebSocketTransport.prototype.close = function() {
// close all connections
for (var id in this.agents) {
if (this.agents.hasOwnProperty(id)) {
this.agents[id].close();
}
}
this.agents = {};
// close the server
if (this.server) {
this.server.close();
}
};
module.exports = WebSocketTransport;
/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var uuid = __webpack_require__(28);
var Promise = __webpack_require__(27);
var WebSocket = (typeof window !== 'undefined' && typeof window.WebSocket !== 'undefined') ?
window.WebSocket :
__webpack_require__(34);
var util = __webpack_require__(4);
var Connection = __webpack_require__(10);
/**
* A websocket connection.
* @param {WebSocketTransport} transport
* @param {string | number | null} url The url of the agent. The url must match
* the url of the WebSocket server.
* If url is null, a UUID id is generated as url.
* @param {function} receive
* @constructor
*/
function WebSocketConnection(transport, url, receive) {
this.transport = transport;
this.url = url ? util.normalizeURL(url) : uuid();
this.receive = receive;
this.sockets = {};
this.closed = false;
this.reconnectTimers = {};
// ready state
this.ready = Promise.resolve(this);
}
/**
* Send a message to an agent.
* @param {string} to The WebSocket url of the receiver
* @param {*} message
* @return {Promise} Returns a promise which resolves when the message is sent,
* and rejects when sending the message failed
*/
WebSocketConnection.prototype.send = function (to, message) {
//console.log('send', this.url, to, message); // TODO: cleanup
// deliver locally when possible
if (this.transport.localShortcut) {
var agent = this.transport.agents[to];
if (agent) {
try {
agent.receive(this.url, message);
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
}
// get or create a connection
var conn = this.sockets[to];
if (conn) {
try {
if (conn.readyState == conn.CONNECTING) {
// the connection is still opening
return new Promise(function (resolve, reject) {
//console.log(conn.onopen)//, conn.onopen.callback)
conn.onopen.callbacks.push(function () {
conn.send(JSON.stringify(message));
resolve();
})
});
}
else if (conn.readyState == conn.OPEN) {
conn.send(JSON.stringify(message));
return Promise.resolve();
}
else {
// remove the connection
conn = null;
}
}
catch (err) {
return Promise.reject(err);
}
}
if (!conn) {
// try to open a connection
var me = this;
return new Promise(function (resolve, reject) {
me._connect(to, function (conn) {
conn.send(JSON.stringify(message));
resolve();
}, function (err) {
reject(new Error('Failed to connect to agent "' + to + '"'));
});
})
}
};
/**
* Open a websocket connection to an other agent. No messages are sent.
* @param {string} to Url of the remote agent.
* @returns {Promise.<WebSocketConnection, Error>}
* Returns a promise which resolves when the connection is
* established and rejects in case of an error.
*/
WebSocketConnection.prototype.connect = function (to) {
var me = this;
return new Promise(function (resolve, reject) {
me._connect(to, function () {
resolve(me);
}, reject);
});
};
/**
* Open a websocket connection
* @param {String} to Url of the remote agent
* @param {function} [callback]
* @param {function} [errback]
* @param {boolean} [doReconnect=false]
* @returns {WebSocket}
* @private
*/
WebSocketConnection.prototype._connect = function (to, callback, errback, doReconnect) {
var me = this;
var conn = new WebSocket(to + '?id=' + this.url);
// register the new socket
me.sockets[to] = conn;
conn.onopen = function () {
// Change doReconnect to true as soon as we have had an open connection
doReconnect = true;
conn.onopen.callbacks.forEach(function (cb) {
cb(conn);
});
conn.onopen.callbacks = [];
};
conn.onopen.callbacks = callback ? [callback] : [];
conn.onmessage = function (event) {
me.receive(to, JSON.parse(event.data));
};
conn.onclose = function () {
delete me.sockets[to];
if (doReconnect) {
me._reconnect(to);
}
};
conn.onerror = function (err) {
delete me.sockets[to];
if (errback) {
errback(err);
}
};
return conn;
};
/**
* Auto reconnect a broken connection
* @param {String} to Url of the remote agent
* @private
*/
WebSocketConnection.prototype._reconnect = function (to) {
var me = this;
var doReconnect = true;
if (me.closed == false && me.reconnectTimers[to] == null) {
me.reconnectTimers[to] = setTimeout(function () {
delete me.reconnectTimers[to];
me._connect(to, null, null, doReconnect);
}, me.transport.reconnectDelay);
}
};
/**
* Register a websocket connection
* @param {String} from Url of the remote agent
* @param {WebSocket} conn WebSocket connection
* @returns {WebSocket} Returns the websocket itself
* @private
*/
WebSocketConnection.prototype._onConnection = function (from, conn) {
var me = this;
conn.onmessage = function (event) {
me.receive(from, JSON.parse(event.data));
};
conn.onclose = function () {
// remove this connection from the sockets list
delete me.sockets[from];
};
conn.onerror = function (err) {
// TODO: what to do with errors?
delete me.sockets[from];
};
if (this.sockets[from]) {
// there is already a connection open with remote agent
// TODO: what to do with overwriting existing sockets?
this.sockets[from].close();
}
// register new connection
this.sockets[from] = conn;
return conn;
};
/**
* Get a list with all open sockets
* @return {String[]} Returns all open sockets
*/
WebSocketConnection.prototype.list = function () {
return Object.keys(this.sockets);
};
/**
* Close the connection. All open sockets will be closed and the agent will
* be unregistered from the WebSocketTransport.
*/
WebSocketConnection.prototype.close = function () {
this.closed = true;
// close all connections
for (var id in this.sockets) {
if (this.sockets.hasOwnProperty(id)) {
this.sockets[id].close();
}
}
this.sockets = {};
delete this.transport.agents[this.url];
};
module.exports = WebSocketConnection;
/***/ },
/* 23 */
/***/ function(module, exports, __webpack_require__) {
module.exports = __WEBPACK_EXTERNAL_MODULE_23__;
/***/ },
/* 24 */
/***/ function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(33);
/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(global) {'use strict';
var width = 256;// each RC4 output is 0 <= x < 256
var chunks = 6;// at least six RC4 outputs for each double
var digits = 52;// there are 52 significant digits in a double
var pool = [];// pool: entropy pool starts empty
var GLOBAL = typeof global === 'undefined' ? window : global;
//
// The following constants are related to IEEE 754 limits.
//
var startdenom = Math.pow(width, chunks),
significance = Math.pow(2, digits),
overflow = significance * 2,
mask = width - 1;
var oldRandom = Math.random;
//
// seedrandom()
// This is the seedrandom function described above.
//
module.exports = function(seed, options) {
if (options && options.global === true) {
options.global = false;
Math.random = module.exports(seed, options);
options.global = true;
return Math.random;
}
var use_entropy = (options && options.entropy) || false;
var key = [];
// Flatten the seed string or build one from local entropy if needed.
var shortseed = mixkey(flatten(
use_entropy ? [seed, tostring(pool)] :
0 in arguments ? seed : autoseed(), 3), key);
// Use the seed to initialize an ARC4 generator.
var arc4 = new ARC4(key);
// Mix the randomness into accumulated entropy.
mixkey(tostring(arc4.S), pool);
// Override Math.random
// This function returns a random double in [0, 1) that contains
// randomness in every bit of the mantissa of the IEEE 754 value.
return function() { // Closure to return a random double:
var n = arc4.g(chunks), // Start with a numerator n < 2 ^ 48
d = startdenom, // and denominator d = 2 ^ 48.
x = 0; // and no 'extra last byte'.
while (n < significance) { // Fill up all significant digits by
n = (n + x) * width; // shifting numerator and
d *= width; // denominator and generating a
x = arc4.g(1); // new least-significant-byte.
}
while (n >= overflow) { // To avoid rounding up, before adding
n /= 2; // last byte, shift everything
d /= 2; // right using integer Math until
x >>>= 1; // we have exactly the desired bits.
}
return (n + x) / d; // Form the number within [0, 1).
};
};
module.exports.resetGlobal = function () {
Math.random = oldRandom;
};
//
// ARC4
//
// An ARC4 implementation. The constructor takes a key in the form of
// an array of at most (width) integers that should be 0 <= x < (width).
//
// The g(count) method returns a pseudorandom integer that concatenates
// the next (count) outputs from ARC4. Its return value is a number x
// that is in the range 0 <= x < (width ^ count).
//
/** @constructor */
function ARC4(key) {
var t, keylen = key.length,
me = this, i = 0, j = me.i = me.j = 0, s = me.S = [];
// The empty key [] is treated as [0].
if (!keylen) { key = [keylen++]; }
// Set up S using the standard key scheduling algorithm.
while (i < width) {
s[i] = i++;
}
for (i = 0; i < width; i++) {
s[i] = s[j = mask & (j + key[i % keylen] + (t = s[i]))];
s[j] = t;
}
// The "g" method returns the next (count) outputs as one number.
(me.g = function(count) {
// Using instance members instead of closure state nearly doubles speed.
var t, r = 0,
i = me.i, j = me.j, s = me.S;
while (count--) {
t = s[i = mask & (i + 1)];
r = r * width + s[mask & ((s[i] = s[j = mask & (j + t)]) + (s[j] = t))];
}
me.i = i; me.j = j;
return r;
// For robust unpredictability discard an initial batch of values.
// See http://www.rsa.com/rsalabs/node.asp?id=2009
})(width);
}
//
// flatten()
// Converts an object tree to nested arrays of strings.
//
function flatten(obj, depth) {
var result = [], typ = (typeof obj)[0], prop;
if (depth && typ == 'o') {
for (prop in obj) {
try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}
}
}
return (result.length ? result : typ == 's' ? obj : obj + '\0');
}
//
// mixkey()
// Mixes a string seed into a key that is an array of integers, and
// returns a shortened string seed that is equivalent to the result key.
//
function mixkey(seed, key) {
var stringseed = seed + '', smear, j = 0;
while (j < stringseed.length) {
key[mask & j] =
mask & ((smear ^= key[mask & j] * 19) + stringseed.charCodeAt(j++));
}
return tostring(key);
}
//
// autoseed()
// Returns an object for autoseeding, using window.crypto if available.
//
/** @param {Uint8Array=} seed */
function autoseed(seed) {
try {
GLOBAL.crypto.getRandomValues(seed = new Uint8Array(width));
return tostring(seed);
} catch (e) {
return [+new Date, GLOBAL, GLOBAL.navigator && GLOBAL.navigator.plugins,
GLOBAL.screen, tostring(pool)];
}
}
//
// tostring()
// Converts an array of charcodes to a string
//
function tostring(a) {
return String.fromCharCode.apply(0, a);
}
//
// When seedrandom.js is loaded, we immediately mix a few bits
// from the built-in RNG into the entropy pool. Because we do
// not want to intefere with determinstic PRNG state later,
// seedrandom will not call Math.random on its own again after
// initialization.
//
mixkey(Math.random(), pool);
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
module.exports = __webpack_require__(39);
/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
module.exports = __webpack_require__(35)
__webpack_require__(36)
__webpack_require__(37)
__webpack_require__(38)
/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {
exports = module.exports = function() {
var ret = '', value;
for (var i = 0; i < 32; i++) {
value = exports.random() * 16 | 0;
// Insert the hypens
if (i > 4 && i < 21 && ! (i % 4)) {
ret += '-';
}
// Add the next random character
ret += (
(i === 12) ? 4 : (
(i === 16) ? (value & 3 | 8) : value
)
).toString(16);
}
return ret;
};
var uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
exports.isUUID = function(uuid) {
return uuidRegex.test(uuid);
};
exports.random = function() {
return Math.random();
};
/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {
exports.Host = __webpack_require__(40);
exports.Promise = __webpack_require__(41);
/***/ },
/* 30 */
/***/ function(module, exports, __webpack_require__) {
var http = module.exports;
var EventEmitter = __webpack_require__(44).EventEmitter;
var Request = __webpack_require__(42);
var url = __webpack_require__(31)
http.request = function (params, cb) {
if (typeof params === 'string') {
params = url.parse(params)
}
if (!params) params = {};
if (!params.host && !params.port) {
params.port = parseInt(window.location.port, 10);
}
if (!params.host && params.hostname) {
params.host = params.hostname;
}
if (!params.protocol) {
if (params.scheme) {
params.protocol = params.scheme + ':';
} else {
params.protocol = window.location.protocol;
}
}
if (!params.host) {
params.host = window.location.hostname || window.location.host;
}
if (/:/.test(params.host)) {
if (!params.port) {
params.port = params.host.split(':')[1];
}
params.host = params.host.split(':')[0];
}
if (!params.port) params.port = params.protocol == 'https:' ? 443 : 80;
var req = new Request(new xhrHttp, params);
if (cb) req.on('response', cb);
return req;
};
http.get = function (params, cb) {
params.method = 'GET';
var req = http.request(params, cb);
req.end();
return req;
};
http.Agent = function () {};
http.Agent.defaultMaxSockets = 4;
var xhrHttp = (function () {
if (typeof window === 'undefined') {
throw new Error('no window object present');
}
else if (window.XMLHttpRequest) {
return window.XMLHttpRequest;
}
else if (window.ActiveXObject) {
var axs = [
'Msxml2.XMLHTTP.6.0',
'Msxml2.XMLHTTP.3.0',
'Microsoft.XMLHTTP'
];
for (var i = 0; i < axs.length; i++) {
try {
var ax = new(window.ActiveXObject)(axs[i]);
return function () {
if (ax) {
var ax_ = ax;
ax = null;
return ax_;
}
else {
return new(window.ActiveXObject)(axs[i]);
}
};
}
catch (e) {}
}
throw new Error('ajax not supported in this browser')
}
else {
throw new Error('ajax not supported in this browser');
}
})();
http.STATUS_CODES = {
100 : 'Continue',
101 : 'Switching Protocols',
102 : 'Processing', // RFC 2518, obsoleted by RFC 4918
200 : 'OK',
201 : 'Created',
202 : 'Accepted',
203 : 'Non-Authoritative Information',
204 : 'No Content',
205 : 'Reset Content',
206 : 'Partial Content',
207 : 'Multi-Status', // RFC 4918
300 : 'Multiple Choices',
301 : 'Moved Permanently',
302 : 'Moved Temporarily',
303 : 'See Other',
304 : 'Not Modified',
305 : 'Use Proxy',
307 : 'Temporary Redirect',
400 : 'Bad Request',
401 : 'Unauthorized',
402 : 'Payment Required',
403 : 'Forbidden',
404 : 'Not Found',
405 : 'Method Not Allowed',
406 : 'Not Acceptable',
407 : 'Proxy Authentication Required',
408 : 'Request Time-out',
409 : 'Conflict',
410 : 'Gone',
411 : 'Length Required',
412 : 'Precondition Failed',
413 : 'Request Entity Too Large',
414 : 'Request-URI Too Large',
415 : 'Unsupported Media Type',
416 : 'Requested Range Not Satisfiable',
417 : 'Expectation Failed',
418 : 'I\'m a teapot', // RFC 2324
422 : 'Unprocessable Entity', // RFC 4918
423 : 'Locked', // RFC 4918
424 : 'Failed Dependency', // RFC 4918
425 : 'Unordered Collection', // RFC 4918
426 : 'Upgrade Required', // RFC 2817
428 : 'Precondition Required', // RFC 6585
429 : 'Too Many Requests', // RFC 6585
431 : 'Request Header Fields Too Large',// RFC 6585
500 : 'Internal Server Error',
501 : 'Not Implemented',
502 : 'Bad Gateway',
503 : 'Service Unavailable',
504 : 'Gateway Time-out',
505 : 'HTTP Version Not Supported',
506 : 'Variant Also Negotiates', // RFC 2295
507 : 'Insufficient Storage', // RFC 4918
509 : 'Bandwidth Limit Exceeded',
510 : 'Not Extended', // RFC 2774
511 : 'Network Authentication Required' // RFC 6585
};
/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var punycode = __webpack_require__(54);
exports.parse = urlParse;
exports.resolve = urlResolve;
exports.resolveObject = urlResolveObject;
exports.format = urlFormat;
exports.Url = Url;
function Url() {
this.protocol = null;
this.slashes = null;
this.auth = null;
this.host = null;
this.port = null;
this.hostname = null;
this.hash = null;
this.search = null;
this.query = null;
this.pathname = null;
this.path = null;
this.href = null;
}
// Reference: RFC 3986, RFC 1808, RFC 2396
// define these here so at least they only have to be
// compiled once on the first module load.
var protocolPattern = /^([a-z0-9.+-]+:)/i,
portPattern = /:[0-9]*$/,
// RFC 2396: characters reserved for delimiting URLs.
// We actually just auto-escape these.
delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
// RFC 2396: characters not allowed for various reasons.
unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
// Allowed by RFCs, but cause of XSS attacks. Always escape these.
autoEscape = ['\''].concat(unwise),
// Characters that are never ever allowed in a hostname.
// Note that any invalid chars are also handled, but these
// are the ones that are *expected* to be seen, so we fast-path
// them.
nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
hostEndingChars = ['/', '?', '#'],
hostnameMaxLen = 255,
hostnamePartPattern = /^[a-z0-9A-Z_-]{0,63}$/,
hostnamePartStart = /^([a-z0-9A-Z_-]{0,63})(.*)$/,
// protocols that can allow "unsafe" and "unwise" chars.
unsafeProtocol = {
'javascript': true,
'javascript:': true
},
// protocols that never have a hostname.
hostlessProtocol = {
'javascript': true,
'javascript:': true
},
// protocols that always contain a // bit.
slashedProtocol = {
'http': true,
'https': true,
'ftp': true,
'gopher': true,
'file': true,
'http:': true,
'https:': true,
'ftp:': true,
'gopher:': true,
'file:': true
},
querystring = __webpack_require__(45);
function urlParse(url, parseQueryString, slashesDenoteHost) {
if (url && isObject(url) && url instanceof Url) return url;
var u = new Url;
u.parse(url, parseQueryString, slashesDenoteHost);
return u;
}
Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
if (!isString(url)) {
throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
}
var rest = url;
// trim before proceeding.
// This is to support parse stuff like " http://foo.com \n"
rest = rest.trim();
var proto = protocolPattern.exec(rest);
if (proto) {
proto = proto[0];
var lowerProto = proto.toLowerCase();
this.protocol = lowerProto;
rest = rest.substr(proto.length);
}
// figure out if it's got a host
// user@server is *always* interpreted as a hostname, and url
// resolution will treat //foo/bar as host=foo,path=bar because that's
// how the browser resolves relative URLs.
if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
var slashes = rest.substr(0, 2) === '//';
if (slashes && !(proto && hostlessProtocol[proto])) {
rest = rest.substr(2);
this.slashes = true;
}
}
if (!hostlessProtocol[proto] &&
(slashes || (proto && !slashedProtocol[proto]))) {
// there's a hostname.
// the first instance of /, ?, ;, or # ends the host.
//
// If there is an @ in the hostname, then non-host chars *are* allowed
// to the left of the last @ sign, unless some host-ending character
// comes *before* the @-sign.
// URLs are obnoxious.
//
// ex:
// http://a@b@c/ => user:a@b host:c
// http://a@b?@c => user:a host:c path:/?@c
// v0.12 TODO(isaacs): This is not quite how Chrome does things.
// Review our test case against browsers more comprehensively.
// find the first instance of any hostEndingChars
var hostEnd = -1;
for (var i = 0; i < hostEndingChars.length; i++) {
var hec = rest.indexOf(hostEndingChars[i]);
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
hostEnd = hec;
}
// at this point, either we have an explicit point where the
// auth portion cannot go past, or the last @ char is the decider.
var auth, atSign;
if (hostEnd === -1) {
// atSign can be anywhere.
atSign = rest.lastIndexOf('@');
} else {
// atSign must be in auth portion.
// http://a@b/c@d => host:b auth:a path:/c@d
atSign = rest.lastIndexOf('@', hostEnd);
}
// Now we have a portion which is definitely the auth.
// Pull that off.
if (atSign !== -1) {
auth = rest.slice(0, atSign);
rest = rest.slice(atSign + 1);
this.auth = decodeURIComponent(auth);
}
// the host is the remaining to the left of the first non-host char
hostEnd = -1;
for (var i = 0; i < nonHostChars.length; i++) {
var hec = rest.indexOf(nonHostChars[i]);
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
hostEnd = hec;
}
// if we still have not hit it, then the entire thing is a host.
if (hostEnd === -1)
hostEnd = rest.length;
this.host = rest.slice(0, hostEnd);
rest = rest.slice(hostEnd);
// pull out port.
this.parseHost();
// we've indicated that there is a hostname,
// so even if it's empty, it has to be present.
this.hostname = this.hostname || '';
// if hostname begins with [ and ends with ]
// assume that it's an IPv6 address.
var ipv6Hostname = this.hostname[0] === '[' &&
this.hostname[this.hostname.length - 1] === ']';
// validate a little.
if (!ipv6Hostname) {
var hostparts = this.hostname.split(/\./);
for (var i = 0, l = hostparts.length; i < l; i++) {
var part = hostparts[i];
if (!part) continue;
if (!part.match(hostnamePartPattern)) {
var newpart = '';
for (var j = 0, k = part.length; j < k; j++) {
if (part.charCodeAt(j) > 127) {
// we replace non-ASCII char with a temporary placeholder
// we need this to make sure size of hostname is not
// broken by replacing non-ASCII by nothing
newpart += 'x';
} else {
newpart += part[j];
}
}
// we test again with ASCII char only
if (!newpart.match(hostnamePartPattern)) {
var validParts = hostparts.slice(0, i);
var notHost = hostparts.slice(i + 1);
var bit = part.match(hostnamePartStart);
if (bit) {
validParts.push(bit[1]);
notHost.unshift(bit[2]);
}
if (notHost.length) {
rest = '/' + notHost.join('.') + rest;
}
this.hostname = validParts.join('.');
break;
}
}
}
}
if (this.hostname.length > hostnameMaxLen) {
this.hostname = '';
} else {
// hostnames are always lower case.
this.hostname = this.hostname.toLowerCase();
}
if (!ipv6Hostname) {
// IDNA Support: Returns a puny coded representation of "domain".
// It only converts the part of the domain name that
// has non ASCII characters. I.e. it dosent matter if
// you call it with a domain that already is in ASCII.
var domainArray = this.hostname.split('.');
var newOut = [];
for (var i = 0; i < domainArray.length; ++i) {
var s = domainArray[i];
newOut.push(s.match(/[^A-Za-z0-9_-]/) ?
'xn--' + punycode.encode(s) : s);
}
this.hostname = newOut.join('.');
}
var p = this.port ? ':' + this.port : '';
var h = this.hostname || '';
this.host = h + p;
this.href += this.host;
// strip [ and ] from the hostname
// the host field still retains them, though
if (ipv6Hostname) {
this.hostname = this.hostname.substr(1, this.hostname.length - 2);
if (rest[0] !== '/') {
rest = '/' + rest;
}
}
}
// now rest is set to the post-host stuff.
// chop off any delim chars.
if (!unsafeProtocol[lowerProto]) {
// First, make 100% sure that any "autoEscape" chars get
// escaped, even if encodeURIComponent doesn't think they
// need to be.
for (var i = 0, l = autoEscape.length; i < l; i++) {
var ae = autoEscape[i];
var esc = encodeURIComponent(ae);
if (esc === ae) {
esc = escape(ae);
}
rest = rest.split(ae).join(esc);
}
}
// chop off from the tail first.
var hash = rest.indexOf('#');
if (hash !== -1) {
// got a fragment string.
this.hash = rest.substr(hash);
rest = rest.slice(0, hash);
}
var qm = rest.indexOf('?');
if (qm !== -1) {
this.search = rest.substr(qm);
this.query = rest.substr(qm + 1);
if (parseQueryString) {
this.query = querystring.parse(this.query);
}
rest = rest.slice(0, qm);
} else if (parseQueryString) {
// no query string, but parseQueryString still requested
this.search = '';
this.query = {};
}
if (rest) this.pathname = rest;
if (slashedProtocol[lowerProto] &&
this.hostname && !this.pathname) {
this.pathname = '/';
}
//to support http.request
if (this.pathname || this.search) {
var p = this.pathname || '';
var s = this.search || '';
this.path = p + s;
}
// finally, reconstruct the href based on what has been validated.
this.href = this.format();
return this;
};
// format a parsed object into a url string
function urlFormat(obj) {
// ensure it's an object, and not a string url.
// If it's an obj, this is a no-op.
// this way, you can call url_format() on strings
// to clean up potentially wonky urls.
if (isString(obj)) obj = urlParse(obj);
if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
return obj.format();
}
Url.prototype.format = function() {
var auth = this.auth || '';
if (auth) {
auth = encodeURIComponent(auth);
auth = auth.replace(/%3A/i, ':');
auth += '@';
}
var protocol = this.protocol || '',
pathname = this.pathname || '',
hash = this.hash || '',
host = false,
query = '';
if (this.host) {
host = auth + this.host;
} else if (this.hostname) {
host = auth + (this.hostname.indexOf(':') === -1 ?
this.hostname :
'[' + this.hostname + ']');
if (this.port) {
host += ':' + this.port;
}
}
if (this.query &&
isObject(this.query) &&
Object.keys(this.query).length) {
query = querystring.stringify(this.query);
}
var search = this.search || (query && ('?' + query)) || '';
if (protocol && protocol.substr(-1) !== ':') protocol += ':';
// only the slashedProtocols get the //. Not mailto:, xmpp:, etc.
// unless they had them to begin with.
if (this.slashes ||
(!protocol || slashedProtocol[protocol]) && host !== false) {
host = '//' + (host || '');
if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
} else if (!host) {
host = '';
}
if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
if (search && search.charAt(0) !== '?') search = '?' + search;
pathname = pathname.replace(/[?#]/g, function(match) {
return encodeURIComponent(match);
});
search = search.replace('#', '%23');
return protocol + host + pathname + search + hash;
};
function urlResolve(source, relative) {
return urlParse(source, false, true).resolve(relative);
}
Url.prototype.resolve = function(relative) {
return this.resolveObject(urlParse(relative, false, true)).format();
};
function urlResolveObject(source, relative) {
if (!source) return relative;
return urlParse(source, false, true).resolveObject(relative);
}
Url.prototype.resolveObject = function(relative) {
if (isString(relative)) {
var rel = new Url();
rel.parse(relative, false, true);
relative = rel;
}
var result = new Url();
Object.keys(this).forEach(function(k) {
result[k] = this[k];
}, this);
// hash is always overridden, no matter what.
// even href="" will remove it.
result.hash = relative.hash;
// if the relative url is empty, then there's nothing left to do here.
if (relative.href === '') {
result.href = result.format();
return result;
}
// hrefs like //foo/bar always cut to the protocol.
if (relative.slashes && !relative.protocol) {
// take everything except the protocol from relative
Object.keys(relative).forEach(function(k) {
if (k !== 'protocol')
result[k] = relative[k];
});
//urlParse appends trailing / to urls like http://www.example.com
if (slashedProtocol[result.protocol] &&
result.hostname && !result.pathname) {
result.path = result.pathname = '/';
}
result.href = result.format();
return result;
}
if (relative.protocol && relative.protocol !== result.protocol) {
// if it's a known url protocol, then changing
// the protocol does weird things
// first, if it's not file:, then we MUST have a host,
// and if there was a path
// to begin with, then we MUST have a path.
// if it is file:, then the host is dropped,
// because that's known to be hostless.
// anything else is assumed to be absolute.
if (!slashedProtocol[relative.protocol]) {
Object.keys(relative).forEach(function(k) {
result[k] = relative[k];
});
result.href = result.format();
return result;
}
result.protocol = relative.protocol;
if (!relative.host && !hostlessProtocol[relative.protocol]) {
var relPath = (relative.pathname || '').split('/');
while (relPath.length && !(relative.host = relPath.shift()));
if (!relative.host) relative.host = '';
if (!relative.hostname) relative.hostname = '';
if (relPath[0] !== '') relPath.unshift('');
if (relPath.length < 2) relPath.unshift('');
result.pathname = relPath.join('/');
} else {
result.pathname = relative.pathname;
}
result.search = relative.search;
result.query = relative.query;
result.host = relative.host || '';
result.auth = relative.auth;
result.hostname = relative.hostname || relative.host;
result.port = relative.port;
// to support http.request
if (result.pathname || result.search) {
var p = result.pathname || '';
var s = result.search || '';
result.path = p + s;
}
result.slashes = result.slashes || relative.slashes;
result.href = result.format();
return result;
}
var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
isRelAbs = (
relative.host ||
relative.pathname && relative.pathname.charAt(0) === '/'
),
mustEndAbs = (isRelAbs || isSourceAbs ||
(result.host && relative.pathname)),
removeAllDots = mustEndAbs,
srcPath = result.pathname && result.pathname.split('/') || [],
relPath = relative.pathname && relative.pathname.split('/') || [],
psychotic = result.protocol && !slashedProtocol[result.protocol];
// if the url is a non-slashed url, then relative
// links like ../.. should be able
// to crawl up to the hostname, as well. This is strange.
// result.protocol has already been set by now.
// Later on, put the first path part into the host field.
if (psychotic) {
result.hostname = '';
result.port = null;
if (result.host) {
if (srcPath[0] === '') srcPath[0] = result.host;
else srcPath.unshift(result.host);
}
result.host = '';
if (relative.protocol) {
relative.hostname = null;
relative.port = null;
if (relative.host) {
if (relPath[0] === '') relPath[0] = relative.host;
else relPath.unshift(relative.host);
}
relative.host = null;
}
mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
}
if (isRelAbs) {
// it's absolute.
result.host = (relative.host || relative.host === '') ?
relative.host : result.host;
result.hostname = (relative.hostname || relative.hostname === '') ?
relative.hostname : result.hostname;
result.search = relative.search;
result.query = relative.query;
srcPath = relPath;
// fall through to the dot-handling below.
} else if (relPath.length) {
// it's relative
// throw away the existing file, and take the new path instead.
if (!srcPath) srcPath = [];
srcPath.pop();
srcPath = srcPath.concat(relPath);
result.search = relative.search;
result.query = relative.query;
} else if (!isNullOrUndefined(relative.search)) {
// just pull out the search.
// like href='?foo'.
// Put this after the other two cases because it simplifies the booleans
if (psychotic) {
result.hostname = result.host = srcPath.shift();
//occationaly the auth can get stuck only in host
//this especialy happens in cases like
//url.resolveObject('mailto:local1@domain1', 'local2@domain2')
var authInHost = result.host && result.host.indexOf('@') > 0 ?
result.host.split('@') : false;
if (authInHost) {
result.auth = authInHost.shift();
result.host = result.hostname = authInHost.shift();
}
}
result.search = relative.search;
result.query = relative.query;
//to support http.request
if (!isNull(result.pathname) || !isNull(result.search)) {
result.path = (result.pathname ? result.pathname : '') +
(result.search ? result.search : '');
}
result.href = result.format();
return result;
}
if (!srcPath.length) {
// no path at all. easy.
// we've already handled the other stuff above.
result.pathname = null;
//to support http.request
if (result.search) {
result.path = '/' + result.search;
} else {
result.path = null;
}
result.href = result.format();
return result;
}
// if a url ENDs in . or .., then it must get a trailing slash.
// however, if it ends in anything else non-slashy,
// then it must NOT get a trailing slash.
var last = srcPath.slice(-1)[0];
var hasTrailingSlash = (
(result.host || relative.host) && (last === '.' || last === '..') ||
last === '');
// strip single dots, resolve double dots to parent dir
// if the path tries to go above the root, `up` ends up > 0
var up = 0;
for (var i = srcPath.length; i >= 0; i--) {
last = srcPath[i];
if (last == '.') {
srcPath.splice(i, 1);
} else if (last === '..') {
srcPath.splice(i, 1);
up++;
} else if (up) {
srcPath.splice(i, 1);
up--;
}
}
// if the path is allowed to go above the root, restore leading ..s
if (!mustEndAbs && !removeAllDots) {
for (; up--; up) {
srcPath.unshift('..');
}
}
if (mustEndAbs && srcPath[0] !== '' &&
(!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
srcPath.unshift('');
}
if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
srcPath.push('');
}
var isAbsolute = srcPath[0] === '' ||
(srcPath[0] && srcPath[0].charAt(0) === '/');
// put the host back
if (psychotic) {
result.hostname = result.host = isAbsolute ? '' :
srcPath.length ? srcPath.shift() : '';
//occationaly the auth can get stuck only in host
//this especialy happens in cases like
//url.resolveObject('mailto:local1@domain1', 'local2@domain2')
var authInHost = result.host && result.host.indexOf('@') > 0 ?
result.host.split('@') : false;
if (authInHost) {
result.auth = authInHost.shift();
result.host = result.hostname = authInHost.shift();
}
}
mustEndAbs = mustEndAbs || (result.host && srcPath.length);
if (mustEndAbs && !isAbsolute) {
srcPath.unshift('');
}
if (!srcPath.length) {
result.pathname = null;
result.path = null;
} else {
result.pathname = srcPath.join('/');
}
//to support request.http
if (!isNull(result.pathname) || !isNull(result.search)) {
result.path = (result.pathname ? result.pathname : '') +
(result.search ? result.search : '');
}
result.auth = relative.auth || result.auth;
result.slashes = result.slashes || relative.slashes;
result.href = result.format();
return result;
};
Url.prototype.parseHost = function() {
var host = this.host;
var port = portPattern.exec(host);
if (port) {
port = port[0];
if (port !== ':') {
this.port = port.substr(1);
}
host = host.substr(0, host.length - port.length);
}
if (host) this.hostname = host;
};
function isString(arg) {
return typeof arg === "string";
}
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
function isNull(arg) {
return arg === null;
}
function isNullOrUndefined(arg) {
return arg == null;
}
/***/ },
/* 32 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {// Version: 3.7.0
var NOW = 1
, READY = false
, READY_BUFFER = []
, PRESENCE_SUFFIX = '-pnpres'
, DEF_WINDOWING = 10 // MILLISECONDS.
, DEF_TIMEOUT = 10000 // MILLISECONDS.
, DEF_SUB_TIMEOUT = 310 // SECONDS.
, DEF_KEEPALIVE = 60 // SECONDS (FOR TIMESYNC).
, SECOND = 1000 // A THOUSAND MILLISECONDS.
, URLBIT = '/'
, PARAMSBIT = '&'
, PRESENCE_HB_THRESHOLD = 5
, PRESENCE_HB_DEFAULT = 30
, SDK_VER = '3.7.0'
, REPL = /{([\w\-]+)}/g;
/**
* UTILITIES
*/
function unique() { return'x'+ ++NOW+''+(+new Date) }
function rnow() { return+new Date }
/**
* NEXTORIGIN
* ==========
* var next_origin = nextorigin();
*/
var nextorigin = (function() {
var max = 20
, ori = Math.floor(Math.random() * max);
return function( origin, failover ) {
return origin.indexOf('pubsub.') > 0
&& origin.replace(
'pubsub', 'ps' + (
failover ? uuid().split('-')[0] :
(++ori < max? ori : ori=1)
) ) || origin;
}
})();
/**
* Build Url
* =======
*
*/
function build_url( url_components, url_params ) {
var url = url_components.join(URLBIT)
, params = [];
if (!url_params) return url;
each( url_params, function( key, value ) {
var value_str = (typeof value == 'object')?JSON['stringify'](value):value;
(typeof value != 'undefined' &&
value != null && encode(value_str).length > 0
) && params.push(key + "=" + encode(value_str));
} );
url += "?" + params.join(PARAMSBIT);
return url;
}
/**
* UPDATER
* =======
* var timestamp = unique();
*/
function updater( fun, rate ) {
var timeout
, last = 0
, runnit = function() {
if (last + rate > rnow()) {
clearTimeout(timeout);
timeout = setTimeout( runnit, rate );
}
else {
last = rnow();
fun();
}
};
return runnit;
}
/**
* GREP
* ====
* var list = grep( [1,2,3], function(item) { return item % 2 } )
*/
function grep( list, fun ) {
var fin = [];
each( list || [], function(l) { fun(l) && fin.push(l) } );
return fin
}
/**
* SUPPLANT
* ========
* var text = supplant( 'Hello {name}!', { name : 'John' } )
*/
function supplant( str, values ) {
return str.replace( REPL, function( _, match ) {
return values[match] || _
} );
}
/**
* timeout
* =======
* timeout( function(){}, 100 );
*/
function timeout( fun, wait ) {
return setTimeout( fun, wait );
}
/**
* uuid
* ====
* var my_uuid = uuid();
*/
function uuid(callback) {
var u = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g,
function(c) {
var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
return v.toString(16);
});
if (callback) callback(u);
return u;
}
function isArray(arg) {
//return !!arg && (Array.isArray && Array.isArray(arg) || typeof(arg.length) === "number")
return !!arg && (Array.isArray && Array.isArray(arg))
}
/**
* EACH
* ====
* each( [1,2,3], function(item) { } )
*/
function each( o, f) {
if ( !o || !f ) return;
if ( isArray(o) )
for ( var i = 0, l = o.length; i < l; )
f.call( o[i], o[i], i++ );
else
for ( var i in o )
o.hasOwnProperty &&
o.hasOwnProperty(i) &&
f.call( o[i], i, o[i] );
}
/**
* MAP
* ===
* var list = map( [1,2,3], function(item) { return item + 1 } )
*/
function map( list, fun ) {
var fin = [];
each( list || [], function( k, v ) { fin.push(fun( k, v )) } );
return fin;
}
/**
* ENCODE
* ======
* var encoded_data = encode('path');
*/
function encode(path) { return encodeURIComponent(path) }
/**
* Generate Subscription Channel List
* ==================================
* generate_channel_list(channels_object);
*/
function generate_channel_list(channels, nopresence) {
var list = [];
each( channels, function( channel, status ) {
if (nopresence) {
if(channel.search('-pnpres') < 0) {
if (status.subscribed) list.push(channel);
}
} else {
if (status.subscribed) list.push(channel);
}
});
return list.sort();
}
/**
* Generate Subscription Channel Groups List
* ==================================
* generate_channel_groups_list(channels_groups object);
*/
function generate_channel_groups_list(channel_groups, nopresence) {
var list = [];
each(channel_groups, function( channel_group, status ) {
if (nopresence) {
if(channel.search('-pnpres') < 0) {
if (status.subscribed) list.push(channel_group);
}
} else {
if (status.subscribed) list.push(channel_group);
}
});
return list.sort();
}
// PUBNUB READY TO CONNECT
function ready() { timeout( function() {
if (READY) return;
READY = 1;
each( READY_BUFFER, function(connect) { connect() } );
}, SECOND ); }
function PNmessage(args) {
msg = args || {'apns' : {}},
msg['getPubnubMessage'] = function() {
var m = {};
if (Object.keys(msg['apns']).length) {
m['pn_apns'] = {
'aps' : {
'alert' : msg['apns']['alert'] ,
'badge' : msg['apns']['badge']
}
}
for (var k in msg['apns']) {
m['pn_apns'][k] = msg['apns'][k];
}
var exclude1 = ['badge','alert'];
for (var k in exclude1) {
//console.log(exclude[k]);
delete m['pn_apns'][exclude1[k]];
}
}
if (msg['gcm']) {
m['pn_gcm'] = {
'data' : msg['gcm']
}
}
for (var k in msg) {
m[k] = msg[k];
}
var exclude = ['apns','gcm','publish', 'channel','callback','error'];
for (var k in exclude) {
delete m[exclude[k]];
}
return m;
};
msg['publish'] = function() {
var m = msg.getPubnubMessage();
if (msg['pubnub'] && msg['channel']) {
msg['pubnub'].publish({
'message' : m,
'channel' : msg['channel'],
'callback' : msg['callback'],
'error' : msg['error']
})
}
};
return msg;
}
function PN_API(setup) {
var SUB_WINDOWING = +setup['windowing'] || DEF_WINDOWING
, SUB_TIMEOUT = (+setup['timeout'] || DEF_SUB_TIMEOUT) * SECOND
, KEEPALIVE = (+setup['keepalive'] || DEF_KEEPALIVE) * SECOND
, NOLEAVE = setup['noleave'] || 0
, PUBLISH_KEY = setup['publish_key'] || 'demo'
, SUBSCRIBE_KEY = setup['subscribe_key'] || 'demo'
, AUTH_KEY = setup['auth_key'] || ''
, SECRET_KEY = setup['secret_key'] || ''
, hmac_SHA256 = setup['hmac_SHA256']
, SSL = setup['ssl'] ? 's' : ''
, ORIGIN = 'http'+SSL+'://'+(setup['origin']||'pubsub.pubnub.com')
, STD_ORIGIN = nextorigin(ORIGIN)
, SUB_ORIGIN = nextorigin(ORIGIN)
, CONNECT = function(){}
, PUB_QUEUE = []
, CLOAK = true
, TIME_DRIFT = 0
, SUB_CALLBACK = 0
, SUB_CHANNEL = 0
, SUB_RECEIVER = 0
, SUB_RESTORE = setup['restore'] || 0
, SUB_BUFF_WAIT = 0
, TIMETOKEN = 0
, RESUMED = false
, CHANNELS = {}
, CHANNEL_GROUPS = {}
, STATE = {}
, PRESENCE_HB_TIMEOUT = null
, PRESENCE_HB = validate_presence_heartbeat(setup['heartbeat'] || setup['pnexpires'] || 0, setup['error'])
, PRESENCE_HB_INTERVAL = setup['heartbeat_interval'] || PRESENCE_HB - 3
, PRESENCE_HB_RUNNING = false
, NO_WAIT_FOR_PENDING = setup['no_wait_for_pending']
, COMPATIBLE_35 = setup['compatible_3.5'] || false
, xdr = setup['xdr']
, params = setup['params'] || {}
, error = setup['error'] || function() {}
, _is_online = setup['_is_online'] || function() { return 1 }
, jsonp_cb = setup['jsonp_cb'] || function() { return 0 }
, db = setup['db'] || {'get': function(){}, 'set': function(){}}
, CIPHER_KEY = setup['cipher_key']
, UUID = setup['uuid'] || ( db && db['get'](SUBSCRIBE_KEY+'uuid') || '')
, _poll_timer
, _poll_timer2;
var crypto_obj = setup['crypto_obj'] ||
{
'encrypt' : function(a,key){ return a},
'decrypt' : function(b,key){return b}
};
function _get_url_params(data) {
if (!data) data = {};
each( params , function( key, value ) {
if (!(key in data)) data[key] = value;
});
return data;
}
function _object_to_key_list(o) {
var l = []
each( o , function( key, value ) {
l.push(key);
});
return l;
}
function _object_to_key_list_sorted(o) {
return _object_to_key_list(o).sort();
}
function _get_pam_sign_input_from_params(params) {
var si = "";
var l = _object_to_key_list_sorted(params);
for (var i in l) {
var k = l[i]
si += k + "=" + encode(params[k]) ;
if (i != l.length - 1) si += "&"
}
return si;
}
function validate_presence_heartbeat(heartbeat, cur_heartbeat, error) {
var err = false;
if (typeof heartbeat === 'number') {
if (heartbeat > PRESENCE_HB_THRESHOLD || heartbeat == 0)
err = false;
else
err = true;
} else if(typeof heartbeat === 'boolean'){
if (!heartbeat) {
return 0;
} else {
return PRESENCE_HB_DEFAULT;
}
} else {
err = true;
}
if (err) {
error && error("Presence Heartbeat value invalid. Valid range ( x > " + PRESENCE_HB_THRESHOLD + " or x = 0). Current Value : " + (cur_heartbeat || PRESENCE_HB_THRESHOLD));
return cur_heartbeat || PRESENCE_HB_THRESHOLD;
} else return heartbeat;
}
function encrypt(input, key) {
return crypto_obj['encrypt'](input, key || CIPHER_KEY) || input;
}
function decrypt(input, key) {
return crypto_obj['decrypt'](input, key || CIPHER_KEY) ||
crypto_obj['decrypt'](input, CIPHER_KEY) ||
input;
}
function error_common(message, callback) {
callback && callback({ 'error' : message || "error occurred"});
error && error(message);
}
function _presence_heartbeat() {
clearTimeout(PRESENCE_HB_TIMEOUT);
if (!PRESENCE_HB_INTERVAL || PRESENCE_HB_INTERVAL >= 500 || PRESENCE_HB_INTERVAL < 1 || !generate_channel_list(CHANNELS,true).length){
PRESENCE_HB_RUNNING = false;
return;
}
PRESENCE_HB_RUNNING = true;
SELF['presence_heartbeat']({
'callback' : function(r) {
PRESENCE_HB_TIMEOUT = timeout( _presence_heartbeat, (PRESENCE_HB_INTERVAL) * SECOND );
},
'error' : function(e) {
error && error("Presence Heartbeat unable to reach Pubnub servers." + JSON.stringify(e));
PRESENCE_HB_TIMEOUT = timeout( _presence_heartbeat, (PRESENCE_HB_INTERVAL) * SECOND );
}
});
}
function start_presence_heartbeat() {
!PRESENCE_HB_RUNNING && _presence_heartbeat();
}
function publish(next) {
if (NO_WAIT_FOR_PENDING) {
if (!PUB_QUEUE.length) return;
} else {
if (next) PUB_QUEUE.sending = 0;
if ( PUB_QUEUE.sending || !PUB_QUEUE.length ) return;
PUB_QUEUE.sending = 1;
}
xdr(PUB_QUEUE.shift());
}
function each_channel(callback) {
var count = 0;
each( generate_channel_list(CHANNELS), function(channel) {
var chan = CHANNELS[channel];
if (!chan) return;
count++;
(callback||function(){})(chan);
} );
return count;
}
function _invoke_callback(response, callback, err) {
if (typeof response == 'object') {
if (response['error'] && response['message'] && response['payload']) {
err({'message' : response['message'], 'payload' : response['payload']});
return;
}
if (response['payload']) {
callback(response['payload']);
return;
}
}
callback(response);
}
function _invoke_error(response,err) {
if (typeof response == 'object' && response['error'] &&
response['message'] && response['payload']) {
err({'message' : response['message'], 'payload' : response['payload']});
} else err(response);
}
function CR(args, callback, url1, data) {
var callback = args['callback'] || callback
, err = args['error'] || error
, jsonp = jsonp_cb();
var url = [
STD_ORIGIN, 'v1', 'channel-registration',
'sub-key', SUBSCRIBE_KEY
];
url.push.apply(url,url1);
xdr({
callback : jsonp,
data : _get_url_params(data),
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) {
_invoke_error(response, err);
},
url : url
});
}
// Announce Leave Event
var SELF = {
'LEAVE' : function( channel, blocking, callback, error ) {
var data = { 'uuid' : UUID, 'auth' : AUTH_KEY }
, origin = nextorigin(ORIGIN)
, callback = callback || function(){}
, err = error || function(){}
, jsonp = jsonp_cb();
// Prevent Leaving a Presence Channel
if (channel.indexOf(PRESENCE_SUFFIX) > 0) return true;
if (COMPATIBLE_35) {
if (!SSL) return false;
if (jsonp == '0') return false;
}
if (NOLEAVE) return false;
if (jsonp != '0') data['callback'] = jsonp;
xdr({
blocking : blocking || SSL,
timeout : 2000,
callback : jsonp,
data : _get_url_params(data),
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) {
_invoke_error(response, err);
},
url : [
origin, 'v2', 'presence', 'sub_key',
SUBSCRIBE_KEY, 'channel', encode(channel), 'leave'
]
});
return true;
},
'set_resumed' : function(resumed) {
RESUMED = resumed;
},
'get_cipher_key' : function() {
return CIPHER_KEY;
},
'set_cipher_key' : function(key) {
CIPHER_KEY = key;
},
'raw_encrypt' : function(input, key) {
return encrypt(input, key);
},
'raw_decrypt' : function(input, key) {
return decrypt(input, key);
},
'get_heartbeat' : function() {
return PRESENCE_HB;
},
'set_heartbeat' : function(heartbeat) {
PRESENCE_HB = validate_presence_heartbeat(heartbeat, PRESENCE_HB_INTERVAL, error);
PRESENCE_HB_INTERVAL = (PRESENCE_HB - 3 >= 1)?PRESENCE_HB - 3:1;
CONNECT();
_presence_heartbeat();
},
'get_heartbeat_interval' : function() {
return PRESENCE_HB_INTERVAL;
},
'set_heartbeat_interval' : function(heartbeat_interval) {
PRESENCE_HB_INTERVAL = heartbeat_interval;
_presence_heartbeat();
},
'get_version' : function() {
return SDK_VER;
},
'getGcmMessageObject' : function(obj) {
return {
'data' : obj
}
},
'getApnsMessageObject' : function(obj) {
var x = {
'aps' : { 'badge' : 1, 'alert' : ''}
}
for (k in obj) {
k[x] = obj[k];
}
return x;
},
'newPnMessage' : function() {
var x = {};
if (gcm) x['pn_gcm'] = gcm;
if (apns) x['pn_apns'] = apns;
for ( k in n ) {
x[k] = n[k];
}
return x;
},
'_add_param' : function(key,val) {
params[key] = val;
},
'channel_group' : function(args, callback) {
var ns_ch = args['channel_group']
, channels = args['channels'] || args['channel']
, cloak = args['cloak']
, namespace
, channel_group
, url = []
, data = {}
, mode = args['mode'] || 'add';
if (ns_ch) {
var ns_ch_a = ns_ch.split(':');
if (ns_ch_a.length > 1) {
namespace = (ns_ch_a[0] === '*')?null:ns_ch_a[0];
channel_group = ns_ch_a[1];
} else {
channel_group = ns_ch_a[0];
}
}
namespace && url.push('namespace') && url.push(encode(namespace));
url.push('channel-group');
if (channel_group && channel_group !== '*') {
url.push(channel_group);
}
if (channels ) {
if (isArray(channels)) {
channels = channels.join(',');
}
data[mode] = channels;
data['cloak'] = (CLOAK)?'true':'false';
} else {
if (mode === 'remove') url.push('remove');
}
if (typeof cloak != 'undefined') data['cloak'] = (cloak)?'true':'false';
CR(args, callback, url, data);
},
'channel_group_list_groups' : function(args, callback) {
var namespace;
namespace = args['namespace'] || args['ns'] || args['channel_group'] || null;
if (namespace) {
args["channel_group"] = namespace + ":*";
}
SELF['channel_group'](args, callback);
},
'channel_group_list_channels' : function(args, callback) {
if (!args['channel_group']) return error('Missing Channel Group');
SELF['channel_group'](args, callback);
},
'channel_group_remove_channel' : function(args, callback) {
if (!args['channel_group']) return error('Missing Channel Group');
if (!args['channel'] && !args['channels'] ) return error('Missing Channel');
args['mode'] = 'remove';
SELF['channel_group'](args,callback);
},
'channel_group_remove_group' : function(args, callback) {
if (!args['channel_group']) return error('Missing Channel Group');
if (args['channel']) return error('Use channel_group_remove_channel if you want to remove a channel from a group.');
args['mode'] = 'remove';
SELF['channel_group'](args,callback);
},
'channel_group_add_channel' : function(args, callback) {
if (!args['channel_group']) return error('Missing Channel Group');
if (!args['channel'] && !args['channels'] ) return error('Missing Channel');
SELF['channel_group'](args,callback);
},
'channel_group_cloak' : function(args, callback) {
if (typeof args['cloak'] == 'undefined') {
callback(CLOAK);
return;
}
CLOAK = args['cloak'];
SELF['channel_group'](args,callback);
},
'channel_group_list_namespaces' : function(args, callback) {
var url = ['namespace'];
CR(args, callback, url);
},
'channel_group_remove_namespace' : function(args, callback) {
var url = ['namespace',args['namespace'],'remove'];
CR(args, callback, url);
},
/*
PUBNUB.history({
channel : 'my_chat_channel',
limit : 100,
callback : function(history) { }
});
*/
'history' : function( args, callback ) {
var callback = args['callback'] || callback
, count = args['count'] || args['limit'] || 100
, reverse = args['reverse'] || "false"
, err = args['error'] || function(){}
, auth_key = args['auth_key'] || AUTH_KEY
, cipher_key = args['cipher_key']
, channel = args['channel']
, channel_group = args['channel_group']
, start = args['start']
, end = args['end']
, include_token = args['include_token']
, params = {}
, jsonp = jsonp_cb();
// Make sure we have a Channel
if (!channel && !channel_group) return error('Missing Channel');
if (!callback) return error('Missing Callback');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
params['stringtoken'] = 'true';
params['count'] = count;
params['reverse'] = reverse;
params['auth'] = auth_key;
if (channel_group) {
params['channel-group'] = channel_group;
if (!channel) {
channel = ',';
}
}
if (jsonp) params['callback'] = jsonp;
if (start) params['start'] = start;
if (end) params['end'] = end;
if (include_token) params['include_token'] = 'true';
// Send Message
xdr({
callback : jsonp,
data : _get_url_params(params),
success : function(response) {
if (typeof response == 'object' && response['error']) {
err({'message' : response['message'], 'payload' : response['payload']});
return;
}
var messages = response[0];
var decrypted_messages = [];
for (var a = 0; a < messages.length; a++) {
var new_message = decrypt(messages[a],cipher_key);
try {
decrypted_messages['push'](JSON['parse'](new_message));
} catch (e) {
decrypted_messages['push']((new_message));
}
}
callback([decrypted_messages, response[1], response[2]]);
},
fail : function(response) {
_invoke_error(response, err);
},
url : [
STD_ORIGIN, 'v2', 'history', 'sub-key',
SUBSCRIBE_KEY, 'channel', encode(channel)
]
});
},
/*
PUBNUB.replay({
source : 'my_channel',
destination : 'new_channel'
});
*/
'replay' : function(args, callback) {
var callback = callback || args['callback'] || function(){}
, auth_key = args['auth_key'] || AUTH_KEY
, source = args['source']
, destination = args['destination']
, stop = args['stop']
, start = args['start']
, end = args['end']
, reverse = args['reverse']
, limit = args['limit']
, jsonp = jsonp_cb()
, data = {}
, url;
// Check User Input
if (!source) return error('Missing Source Channel');
if (!destination) return error('Missing Destination Channel');
if (!PUBLISH_KEY) return error('Missing Publish Key');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
// Setup URL Params
if (jsonp != '0') data['callback'] = jsonp;
if (stop) data['stop'] = 'all';
if (reverse) data['reverse'] = 'true';
if (start) data['start'] = start;
if (end) data['end'] = end;
if (limit) data['count'] = limit;
data['auth'] = auth_key;
// Compose URL Parts
url = [
STD_ORIGIN, 'v1', 'replay',
PUBLISH_KEY, SUBSCRIBE_KEY,
source, destination
];
// Start (or Stop) Replay!
xdr({
callback : jsonp,
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function() { callback([ 0, 'Disconnected' ]) },
url : url,
data : _get_url_params(data)
});
},
/*
PUBNUB.auth('AJFLKAJSDKLA');
*/
'auth' : function(auth) {
AUTH_KEY = auth;
CONNECT();
},
/*
PUBNUB.time(function(time){ });
*/
'time' : function(callback) {
var jsonp = jsonp_cb();
xdr({
callback : jsonp,
data : _get_url_params({ 'uuid' : UUID, 'auth' : AUTH_KEY }),
timeout : SECOND * 5,
url : [STD_ORIGIN, 'time', jsonp],
success : function(response) { callback(response[0]) },
fail : function() { callback(0) }
});
},
/*
PUBNUB.publish({
channel : 'my_chat_channel',
message : 'hello!'
});
*/
'publish' : function( args, callback ) {
var msg = args['message'];
if (!msg) return error('Missing Message');
var callback = callback || args['callback'] || msg['callback'] || function(){}
, channel = args['channel'] || msg['channel']
, auth_key = args['auth_key'] || AUTH_KEY
, cipher_key = args['cipher_key']
, err = args['error'] || msg['error'] || function() {}
, post = args['post'] || false
, store = ('store_in_history' in args) ? args['store_in_history']: true
, jsonp = jsonp_cb()
, add_msg = 'push'
, url;
if (args['prepend']) add_msg = 'unshift'
if (!channel) return error('Missing Channel');
if (!PUBLISH_KEY) return error('Missing Publish Key');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
if (msg['getPubnubMessage']) {
msg = msg['getPubnubMessage']();
}
// If trying to send Object
msg = JSON['stringify'](encrypt(msg, cipher_key));
// Create URL
url = [
STD_ORIGIN, 'publish',
PUBLISH_KEY, SUBSCRIBE_KEY,
0, encode(channel),
jsonp, encode(msg)
];
params = { 'uuid' : UUID, 'auth' : auth_key }
if (!store) params['store'] ="0"
// Queue Message Send
PUB_QUEUE[add_msg]({
callback : jsonp,
timeout : SECOND * 5,
url : url,
data : _get_url_params(params),
fail : function(response){
_invoke_error(response, err);
publish(1);
},
success : function(response) {
_invoke_callback(response, callback, err);
publish(1);
},
mode : (post)?'POST':'GET'
});
// Send Message
publish();
},
/*
PUBNUB.unsubscribe({ channel : 'my_chat' });
*/
'unsubscribe' : function(args, callback) {
var channel = args['channel']
, channel_group = args['channel_group']
, callback = callback || args['callback'] || function(){}
, err = args['error'] || function(){};
TIMETOKEN = 0;
//SUB_RESTORE = 1; REVISIT !!!!
if (channel) {
// Prepare Channel(s)
channel = map( (
channel.join ? channel.join(',') : ''+channel
).split(','), function(channel) {
if (!CHANNELS[channel]) return;
return channel + ',' + channel + PRESENCE_SUFFIX;
} ).join(',');
// Iterate over Channels
each( channel.split(','), function(channel) {
var CB_CALLED = true;
if (!channel) return;
if (READY) {
CB_CALLED = SELF['LEAVE']( channel, 0 , callback, err);
}
if (!CB_CALLED) callback({action : "leave"});
CHANNELS[channel] = 0;
if (channel in STATE) delete STATE[channel];
} );
}
if (channel_group) {
// Prepare channel group(s)
channel_group = map( (
channel_group.join ? channel_group.join(',') : ''+channel_group
).split(','), function(channel_group) {
if (!CHANNEL_GROUPS[channel_group]) return;
return channel_group + ',' + channel_group + PRESENCE_SUFFIX;
} ).join(',');
// Iterate over channel groups
each( channel_group.split(','), function(channel) {
var CB_CALLED = true;
if (!channel_group) return;
if (READY) {
CB_CALLED = SELF['LEAVE']( channel_group, 0 , callback, err);
}
if (!CB_CALLED) callback({action : "leave"});
CHANNEL_GROUPS[channel_group] = 0;
if (channel_group in STATE) delete STATE[channel_group];
} );
}
// Reset Connection if Count Less
CONNECT();
},
/*
PUBNUB.subscribe({
channel : 'my_chat'
callback : function(message) { }
});
*/
'subscribe' : function( args, callback ) {
var channel = args['channel']
, channel_group = args['channel_group']
, callback = callback || args['callback']
, callback = callback || args['message']
, auth_key = args['auth_key'] || AUTH_KEY
, connect = args['connect'] || function(){}
, reconnect = args['reconnect'] || function(){}
, disconnect = args['disconnect'] || function(){}
, errcb = args['error'] || function(){}
, idlecb = args['idle'] || function(){}
, presence = args['presence'] || 0
, noheresync = args['noheresync'] || 0
, backfill = args['backfill'] || 0
, timetoken = args['timetoken'] || 0
, sub_timeout = args['timeout'] || SUB_TIMEOUT
, windowing = args['windowing'] || SUB_WINDOWING
, state = args['state']
, heartbeat = args['heartbeat'] || args['pnexpires']
, restore = args['restore'] || SUB_RESTORE;
// Restore Enabled?
SUB_RESTORE = restore;
// Always Reset the TT
TIMETOKEN = timetoken;
// Make sure we have a Channel
if (!channel && !channel_group) {
return error('Missing Channel');
}
if (!callback) return error('Missing Callback');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
if (heartbeat || heartbeat === 0) {
SELF['set_heartbeat'](heartbeat);
}
// Setup Channel(s)
if (channel) {
each( (channel.join ? channel.join(',') : ''+channel).split(','),
function(channel) {
var settings = CHANNELS[channel] || {};
// Store Channel State
CHANNELS[SUB_CHANNEL = channel] = {
name : channel,
connected : settings.connected,
disconnected : settings.disconnected,
subscribed : 1,
callback : SUB_CALLBACK = callback,
'cipher_key' : args['cipher_key'],
connect : connect,
disconnect : disconnect,
reconnect : reconnect
};
if (state) {
if (channel in state) {
STATE[channel] = state[channel];
} else {
STATE[channel] = state;
}
}
// Presence Enabled?
if (!presence) return;
// Subscribe Presence Channel
SELF['subscribe']({
'channel' : channel + PRESENCE_SUFFIX,
'callback' : presence,
'restore' : restore
});
// Presence Subscribed?
if (settings.subscribed) return;
// See Who's Here Now?
if (noheresync) return;
SELF['here_now']({
'channel' : channel,
'callback' : function(here) {
each( 'uuids' in here ? here['uuids'] : [],
function(uid) { presence( {
'action' : 'join',
'uuid' : uid,
'timestamp' : Math.floor(rnow() / 1000),
'occupancy' : here['occupancy'] || 1
}, here, channel ); } );
}
});
} );
}
// Setup Channel Groups
if (channel_group) {
each( (channel_group.join ? channel_group.join(',') : ''+channel_group).split(','),
function(channel_group) {
var settings = CHANNEL_GROUPS[channel_group] || {};
CHANNEL_GROUPS[channel_group] = {
name : channel_group,
connected : settings.connected,
disconnected : settings.disconnected,
subscribed : 1,
callback : SUB_CALLBACK = callback,
'cipher_key' : args['cipher_key'],
connect : connect,
disconnect : disconnect,
reconnect : reconnect
};
// Presence Enabled?
if (!presence) return;
// Subscribe Presence Channel
SELF['subscribe']({
'channel_group' : channel_group + PRESENCE_SUFFIX,
'callback' : presence,
'restore' : restore
});
// Presence Subscribed?
if (settings.subscribed) return;
// See Who's Here Now?
if (noheresync) return;
SELF['here_now']({
'channel_group' : channel_group,
'callback' : function(here) {
each( 'uuids' in here ? here['uuids'] : [],
function(uid) { presence( {
'action' : 'join',
'uuid' : uid,
'timestamp' : Math.floor(rnow() / 1000),
'occupancy' : here['occupancy'] || 1
}, here, channel_group ); } );
}
});
} );
}
// Test Network Connection
function _test_connection(success) {
if (success) {
// Begin Next Socket Connection
timeout( CONNECT, SECOND );
}
else {
// New Origin on Failed Connection
STD_ORIGIN = nextorigin( ORIGIN, 1 );
SUB_ORIGIN = nextorigin( ORIGIN, 1 );
// Re-test Connection
timeout( function() {
SELF['time'](_test_connection);
}, SECOND );
}
// Disconnect & Reconnect
each_channel(function(channel){
// Reconnect
if (success && channel.disconnected) {
channel.disconnected = 0;
return channel.reconnect(channel.name);
}
// Disconnect
if (!success && !channel.disconnected) {
channel.disconnected = 1;
channel.disconnect(channel.name);
}
});
}
// Evented Subscribe
function _connect() {
var jsonp = jsonp_cb()
, channels = generate_channel_list(CHANNELS).join(',')
, channel_groups = generate_channel_groups_list(CHANNEL_GROUPS).join(',');
// Stop Connection
if (!channels && !channel_groups) return;
if (!channels) channels = ',';
// Connect to PubNub Subscribe Servers
_reset_offline();
var data = _get_url_params({ 'uuid' : UUID, 'auth' : auth_key });
if (channel_groups) {
data['channel-group'] = channel_groups;
}
var st = JSON.stringify(STATE);
if (st.length > 2) data['state'] = JSON.stringify(STATE);
if (PRESENCE_HB) data['heartbeat'] = PRESENCE_HB;
start_presence_heartbeat();
SUB_RECEIVER = xdr({
timeout : sub_timeout,
callback : jsonp,
fail : function(response) {
_invoke_error(response, errcb);
//SUB_RECEIVER = null;
SELF['time'](_test_connection);
},
data : _get_url_params(data),
url : [
SUB_ORIGIN, 'subscribe',
SUBSCRIBE_KEY, encode(channels),
jsonp, TIMETOKEN
],
success : function(messages) {
//SUB_RECEIVER = null;
// Check for Errors
if (!messages || (
typeof messages == 'object' &&
'error' in messages &&
messages['error']
)) {
errcb(messages['error']);
return timeout( CONNECT, SECOND );
}
// User Idle Callback
idlecb(messages[1]);
// Restore Previous Connection Point if Needed
TIMETOKEN = !TIMETOKEN &&
SUB_RESTORE &&
db['get'](SUBSCRIBE_KEY) || messages[1];
/*
// Connect
each_channel_registry(function(registry){
if (registry.connected) return;
registry.connected = 1;
registry.connect(channel.name);
});
*/
// Connect
each_channel(function(channel){
if (channel.connected) return;
channel.connected = 1;
channel.connect(channel.name);
});
if (RESUMED && !SUB_RESTORE) {
TIMETOKEN = 0;
RESUMED = false;
// Update Saved Timetoken
db['set']( SUBSCRIBE_KEY, 0 );
timeout( _connect, windowing );
return;
}
// Invoke Memory Catchup and Receive Up to 100
// Previous Messages from the Queue.
if (backfill) {
TIMETOKEN = 10000;
backfill = 0;
}
// Update Saved Timetoken
db['set']( SUBSCRIBE_KEY, messages[1] );
// Route Channel <---> Callback for Message
var next_callback = (function() {
var channels = '';
if (messages.length > 3) {
channels = messages[3];
} else if (messages.length > 2) {
channels = messages[2];
} else {
channels = map(
generate_channel_list(CHANNELS), function(chan) { return map(
Array(messages[0].length)
.join(',').split(','),
function() { return chan; }
) }).join(',')
}
var list = channels.split(',');
return function() {
var channel = list.shift()||SUB_CHANNEL;
return [
(CHANNELS[channel]||{})
.callback||SUB_CALLBACK,
channel.split(PRESENCE_SUFFIX)[0]
];
};
})();
var latency = detect_latency(+messages[1]);
each( messages[0], function(msg) {
var next = next_callback();
var decrypted_msg = decrypt(msg,
(CHANNELS[next[1]])?CHANNELS[next[1]]['cipher_key']:null);
next[0]( decrypted_msg, messages, next[2] || next[1], latency);
});
timeout( _connect, windowing );
}
});
}
CONNECT = function() {
_reset_offline();
timeout( _connect, windowing );
};
// Reduce Status Flicker
if (!READY) return READY_BUFFER.push(CONNECT);
// Connect Now
CONNECT();
},
/*
PUBNUB.here_now({ channel : 'my_chat', callback : fun });
*/
'here_now' : function( args, callback ) {
var callback = args['callback'] || callback
, err = args['error'] || function(){}
, auth_key = args['auth_key'] || AUTH_KEY
, channel = args['channel']
, channel_group = args['channel_group']
, jsonp = jsonp_cb()
, uuids = ('uuids' in args) ? args['uuids'] : true
, state = args['state']
, data = { 'uuid' : UUID, 'auth' : auth_key };
if (!uuids) data['disable_uuids'] = 1;
if (state) data['state'] = 1;
// Make sure we have a Channel
if (!callback) return error('Missing Callback');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
var url = [
STD_ORIGIN, 'v2', 'presence',
'sub_key', SUBSCRIBE_KEY
];
channel && url.push('channel') && url.push(encode(channel));
if (jsonp != '0') { data['callback'] = jsonp; }
if (channel_group) {
data['channel-group'] = channel_group;
!channel && url.push('channel') && url.push(',');
}
xdr({
callback : jsonp,
data : _get_url_params(data),
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) {
_invoke_error(response, err);
},
url : url
});
},
/*
PUBNUB.current_channels_by_uuid({ channel : 'my_chat', callback : fun });
*/
'where_now' : function( args, callback ) {
var callback = args['callback'] || callback
, err = args['error'] || function(){}
, auth_key = args['auth_key'] || AUTH_KEY
, jsonp = jsonp_cb()
, uuid = args['uuid'] || UUID
, data = { 'auth' : auth_key };
// Make sure we have a Channel
if (!callback) return error('Missing Callback');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
if (jsonp != '0') { data['callback'] = jsonp; }
xdr({
callback : jsonp,
data : _get_url_params(data),
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) {
_invoke_error(response, err);
},
url : [
STD_ORIGIN, 'v2', 'presence',
'sub_key', SUBSCRIBE_KEY,
'uuid', encode(uuid)
]
});
},
'state' : function(args, callback) {
var callback = args['callback'] || callback || function(r) {}
, err = args['error'] || function(){}
, auth_key = args['auth_key'] || AUTH_KEY
, jsonp = jsonp_cb()
, state = args['state']
, uuid = args['uuid'] || UUID
, channel = args['channel']
, channel_group = args['channel_group']
, url
, data = _get_url_params({ 'auth' : auth_key });
// Make sure we have a Channel
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
if (!uuid) return error('Missing UUID');
if (!channel && !channel_group) return error('Missing Channel');
if (jsonp != '0') { data['callback'] = jsonp; }
if (typeof channel != 'undefined'
&& CHANNELS[channel] && CHANNELS[channel].subscribed ) {
if (state) STATE[channel] = state;
}
if (typeof channel_group != 'undefined'
&& CHANNEL_GROUPS[channel_group]
&& CHANNEL_GROUPS[channel_group].subscribed
) {
if (state) STATE[channel_group] = state;
data['channel-group'] = channel_group;
if (!channel) {
channel = ',';
}
}
data['state'] = JSON.stringify(state);
if (state) {
url = [
STD_ORIGIN, 'v2', 'presence',
'sub-key', SUBSCRIBE_KEY,
'channel', channel,
'uuid', uuid, 'data'
]
} else {
url = [
STD_ORIGIN, 'v2', 'presence',
'sub-key', SUBSCRIBE_KEY,
'channel', channel,
'uuid', encode(uuid)
]
}
xdr({
callback : jsonp,
data : _get_url_params(data),
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) {
_invoke_error(response, err);
},
url : url
});
},
/*
PUBNUB.grant({
channel : 'my_chat',
callback : fun,
error : fun,
ttl : 24 * 60, // Minutes
read : true,
write : true,
auth_key : '3y8uiajdklytowsj'
});
*/
'grant' : function( args, callback ) {
var callback = args['callback'] || callback
, err = args['error'] || function(){}
, channel = args['channel']
, channel_group = args['channel_group']
, jsonp = jsonp_cb()
, ttl = args['ttl']
, r = (args['read'] )?"1":"0"
, w = (args['write'])?"1":"0"
, m = (args['manage'])?"1":"0"
, auth_key = args['auth_key'];
if (!callback) return error('Missing Callback');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
if (!PUBLISH_KEY) return error('Missing Publish Key');
if (!SECRET_KEY) return error('Missing Secret Key');
var timestamp = Math.floor(new Date().getTime() / 1000)
, sign_input = SUBSCRIBE_KEY + "\n" + PUBLISH_KEY + "\n"
+ "grant" + "\n";
var data = {
'w' : w,
'r' : r,
'timestamp' : timestamp
};
if (args['manage']) {
data['m'] = m;
}
if (typeof channel != 'undefined' && channel != null && channel.length > 0) data['channel'] = channel;
if (typeof channel_group != 'undefined' && channel_group != null && channel_group.length > 0) {
data['channel-group'] = channel_group;
}
if (jsonp != '0') { data['callback'] = jsonp; }
if (ttl || ttl === 0) data['ttl'] = ttl;
if (auth_key) data['auth'] = auth_key;
data = _get_url_params(data)
if (!auth_key) delete data['auth'];
sign_input += _get_pam_sign_input_from_params(data);
var signature = hmac_SHA256( sign_input, SECRET_KEY );
signature = signature.replace( /\+/g, "-" );
signature = signature.replace( /\//g, "_" );
data['signature'] = signature;
xdr({
callback : jsonp,
data : data,
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) {
_invoke_error(response, err);
},
url : [
STD_ORIGIN, 'v1', 'auth', 'grant' ,
'sub-key', SUBSCRIBE_KEY
]
});
},
/*
PUBNUB.audit({
channel : 'my_chat',
callback : fun,
error : fun,
read : true,
write : true,
auth_key : '3y8uiajdklytowsj'
});
*/
'audit' : function( args, callback ) {
var callback = args['callback'] || callback
, err = args['error'] || function(){}
, channel = args['channel']
, channel_group = args['channel_group']
, auth_key = args['auth_key']
, jsonp = jsonp_cb();
// Make sure we have a Channel
if (!callback) return error('Missing Callback');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
if (!PUBLISH_KEY) return error('Missing Publish Key');
if (!SECRET_KEY) return error('Missing Secret Key');
var timestamp = Math.floor(new Date().getTime() / 1000)
, sign_input = SUBSCRIBE_KEY + "\n"
+ PUBLISH_KEY + "\n"
+ "audit" + "\n";
var data = {'timestamp' : timestamp };
if (jsonp != '0') { data['callback'] = jsonp; }
if (typeof channel != 'undefined' && channel != null && channel.length > 0) data['channel'] = channel;
if (typeof channel_group != 'undefined' && channel_group != null && channel_group.length > 0) {
data['channel-group'] = channel_group;
}
if (auth_key) data['auth'] = auth_key;
data = _get_url_params(data);
if (!auth_key) delete data['auth'];
sign_input += _get_pam_sign_input_from_params(data);
var signature = hmac_SHA256( sign_input, SECRET_KEY );
signature = signature.replace( /\+/g, "-" );
signature = signature.replace( /\//g, "_" );
data['signature'] = signature;
xdr({
callback : jsonp,
data : data,
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) {
_invoke_error(response, err);
},
url : [
STD_ORIGIN, 'v1', 'auth', 'audit' ,
'sub-key', SUBSCRIBE_KEY
]
});
},
/*
PUBNUB.revoke({
channel : 'my_chat',
callback : fun,
error : fun,
auth_key : '3y8uiajdklytowsj'
});
*/
'revoke' : function( args, callback ) {
args['read'] = false;
args['write'] = false;
SELF['grant']( args, callback );
},
'set_uuid' : function(uuid) {
UUID = uuid;
CONNECT();
},
'get_uuid' : function() {
return UUID;
},
'presence_heartbeat' : function(args) {
var callback = args['callback'] || function() {}
var err = args['error'] || function() {}
var jsonp = jsonp_cb();
var data = { 'uuid' : UUID, 'auth' : AUTH_KEY };
var st = JSON['stringify'](STATE);
if (st.length > 2) data['state'] = JSON['stringify'](STATE);
if (PRESENCE_HB > 0 && PRESENCE_HB < 320) data['heartbeat'] = PRESENCE_HB;
if (jsonp != '0') { data['callback'] = jsonp; }
var channels = encode(generate_channel_list(CHANNELS, true)['join'](','));
var channel_groups = generate_channel_groups_list(CHANNEL_GROUPS, true)['join'](',');
if (!channels) channels = ',';
if (channel_groups) data['channel-group'] = channel_groups;
xdr({
callback : jsonp,
data : _get_url_params(data),
timeout : SECOND * 5,
url : [
STD_ORIGIN, 'v2', 'presence',
'sub-key', SUBSCRIBE_KEY,
'channel' , channels,
'heartbeat'
],
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) { _invoke_error(response, err); }
});
},
'stop_timers': function () {
clearTimeout(_poll_timer);
clearTimeout(_poll_timer2);
},
// Expose PUBNUB Functions
'xdr' : xdr,
'ready' : ready,
'db' : db,
'uuid' : uuid,
'map' : map,
'each' : each,
'each-channel' : each_channel,
'grep' : grep,
'offline' : function(){_reset_offline(1, { "message":"Offline. Please check your network settings." })},
'supplant' : supplant,
'now' : rnow,
'unique' : unique,
'updater' : updater
};
function _poll_online() {
_is_online() || _reset_offline( 1, {
"error" : "Offline. Please check your network settings. "
});
_poll_timer && clearTimeout(_poll_timer);
_poll_timer = timeout( _poll_online, SECOND );
}
function _poll_online2() {
SELF['time'](function(success){
detect_time_detla( function(){}, success );
success || _reset_offline( 1, {
"error" : "Heartbeat failed to connect to Pubnub Servers." +
"Please check your network settings."
});
_poll_timer2 && clearTimeout(_poll_timer2);
_poll_timer2 = timeout( _poll_online2, KEEPALIVE );
});
}
function _reset_offline(err, msg) {
SUB_RECEIVER && SUB_RECEIVER(err, msg);
SUB_RECEIVER = null;
clearTimeout(_poll_timer);
clearTimeout(_poll_timer2);
}
if (!UUID) UUID = SELF['uuid']();
db['set']( SUBSCRIBE_KEY + 'uuid', UUID );
_poll_timer = timeout( _poll_online, SECOND );
_poll_timer2 = timeout( _poll_online2, KEEPALIVE );
PRESENCE_HB_TIMEOUT = timeout( start_presence_heartbeat, ( PRESENCE_HB_INTERVAL - 3 ) * SECOND ) ;
// Detect Age of Message
function detect_latency(tt) {
var adjusted_time = rnow() - TIME_DRIFT;
return adjusted_time - tt / 10000;
}
detect_time_detla();
function detect_time_detla( cb, time ) {
var stime = rnow();
time && calculate(time) || SELF['time'](calculate);
function calculate(time) {
if (!time) return;
var ptime = time / 10000
, latency = (rnow() - stime) / 2;
TIME_DRIFT = rnow() - (ptime + latency);
cb && cb(TIME_DRIFT);
}
}
return SELF;
}
/* ---------------------------------------------------------------------------
WAIT! - This file depends on instructions from the PUBNUB Cloud.
http://www.pubnub.com/account
--------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------
PubNub Real-time Cloud-Hosted Push API and Push Notification Client Frameworks
Copyright (c) 2011 TopMambo Inc.
http://www.pubnub.com/
http://www.pubnub.com/terms
--------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
--------------------------------------------------------------------------- */
/**
* UTIL LOCALS
*/
var NOW = 1
, http = __webpack_require__(30)
, https = __webpack_require__(46)
, keepAliveAgent = new (keepAliveIsEmbedded() ? http.Agent : __webpack_require__(55))({
keepAlive: true,
keepAliveMsecs: 300000,
maxSockets: 5
})
, XHRTME = 310000
, DEF_TIMEOUT = 10000
, SECOND = 1000
, PNSDK = 'PubNub-JS-' + 'Nodejs' + '/' + '3.7.0'
, crypto = __webpack_require__(48)
, proxy = null
, XORIGN = 1;
function get_hmac_SHA256(data, key) {
return crypto.createHmac('sha256',
new Buffer(key, 'utf8')).update(data).digest('base64');
}
/**
* ERROR
* ===
* error('message');
*/
function error(message) { console['error'](message) }
/**
* Request
* =======
* xdr({
* url : ['http://www.blah.com/url'],
* success : function(response) {},
* fail : function() {}
* });
*/
function xdr( setup ) {
var request
, response
, success = setup.success || function(){}
, fail = setup.fail || function(){}
, origin = setup.origin || 'pubsub.pubnub.com'
, ssl = setup.ssl
, failed = 0
, complete = 0
, loaded = 0
, mode = setup['mode'] || 'GET'
, data = setup['data'] || {}
, xhrtme = setup.timeout || DEF_TIMEOUT
, body = ''
, finished = function() {
if (loaded) return;
loaded = 1;
clearTimeout(timer);
try { response = JSON['parse'](body); }
catch (r) { return done(1); }
success(response);
}
, done = function(failed, response) {
if (complete) return;
complete = 1;
clearTimeout(timer);
if (request) {
request.on('error', function(){});
request.on('data', function(){});
request.on('end', function(){});
request.abort && request.abort();
request = null;
}
failed && fail(response);
}
, timer = timeout( function(){done(1);} , xhrtme );
data['pnsdk'] = PNSDK;
var options = {};
var headers = {};
var payload = '';
if (mode == 'POST')
payload = decodeURIComponent(setup.url.pop());
var url = build_url( setup.url, data );
if (!ssl) ssl = (url.split('://')[0] == 'https')?true:false;
url = '/' + url.split('/').slice(3).join('/');
var origin = setup.url[0].split("//")[1]
options.hostname = proxy ? proxy.hostname : setup.url[0].split("//")[1];
options.port = proxy ? proxy.port : ssl ? 443 : 80;
options.path = proxy ? "http://" + origin + url:url;
options.headers = proxy ? { 'Host': origin }:null;
options.method = mode;
options.keepAlive= !!keepAliveAgent;
//options.agent = keepAliveAgent;
options.body = payload;
__webpack_require__(30).globalAgent.maxSockets = Infinity;
try {
request = (ssl ? https : http)['request'](options, function(response) {
response.setEncoding('utf8');
response.on( 'error', function(){done(1, body || { "error" : "Network Connection Error"})});
response.on( 'abort', function(){done(1, body || { "error" : "Network Connection Error"})});
response.on( 'data', function (chunk) {
if (chunk) body += chunk;
} );
response.on( 'end', function(){
var statusCode = response.statusCode;
switch(statusCode) {
case 401:
case 402:
case 403:
try {
response = JSON['parse'](body);
done(1,response);
}
catch (r) { return done(1, body); }
return;
default:
break;
}
finished();
});
});
request.timeout = xhrtme;
request.on( 'error', function() {
done( 1, {"error":"Network Connection Error"} );
} );
if (mode == 'POST') request.write(payload);
request.end();
} catch(e) {
done(0);
return xdr(setup);
}
return done;
}
/**
* LOCAL STORAGE
*/
var db = (function(){
var store = {};
return {
'get' : function(key) {
return store[key];
},
'set' : function( key, value ) {
store[key] = value;
}
};
})();
function crypto_obj() {
var iv = "0123456789012345";
function get_padded_key(key) {
return crypto.createHash('sha256').update(key).digest("hex").slice(0,32);
}
return {
'encrypt' : function(input, key) {
if (!key) return input;
var plain_text = JSON['stringify'](input);
var cipher = crypto.createCipheriv('aes-256-cbc', get_padded_key(key), iv);
var base_64_encrypted = cipher.update(plain_text, 'utf8', 'base64') + cipher.final('base64');
return base_64_encrypted || input;
},
'decrypt' : function(input, key) {
if (!key) return input;
var decipher = crypto.createDecipheriv('aes-256-cbc', get_padded_key(key), iv);
try {
var decrypted = decipher.update(input, 'base64', 'utf8') + decipher.final('utf8');
} catch (e) {
return null;
}
return JSON.parse(decrypted);
}
}
}
function keepAliveIsEmbedded() {
return 'EventEmitter' in http.Agent.super_;
}
var CREATE_PUBNUB = function(setup) {
proxy = setup['proxy'];
setup['xdr'] = xdr;
setup['db'] = db;
setup['error'] = setup['error'] || error;
setup['hmac_SHA256'] = get_hmac_SHA256;
setup['crypto_obj'] = crypto_obj();
setup['params'] = {'pnsdk' : PNSDK};
if (setup['keepAlive'] === false) {
keepAliveAgent = undefined;
}
SELF = function(setup) {
return CREATE_PUBNUB(setup);
}
var PN = PN_API(setup);
for (var prop in PN) {
if (PN.hasOwnProperty(prop)) {
SELF[prop] = PN[prop];
}
}
SELF.init = SELF;
SELF.secure = SELF;
SELF.ready();
return SELF;
}
CREATE_PUBNUB.init = CREATE_PUBNUB;
CREATE_PUBNUB.unique = unique
CREATE_PUBNUB.secure = CREATE_PUBNUB;
module.exports = CREATE_PUBNUB
module.exports.PNmessage = PNmessage;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 33 */
/***/ function(module, exports, __webpack_require__) {
var util = __webpack_require__(43);
// enum for type of timeout
var TYPE = {
TIMEOUT: 0,
INTERVAL: 1,
TRIGGER: 2
};
var DISCRETE = 'discrete';
/**
* Create a new hypertimer
* @param {Object} [options] The following options are available:
* rate: number | 'discrete'
* The rate of speed of hyper time with
* respect to real-time in milliseconds
* per millisecond. Rate must be a
* positive number, or 'discrete' to
* run in discrete time (jumping from
* event to event). By default, rate is 1.
* deterministic: boolean
* If true (default), simultaneous events
* are executed in a deterministic order.
*/
function hypertimer(options) {
// options
var rate = 1; // number of milliseconds per milliseconds
var deterministic = true; // run simultaneous events in a deterministic order
// properties
var running = false; // true when running
var realTime = null; // timestamp. the moment in real-time when hyperTime was set
var hyperTime = null; // timestamp. the start time in hyper-time
var timeouts = []; // array with all running timeouts
var current = {}; // the timeouts currently in progress (callback is being executed)
var timeoutId = null; // currently running timer
var idSeq = 0; // counter for unique timeout id's
// exported timer object with public functions and variables
var timer = {};
/**
* Change configuration options of the hypertimer, or retrieve current
* configuration.
* @param {Object} [options] The following options are available:
* rate: number | 'discrete'
* The rate of speed of hyper time with
* respect to real-time in milliseconds
* per millisecond. Rate must be a
* positive number, or 'discrete' to
* run in discrete time (jumping from
* event to event). By default, rate is 1.
* deterministic: boolean
* If true (default), simultaneous events
* are executed in a deterministic order.
* @return {Object} Returns the applied configuration
*/
timer.config = function(options) {
if (options) {
if ('rate' in options) {
var newRate = (options.rate === DISCRETE) ? DISCRETE : Number(options.rate);
if (newRate !== DISCRETE && (isNaN(newRate) || newRate <= 0)) {
throw new TypeError('rate must be a positive number or the string "discrete"');
}
hyperTime = timer.now();
realTime = util.systemNow();
rate = newRate;
}
if ('deterministic' in options) {
deterministic = options.deterministic ? true : false;
}
}
// reschedule running timeouts
_schedule();
// return a copy of the configuration options
return {
rate: rate,
deterministic: deterministic
};
};
/**
* Set the time of the timer. To get the current time, use getTime() or now().
* @param {number | Date} time The time in hyper-time.
*/
timer.setTime = function (time) {
if (time instanceof Date) {
hyperTime = time.valueOf();
}
else {
var newTime = Number(time);
if (isNaN(newTime)) {
throw new TypeError('time must be a Date or number');
}
hyperTime = newTime;
}
// reschedule running timeouts
_schedule();
};
/**
* Returns the current time of the timer as a number.
* See also getTime().
* @return {number} The time
*/
timer.now = function () {
if (rate === DISCRETE) {
return hyperTime;
}
else {
if (running) {
// TODO: implement performance.now() / process.hrtime(time) for high precision calculation of time interval
var realInterval = util.systemNow() - realTime;
var hyperInterval = realInterval * rate;
return hyperTime + hyperInterval;
}
else {
return hyperTime;
}
}
};
/**
* Continue the timer.
*/
timer['continue'] = function() {
realTime = util.systemNow();
running = true;
// reschedule running timeouts
_schedule();
};
/**
* Pause the timer. The timer can be continued again with `continue()`
*/
timer.pause = function() {
hyperTime = timer.now();
realTime = null;
running = false;
// reschedule running timeouts (pauses them)
_schedule();
};
/**
* Returns the current time of the timer as Date.
* See also now().
* @return {Date} The time
*/
// rename to getTime
timer.getTime = function() {
return new Date(timer.now());
};
/**
* Get the value of the hypertimer. This function returns the result of getTime().
* @return {Date} current time
*/
timer.valueOf = timer.getTime;
/**
* Return a string representation of the current hyper-time.
* @returns {string} String representation
*/
timer.toString = function () {
return timer.getTime().toString();
};
/**
* Set a timeout, which is triggered when the timeout occurs in hyper-time.
* See also setTrigger.
* @param {Function} callback Function executed when delay is exceeded.
* @param {number} delay The delay in milliseconds. When the delay is
* smaller or equal to zero, the callback is
* triggered immediately.
* @return {number} Returns a timeoutId which can be used to cancel the
* timeout using clearTimeout().
*/
timer.setTimeout = function(callback, delay) {
var id = idSeq++;
var timestamp = timer.now() + delay;
if (isNaN(timestamp)) {
throw new TypeError('delay must be a number');
}
// add a new timeout to the queue
_queueTimeout({
id: id,
type: TYPE.TIMEOUT,
time: timestamp,
callback: callback
});
// reschedule the timeouts
_schedule();
return id;
};
/**
* Set a trigger, which is triggered when the timeout occurs in hyper-time.
* See also getTimeout.
* @param {Function} callback Function executed when timeout occurs.
* @param {Date | number} time An absolute moment in time (Date) when the
* callback will be triggered. When the date is
* a Date in the past, the callback is triggered
* immediately.
* @return {number} Returns a triggerId which can be used to cancel the
* trigger using clearTrigger().
*/
timer.setTrigger = function (callback, time) {
var id = idSeq++;
var timestamp = Number(time);
if (isNaN(timestamp)) {
throw new TypeError('time must be a Date or number');
}
// add a new timeout to the queue
_queueTimeout({
id: id,
type: TYPE.TRIGGER,
time: timestamp,
callback: callback
});
// reschedule the timeouts
_schedule();
return id;
};
/**
* Trigger a callback every interval. Optionally, a start date can be provided
* to specify the first time the callback must be triggered.
* See also setTimeout and setTrigger.
* @param {Function} callback Function executed when delay is exceeded.
* @param {number} interval Interval in milliseconds. When interval
* is smaller than zero or is infinity, the
* interval will be set to zero and triggered
* with a maximum rate.
* @param {Date | number} [firstTime] An absolute moment in time (Date) when the
* callback will be triggered the first time.
* By default, firstTime = now() + interval.
* @return {number} Returns a intervalId which can be used to cancel the
* trigger using clearInterval().
*/
timer.setInterval = function(callback, interval, firstTime) {
var id = idSeq++;
var _interval = Number(interval);
if (isNaN(_interval)) {
throw new TypeError('interval must be a number');
}
if (_interval < 0 || !isFinite(_interval)) {
_interval = 0;
}
var timestamp;
if (firstTime != undefined) {
timestamp = Number(firstTime);
if (isNaN(timestamp)) {
throw new TypeError('firstTime must be a Date or number');
}
}
else {
// firstTime is undefined or null
timestamp = (timer.now() + _interval);
}
// add a new timeout to the queue
_queueTimeout({
id: id,
type: TYPE.INTERVAL,
interval: _interval,
time: timestamp,
firstTime: timestamp,
occurrence: 0,
callback: callback
});
// reschedule the timeouts
_schedule();
return id;
};
/**
* Cancel a timeout
* @param {number} timeoutId The id of a timeout
*/
timer.clearTimeout = function(timeoutId) {
// test whether timeout is currently being executed
if (current[timeoutId]) {
delete current[timeoutId];
return;
}
// find the timeout in the queue
for (var i = 0; i < timeouts.length; i++) {
if (timeouts[i].id === timeoutId) {
// remove this timeout from the queue
timeouts.splice(i, 1);
// reschedule timeouts
_schedule();
break;
}
}
};
/**
* Cancel a trigger
* @param {number} triggerId The id of a trigger
*/
timer.clearTrigger = timer.clearTimeout;
timer.clearInterval = timer.clearTimeout;
/**
* Returns a list with the id's of all timeouts
* @returns {number[]} Timeout id's
*/
timer.list = function () {
return timeouts.map(function (timeout) {
return timeout.id;
});
};
/**
* Clear all timeouts
*/
timer.clear = function () {
// empty the queue
current = {};
timeouts = [];
// reschedule
_schedule();
};
/**
* Add a timeout to the queue. After the queue has been changed, the queue
* must be rescheduled by executing _reschedule()
* @param {{id: number, type: number, time: number, callback: Function}} timeout
* @private
*/
function _queueTimeout(timeout) {
// insert the new timeout at the right place in the array, sorted by time
if (timeouts.length > 0) {
var i = timeouts.length - 1;
while (i >= 0 && timeouts[i].time > timeout.time) {
i--;
}
// insert the new timeout in the queue. Note that the timeout is
// inserted *after* existing timeouts with the exact *same* time,
// so the order in which they are executed is deterministic
timeouts.splice(i + 1, 0, timeout);
}
else {
// queue is empty, append the new timeout
timeouts.push(timeout);
}
}
/**
* Execute a timeout
* @param {{id: number, type: number, time: number, callback: function}} timeout
* @param {function} [callback]
* The callback is executed when the timeout's callback is
* finished. Called without parameters
* @private
*/
function _execTimeout(timeout, callback) {
// store the timeout in the queue with timeouts in progress
// it can be cleared when a clearTimeout is executed inside the callback
current[timeout.id] = timeout;
function finish() {
// in case of an interval we have to reschedule on next cycle
// interval must not be cleared while executing the callback
if (timeout.type === TYPE.INTERVAL && current[timeout.id]) {
timeout.occurrence++;
timeout.time = timeout.firstTime + timeout.occurrence * timeout.interval;
_queueTimeout(timeout);
}
// remove the timeout from the queue with timeouts in progress
delete current[timeout.id];
if (typeof callback === 'function') callback();
}
// execute the callback
try {
if (timeout.callback.length == 0) {
// synchronous timeout, like `timer.setTimeout(function () {...}, delay)`
timeout.callback();
finish();
} else {
// asynchronous timeout, like `timer.setTimeout(function (done) {...; done(); }, delay)`
timeout.callback(finish);
}
} catch (err) {
// silently ignore errors thrown by the callback
finish();
}
}
/**
* Remove all timeouts occurring before or on the provided time from the
* queue and return them.
* @param {number} time A timestamp
* @returns {Array} returns an array containing all expired timeouts
* @private
*/
function _getExpiredTimeouts(time) {
var i = 0;
while (i < timeouts.length && ((timeouts[i].time <= time) || !isFinite(timeouts[i].time))) {
i++;
}
var expired = timeouts.splice(0, i);
if (deterministic == false) {
// the array with expired timeouts is in deterministic order
// shuffle them
util.shuffle(expired);
}
return expired;
}
/**
* Reschedule all queued timeouts
* @private
*/
function _schedule() {
// do not _schedule when there are timeouts in progress
// this can be the case with async timeouts in discrete time.
// _schedule will be executed again when all async timeouts are finished.
if (rate === DISCRETE && Object.keys(current).length > 0) {
return;
}
var next = timeouts[0];
// cancel timer when running
if (timeoutId) {
clearTimeout(timeoutId);
timeoutId = null;
}
if (running && next) {
// schedule next timeout
var time = next.time;
var delay = time - timer.now();
var realDelay = (rate === DISCRETE) ? 0 : delay / rate;
function onTimeout() {
// when running in discrete time, update the hyperTime to the time
// of the current event
if (rate === DISCRETE) {
hyperTime = (time > hyperTime && isFinite(time)) ? time : hyperTime;
}
// grab all expired timeouts from the queue
var expired = _getExpiredTimeouts(time);
// note: expired.length can never be zero (on every change of the queue, we reschedule)
// execute all expired timeouts
if (rate === DISCRETE) {
// in discrete time, we execute all expired timeouts serially,
// and wait for their completion in order to guarantee deterministic
// order of execution
function next() {
var timeout = expired.shift();
if (timeout) {
_execTimeout(timeout, next);
}
else {
// schedule the next round
_schedule();
}
}
next();
}
else {
// in continuous time, we fire all timeouts in parallel,
// and don't await their completion (they can do async operations)
expired.forEach(_execTimeout);
// schedule the next round
_schedule();
}
}
timeoutId = setTimeout(onTimeout, Math.round(realDelay));
// Note: Math.round(realDelay) is to defeat a bug in node.js v0.10.30,
// see https://github.com/joyent/node/issues/8065
}
}
Object.defineProperty(timer, 'running', {
get: function () {
return running;
}
});
timer.config(options); // apply options
timer.setTime(util.systemNow()); // set time as current real time
timer.continue(); // start the timer
return timer;
}
module.exports = hypertimer;
/***/ },
/* 34 */
/***/ function(module, exports, __webpack_require__) {
/**
* Module dependencies.
*/
var global = (function() { return this; })();
/**
* WebSocket constructor.
*/
var WebSocket = global.WebSocket || global.MozWebSocket;
/**
* Module exports.
*/
module.exports = WebSocket ? ws : null;
/**
* WebSocket constructor.
*
* The third `opts` options object gets ignored in web browsers, since it's
* non-standard, and throws a TypeError if passed to the constructor.
* See: https://github.com/einaros/ws/issues/227
*
* @param {String} uri
* @param {Array} protocols (optional)
* @param {Object) opts (optional)
* @api public
*/
function ws(uri, protocols, opts) {
var instance;
if (protocols) {
instance = new WebSocket(uri, protocols);
} else {
instance = new WebSocket(uri);
}
return instance;
}
if (WebSocket) ws.prototype = WebSocket.prototype;
/***/ },
/* 35 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var asap = __webpack_require__(72)
module.exports = Promise;
function Promise(fn) {
if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new')
if (typeof fn !== 'function') throw new TypeError('not a function')
var state = null
var value = null
var deferreds = []
var self = this
this.then = function(onFulfilled, onRejected) {
return new self.constructor(function(resolve, reject) {
handle(new Handler(onFulfilled, onRejected, resolve, reject))
})
}
function handle(deferred) {
if (state === null) {
deferreds.push(deferred)
return
}
asap(function() {
var cb = state ? deferred.onFulfilled : deferred.onRejected
if (cb === null) {
(state ? deferred.resolve : deferred.reject)(value)
return
}
var ret
try {
ret = cb(value)
}
catch (e) {
deferred.reject(e)
return
}
deferred.resolve(ret)
})
}
function resolve(newValue) {
try { //Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.')
if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
var then = newValue.then
if (typeof then === 'function') {
doResolve(then.bind(newValue), resolve, reject)
return
}
}
state = true
value = newValue
finale()
} catch (e) { reject(e) }
}
function reject(newValue) {
state = false
value = newValue
finale()
}
function finale() {
for (var i = 0, len = deferreds.length; i < len; i++)
handle(deferreds[i])
deferreds = null
}
doResolve(fn, resolve, reject)
}
function Handler(onFulfilled, onRejected, resolve, reject){
this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null
this.onRejected = typeof onRejected === 'function' ? onRejected : null
this.resolve = resolve
this.reject = reject
}
/**
* Take a potentially misbehaving resolver function and make sure
* onFulfilled and onRejected are only called once.
*
* Makes no guarantees about asynchrony.
*/
function doResolve(fn, onFulfilled, onRejected) {
var done = false;
try {
fn(function (value) {
if (done) return
done = true
onFulfilled(value)
}, function (reason) {
if (done) return
done = true
onRejected(reason)
})
} catch (ex) {
if (done) return
done = true
onRejected(ex)
}
}
/***/ },
/* 36 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(35)
var asap = __webpack_require__(72)
module.exports = Promise
Promise.prototype.done = function (onFulfilled, onRejected) {
var self = arguments.length ? this.then.apply(this, arguments) : this
self.then(null, function (err) {
asap(function () {
throw err
})
})
}
/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
//This file contains the ES6 extensions to the core Promises/A+ API
var Promise = __webpack_require__(35)
var asap = __webpack_require__(72)
module.exports = Promise
/* Static Functions */
function ValuePromise(value) {
this.then = function (onFulfilled) {
if (typeof onFulfilled !== 'function') return this
return new Promise(function (resolve, reject) {
asap(function () {
try {
resolve(onFulfilled(value))
} catch (ex) {
reject(ex);
}
})
})
}
}
ValuePromise.prototype = Promise.prototype
var TRUE = new ValuePromise(true)
var FALSE = new ValuePromise(false)
var NULL = new ValuePromise(null)
var UNDEFINED = new ValuePromise(undefined)
var ZERO = new ValuePromise(0)
var EMPTYSTRING = new ValuePromise('')
Promise.resolve = function (value) {
if (value instanceof Promise) return value
if (value === null) return NULL
if (value === undefined) return UNDEFINED
if (value === true) return TRUE
if (value === false) return FALSE
if (value === 0) return ZERO
if (value === '') return EMPTYSTRING
if (typeof value === 'object' || typeof value === 'function') {
try {
var then = value.then
if (typeof then === 'function') {
return new Promise(then.bind(value))
}
} catch (ex) {
return new Promise(function (resolve, reject) {
reject(ex)
})
}
}
return new ValuePromise(value)
}
Promise.all = function (arr) {
var args = Array.prototype.slice.call(arr)
return new Promise(function (resolve, reject) {
if (args.length === 0) return resolve([])
var remaining = args.length
function res(i, val) {
try {
if (val && (typeof val === 'object' || typeof val === 'function')) {
var then = val.then
if (typeof then === 'function') {
then.call(val, function (val) { res(i, val) }, reject)
return
}
}
args[i] = val
if (--remaining === 0) {
resolve(args);
}
} catch (ex) {
reject(ex)
}
}
for (var i = 0; i < args.length; i++) {
res(i, args[i])
}
})
}
Promise.reject = function (value) {
return new Promise(function (resolve, reject) {
reject(value);
});
}
Promise.race = function (values) {
return new Promise(function (resolve, reject) {
values.forEach(function(value){
Promise.resolve(value).then(resolve, reject);
})
});
}
/* Prototype Methods */
Promise.prototype['catch'] = function (onRejected) {
return this.then(null, onRejected);
}
/***/ },
/* 38 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
//This file contains then/promise specific extensions that are only useful for node.js interop
var Promise = __webpack_require__(35)
var asap = __webpack_require__(72)
module.exports = Promise
/* Static Functions */
Promise.denodeify = function (fn, argumentCount) {
argumentCount = argumentCount || Infinity
return function () {
var self = this
var args = Array.prototype.slice.call(arguments)
return new Promise(function (resolve, reject) {
while (args.length && args.length > argumentCount) {
args.pop()
}
args.push(function (err, res) {
if (err) reject(err)
else resolve(res)
})
fn.apply(self, args)
})
}
}
Promise.nodeify = function (fn) {
return function () {
var args = Array.prototype.slice.call(arguments)
var callback = typeof args[args.length - 1] === 'function' ? args.pop() : null
var ctx = this
try {
return fn.apply(this, arguments).nodeify(callback, ctx)
} catch (ex) {
if (callback === null || typeof callback == 'undefined') {
return new Promise(function (resolve, reject) { reject(ex) })
} else {
asap(function () {
callback.call(ctx, ex)
})
}
}
}
}
Promise.prototype.nodeify = function (callback, ctx) {
if (typeof callback != 'function') return this
this.then(function (value) {
asap(function () {
callback.call(ctx, null, value)
})
}, function (err) {
asap(function () {
callback.call(ctx, err)
})
})
}
/***/ },
/* 39 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Babbler = __webpack_require__(49);
var Tell = __webpack_require__(56);
var Listen = __webpack_require__(57);
var Then = __webpack_require__(58);
var Decision = __webpack_require__(59);
var IIf = __webpack_require__(60);
/**
* Create a new babbler
* @param {String} id
* @return {Babbler} babbler
*/
exports.babbler = function (id) {
return new Babbler(id);
};
/**
* Create a control flow starting with a tell block
* @param {* | Function} [message] A static message or callback function
* returning a message dynamically.
* When `message` is a function, it will be
* invoked as callback(message, context),
* where `message` is the output from the
* previous block in the chain, and `context` is
* an object where state can be stored during a
* conversation.
* @return {Tell} tell
*/
exports.tell = function (message) {
return new Tell(message);
};
/**
* Send a question, listen for a response.
* Creates two blocks: Tell and Listen.
* This is equivalent of doing `babble.tell(message).listen(callback)`
* @param {* | Function} message
* @param {Function} [callback] Invoked as callback(message, context),
* where `message` is the just received message,
* and `context` is an object where state can be
* stored during a conversation. This is equivalent
* of doing `listen().then(callback)`
* @return {Block} block Last block in the created control flow
*/
exports.ask = function (message, callback) {
return exports
.tell(message)
.listen(callback);
};
/**
* Create a decision block and chain it to the current block.
*
* Syntax:
*
* decide(choices)
* decide(decision, choices)
*
* Where:
*
* {Function | Object} [decision]
* When a `decision` function is provided, the
* function is invoked as decision(message, context),
* where `message` is the output from the previous
* block in the chain, and `context` is an object
* where state can be stored during a conversation.
* The function must return the id for the next
* block in the control flow, which must be
* available in the provided `choices`.
* If `decision` is not provided, the next block
* will be mapped directly from the message.
* {Object.<String, Block>} choices
* A map with the possible next blocks in the flow
* The next block is selected by the id returned
* by the decision function.
*
* There is one special id for choices: 'default'. This id is called when either
* the decision function returns an id which does not match any of the available
* choices.
*
* @param {Function | Object} arg1 Can be {function} decision or {Object} choices
* @param {Object} [arg2] choices
* @return {Block} decision The created decision block
*/
exports.decide = function (arg1, arg2) {
// TODO: test arguments.length > 2
return new Decision(arg1, arg2);
};
/**
* Listen for a message.
*
* Optionally a callback function can be provided, which is equivalent of
* doing `listen().then(callback)`.
*
* @param {Function} [callback] Invoked as callback(message, context),
* where `message` is the just received message,
* and `context` is an object where state can be
* stored during a conversation. This is equivalent
* of doing `listen().then(callback)`
* @return {Block} Returns the created Listen block
*/
exports.listen = function(callback) {
var block = new Listen();
if (callback) {
return block.then(callback);
}
return block;
};
/**
* Create a control flow starting with a Then block
* @param {Function} callback Invoked as callback(message, context),
* where `message` is the output from the previous
* block in the chain, and `context` is an object
* where state can be stored during a conversation.
* @return {Then} then
*/
exports.then = function (callback) {
return new Then(callback);
};
/**
* IIf
* Create an iif block, which checks a condition and continues either with
* the trueBlock or the falseBlock. The input message is passed to the next
* block in the flow.
*
* Can be used as follows:
* - When `condition` evaluates true:
* - when `trueBlock` is provided, the flow continues with `trueBlock`
* - else, when there is a block connected to the IIf block, the flow continues
* with that block.
* - When `condition` evaluates false:
* - when `falseBlock` is provided, the flow continues with `falseBlock`
*
* Syntax:
*
* new IIf(condition, trueBlock)
* new IIf(condition, trueBlock [, falseBlock])
* new IIf(condition).then(...)
*
* @param {Function | RegExp | *} condition A condition returning true or false
* In case of a function,
* the function is invoked as
* `condition(message, context)` and
* must return a boolean. In case of
* a RegExp, condition will be tested
* to return true. In other cases,
* non-strict equality is tested on
* the input.
* @param {Block} [trueBlock]
* @param {Block} [falseBlock]
* @returns {Block}
*/
exports.iif = function (condition, trueBlock, falseBlock) {
return new IIf(condition, trueBlock, falseBlock);
};
// export the babbler prototype
exports.Babbler = Babbler;
// export all flow blocks
exports.block = {
Block: __webpack_require__(61),
Then: __webpack_require__(58),
Decision: __webpack_require__(59),
IIf: __webpack_require__(60),
Listen: __webpack_require__(57),
Tell: __webpack_require__(56)
};
// export messagebus interfaces
exports.messagebus = __webpack_require__(50);
/**
* Babblify an actor. The babblified actor will be extended with functions
* `ask`, `tell`, and `listen`.
*
* Babble expects that messages sent via `actor.send(to, message)` will be
* delivered by the recipient on a function `actor.receive(from, message)`.
* Babble replaces the original `receive` with a new one, which is used to
* listen for all incoming messages. Messages ignored by babble are propagated
* to the original `receive` function.
*
* The actor can be restored in its original state using `unbabblify(actor)`.
*
* @param {Object} actor The actor to be babblified. Must be an object
* containing functions `send(to, message)` and
* `receive(from, message)`.
* @param {Object} [params] Optional parameters. Can contain properties:
* - id: string The id for the babbler
* - send: string The name of an alternative
* send function available on
* the actor.
* - receive: string The name of an alternative
* receive function available
* on the actor.
* @returns {Object} Returns the babblified actor.
*/
exports.babblify = function (actor, params) {
var babblerId;
if (params && params.id !== undefined) {
babblerId = params.id;
}
else if (actor.id !== undefined) {
babblerId = actor.id
}
else {
throw new Error('Id missing. Ensure that either actor has a property "id", ' +
'or provide an id as a property in second argument params')
}
// validate actor
['ask', 'tell', 'listen'].forEach(function (prop) {
if (actor[prop] !== undefined) {
throw new Error('Conflict: actor already has a property "' + prop + '"');
}
});
var sendName = params && params.send || 'send';
if (typeof actor[sendName] !== 'function') {
throw new Error('Missing function. ' +
'Function "' + sendName + '(to, message)" expected on actor or on params');
}
// create a new babbler
var babbler = exports.babbler(babblerId);
// attach receive function to the babbler
var receiveName = params && params.receive || 'receive';
var receiveOriginal = actor.hasOwnProperty(receiveName) ? actor[receiveName] : null;
if (receiveOriginal) {
actor[receiveName] = function (from, message) {
babbler._receive(message);
receiveOriginal.call(actor, from, message);
};
}
else {
actor[receiveName] = function (from, message) {
babbler._receive(message);
};
}
// attach send function to the babbler
babbler.send = function (to, message) {
// FIXME: there should be no need to send a message on next tick
setTimeout(function () {
actor[sendName](to, message)
}, 0)
};
// attach babbler functions and properties to the actor
actor.__babbler__ = {
babbler: babbler,
receive: receiveOriginal,
receiveName: receiveName
};
actor.ask = babbler.ask.bind(babbler);
actor.tell = babbler.tell.bind(babbler);
actor.listen = babbler.listen.bind(babbler);
actor.listenOnce = babbler.listenOnce.bind(babbler);
return actor;
};
/**
* Unbabblify an actor.
* @param {Object} actor
* @return {Object} Returns the unbabblified actor.
*/
exports.unbabblify = function (actor) {
var __babbler__ = actor.__babbler__;
if (__babbler__) {
delete actor.__babbler__;
delete actor.ask;
delete actor.tell;
delete actor.listen;
delete actor.listenOnce;
delete actor[__babbler__.receiveName];
// restore any original receive method
if (__babbler__.receive) {
actor[__babbler__.receiveName] = __babbler__.receive;
}
}
return actor;
};
/***/ },
/* 40 */
/***/ function(module, exports, __webpack_require__) {
var WebSocket = __webpack_require__(76);
var WebSocketServer = __webpack_require__(76).Server;
var uuid = __webpack_require__(74);
var Promise = __webpack_require__(41);
var requestify = __webpack_require__(51);
var Peer = __webpack_require__(52);
/**
* Host
* @param {Object} [options] Available options: see Host.config
*/
function Host(options) {
var me = this;
// peers and cached peer addresses
this.peers = {}; // local peers
this.addresses = {}; // cached addresses of peers located on other hosts
// pubsub
this.channels = {}; // keys are the channels, values are arrays with callbacks of subscribers
// default options
this.options = {
reconnectTimeout: 5 * 60 * 1000, // give up reconnecting after 5 minutes
reconnectDelay: 1000, // try reconnecting after one second
reconnectDecay: 2
};
// server properties
this.server = null;
this.address = null;
this.port = null;
this.connections = {}; // List with open connections, key is the url and value is the connection
this.timers = {}; // reconnect timers
/**
* Send a message from one peer to another
* @param {string} from Id of the sending peer
* @param {string} to Id of the receiving peer
* @param {*} message JSON message
* @returns {Promise.<null, Error>} Resolves when sent
*/
this.send = function (from, to, message) {
// see if the peer lives on the same host
var peer = me.peers[to];
if (peer) {
peer.emit('message', from, message);
return Promise.resolve(null);
}
// find the remote host where the recipient is located
return me.find(to)
.then(function (url) {
var conn = me.connections[url];
if (conn) {
var request = {
method: 'send',
params: {
from: from,
to: to,
message: message
}
};
// TODO: there is a maximum callstack issue when queuing a lot of notifications
return conn.request(request) // the send request returns null
//return conn.notify(request) // the send request returns null
.catch(function (err) {
// FIXME: use a protocol for errors, use error code
if (err.toString().indexOf('Error: Peer not found') === 0) {
// this peer was deleted. Remove it from cache
delete me.addresses[to];
throw _peerNotFoundError(to);
}
})
}
else {
throw _peerUnreachable(to, url);
}
});
};
this.config(options);
}
/**
* Apply configuration options to the host, and/or retrieve the current
* configuration.
* @param {Object} [options] Available options:
* - networkId An id for the distribus
* network. A Host can only
* connect to other hosts with
* the same id. networkId cannot
* be changed once set.
* - reconnectTimeout Timeout in milliseconds for
* giving up reconnecting.
* 5 minutes by default
* - reconnectDelay Initial delay for trying to
* reconnect. for consecutive
* reconnect trials, the delay
* decays with a factor
* `reconnectDecay`.
* 1 second by default.
* - reconnectDecay Decay for the reconnect
* delay. 2 by default.
* @return {Object} Returns the current configuration
*/
Host.prototype.config = function (options) {
// apply new options
if (options) {
_merge(this.options, options);
// apply networkId
if (options.networkId) {
if (this.networkId !== null) {
this.networkId = options.networkId;
}
else {
throw new Error('Cannot replace networkId once set');
}
}
}
// return a copy of the options
return _merge({}, this.options);
};
/**
* Create a new peer.
* Throws an error when a peer with the same id already exists on this host.
* Does not check whether this id exists on any remote host (use Host.find(id)
* to validate this before creating a peer, or even better, use a uuid to
* prevent id collisions).
* @param {string} id The id for the new peer
* @return {Peer} Returns the created peer
*/
Host.prototype.create = function (id) {
if (id in this.peers) {
throw new Error('Id already exists (id: ' + id +')');
}
var peer = new Peer(id, this.send);
this.peers[id] = peer;
return peer;
};
/**
* Remove a peer from the host
* @param {Peer | string} peer A peer or the id of a peer
*/
Host.prototype.remove = function (peer) {
if (peer instanceof Peer) { // a peer instance
delete this.peers[peer.id];
}
else if (peer) { // a string with the peers id
delete this.peers[peer];
}
};
/**
* Get a local peer by its id
* @param {string} id The id of an existing peer
* @return {Peer | null} returns the peer, or returns null when not existing.
*/
Host.prototype.get = function (id) {
return this.peers[id] || null;
};
/**
* Find the host of a peer by it's id
* @param {string} id Id of a peer
* @return {Promise.<string | null, Error>} The url of the peers host.
* Returns null if the found host has no url.
* Throws an error if not found.
*/
Host.prototype.find = function (id) {
var me = this;
// check if this is a local peer
if (id in me.peers) {
return Promise.resolve(me.url || null);
}
// check if this id is already in cache
var url = me.addresses[id];
if (url) {
// yes, we already have the address
return Promise.resolve(url);
}
// search on other hosts
return new Promise(function (resolve, reject) {
// TODO: send requests in small batches, not all at once
// send a find request to a host
var found = false;
function _find(url) {
var conn = me.connections[url];
return conn.request({method: 'find', params: {id: id}})
.then(function (url) {
if (url && !found) {
// we found the peer
found = true;
// put this address in cache
// TODO: limit the number of cached addresses. When exceeding the limit, store on disk in a temporary db
me.addresses[id] = url;
// return the found url
resolve(url);
}
});
}
// ask all connected hosts if they host this peer
var results = Object.keys(me.connections).map(_find);
// if all requests are finished and the peer is not found, reject with an error
Promise.all(results)
.then(function () {
if (!found || results.length == 0) {
reject(_peerNotFoundError(id));
}
});
});
};
/**
* Start listening on a socket.
* @param {string} address
* @param {number} port
* @return {Promise.<Host, Error>} Returns itself when connected
*/
Host.prototype.listen = function (address, port) {
var me = this;
return new Promise(function (resolve, reject) {
if (me.server) {
reject(new Error('Server already listening'));
return;
}
me.server = new WebSocketServer({port: port}, function () {
me.address = address;
me.port = port;
me.url = 'ws://' + address + ':' + port;
resolve(me);
});
me.server.on('connection', function (conn) {
conn = requestify(conn);
conn.onerror = function (err) {
// TODO: what to do with errors?
};
conn.onclose = function () {
// remove this connection from the connections list
// (we do not yet forget the cached peers)
var url = me._findUrl(conn);
delete me.connections[url];
me.timers[url] = setTimeout(function () {
delete me.timers[url];
// clear cache
me._forgetPeers(url);
}, me.options.reconnectTimeout);
};
conn.onrequest = function (request) {
return me._onRequest(conn, request);
};
});
me.server.on('error', function (err) {
reject(err)
});
});
};
/**
* Handle a request
* @param {WebSocket} conn
* @param {Object} request
* @returns {Promise}
* @private
*/
Host.prototype._onRequest = function (conn, request) {
var me = this;
var url;
switch (request.method) {
case 'greeting':
url = request.params && request.params.url;
var networkId = request.params.networkId || null;
if (networkId === null || networkId === me.networkId) {
if (url && !(url in this.connections)) {
this.connections[url] = conn;
return this._broadcastJoin(url)
.then(function () {
return Promise.resolve({networkId: me.networkId})
});
}
else {
return Promise.resolve({networkId: me.networkId});
}
}
else {
return Promise.reject(new Error('Network id mismatch (' + networkId + ' !== ' + me.networkId + ')'));
}
case 'join':
url = request.params && request.params.url;
return this.join(url)
.then(function (host) {
return Promise.resolve();
});
case 'goodbye':
url = this._findUrl(conn);
this._forgetPeers(url);
this._disconnect(url);
return Promise.resolve('goodbye');
case 'hosts':
// connect to all newly retrieved urls
if (request.params && request.params.urls) {
this.join(request.params.urls);
}
// return a list with the urls of all known hosts
return Promise.resolve(Object.keys(this.connections));
case 'find': // find a peer
var id = request.params && request.params.id;
return Promise.resolve(this.peers[id] ? this.url : null);
case 'send':
var from = request.params && request.params.from;
var to = request.params && request.params.to;
var message = request.params && request.params.message;
// TODO: validate whether all parameters are there
var peer = this.peers[to];
if (peer) {
peer.emit('message', from, message);
return Promise.resolve(null);
}
else {
return Promise.reject(_peerNotFoundError(to).toString());
}
case 'publish':
var channel = request.params && request.params.channel;
var message = request.params && request.params.message;
this._publish(channel, message);
return Promise.resolve({
result: null,
error: null
});
case 'ping':
return Promise.resolve({
result: request.params,
error: null
});
default:
return Promise.reject('Unknown method "' + request.method + '"');
}
};
/**
* Find an url from a connection
* @param {WebSocket} conn
* @return {String | null} url
* @private
*/
Host.prototype._findUrl = function (conn) {
// search by instance
for (var url in this.connections) {
if (this.connections.hasOwnProperty(url) && this.connections[url] === conn) {
return url;
}
}
return null;
};
/**
* Remove all cached peers of given
* @param {string} url Url of a host for which to forget the cached peers
* @private
*/
Host.prototype._forgetPeers = function (url) {
// remove all cached peers
for (var id in this.addresses) {
if (this.addresses.hasOwnProperty(id) && this.addresses[id] === url) {
delete this.addresses[id];
}
}
};
/**
* Join an other Host.
* A host can only join another host when having the same id, or having no id
* defined. In the latter case, the host will orphan the id of the host it
* connects to.
* @param {string} url For example 'ws://localhost:3000'
* @return {Promise.<Host, Error>} Returns itself when joined
*/
Host.prototype.join = function (url) {
var me = this;
if (url && !(url in me.connections)) {
return me._connect(url)
.then(function () {
// broadcast the join request to all known hosts
return me._broadcastJoin(url);
})
.then(function (urls) {
// return the host itself as last result in the promise chain
return me;
});
// TODO: handle connection error
}
else {
// already known url. ignore this join
// FIXME: it is possible that this connection is still being established
return Promise.resolve(me);
}
};
/**
* Open a connection to an other host and add the host to the list of connected
* hosts.
* @param {String} url
* @returns {Promise.<WebSocket, Error>} Returns the established connection
* @private
*/
Host.prototype._connect = function(url) {
var me = this;
return new Promise(function (resolve, reject) {
// open a web socket
var conn = new WebSocket(url);
requestify(conn);
me.connections[url] = conn;
conn.onrequest = function (request) {
return me._onRequest(conn, request);
};
conn.onclose = function () {
if (me.connections[url]) {
// remove the connection from the list
delete me.connections[url];
// schedule reconnection
me._reconnect(url);
}
};
conn.onopen = function () {
// send a greeting with the hosts url
conn.request({method: 'greeting', params: { url: me.url, networkId: me.networkId } })
.then(function (params) {
me.networkId = params.networkId;
resolve(conn);
})
.catch(function (err) {
// greeting rejected
delete me.connections[url];
conn.close();
reject(err);
});
};
conn.onerror = function (err) {
delete me.connections[url];
reject(err);
conn.close();
};
});
};
/**
* Reconnect with a host
* @param {String} url Url of the host to which to reconnect
* @private
*/
Host.prototype._reconnect = function (url) {
var me = this;
var start = new Date().valueOf();
function scheduleReconnect(delay, trial) {
me.timers[url] = setTimeout(function () {
delete me.timers[url];
var now = new Date().valueOf();
if (now - start < me.options.reconnectTimeout) {
// reconnect
me._connect(url)
.catch(function (err) {
// schedule next reconnect trial
scheduleReconnect(delay / me.options.reconnectDecay, trial + 1);
});
}
else {
// give up trying to reconnect
me._forgetPeers(url);
}
}, delay);
}
// schedule reconnection after a delay
scheduleReconnect(me.options.reconnectDelay, 0);
};
/**
* Forward a join message to all known hosts
* @param {string} url For example 'ws://localhost:3000'
* @return {Promise.<String[], Error>} returns the joined urls
*/
Host.prototype._broadcastJoin = function (url) {
// TODO: implement a more efficient broadcast mechanism
var me = this;
var urls = Object.keys(me.connections)
.filter(function (u) {
return u !== url
});
function join (existingUrl) {
var conn = me.connections[existingUrl];
return conn.request({method: 'join', params: {'url': url}})
.catch(function (err) {
// TODO: what to do with failed requests? Right now we ignore them
})
.then(function () {
// return the url where the join is broadcasted to
return existingUrl;
})
}
// send a join request to all known hosts
return Promise.all(urls.map(join));
};
/**
* Stop listening on currently a socket
* @return {Promise.<Host, Error>} Returns itself
*/
Host.prototype.close = function () {
var me = this;
// TODO: create a flag while closing? and opening?
if (this.server) {
// close the host, and clean up cache
function closeHost() {
// close the host itself
me.addresses = {};
if (me.server) {
me.server.close();
me.server = null;
me.address = null;
me.port = null;
me.url = null;
}
return me;
}
// close all connections
var urls = Object.keys(this.connections);
return Promise.all(urls.map(function (url) {
return me._disconnect(url);
})).then(closeHost);
}
else {
// no socket open. resolve immediately
Promise.resolve(this);
}
};
/**
* Close the connection with a host. Note: peers are not removed from cache
* @param {string} url Url of a connected host
* @return {Promise.<undefined, Error>} Resolves a promise when closed
* @private
*/
Host.prototype._disconnect = function (url) {
var conn = this.connections[url];
if (conn) {
delete this.connections[url];
if (this.timers[url]) {
clearTimeout(this.timers[url]);
delete this.timers[url];
}
// send a goodbye message
return conn.request({method: 'goodbye'})
.catch(function (err) {
// ignore failing to send goodbye
})
// then close the connection
.then(function () {
conn.close();
});
}
else {
Promise.resolve();
}
};
/**
* Publish a message via a channel. All listeners subscribed to this channel
* will be triggered, both listeners on this host as well as connected hosts.
* @param {string} channel The name of the channel
* @param {*} message A message, can be any type. Must be serializable JSON.
*/
Host.prototype.publish = function (channel, message) {
// trigger local subscribers
this._publish(channel, message);
// send the message to all connected hosts
for (var url in this.connections) {
if (this.connections.hasOwnProperty(url)) {
var connection = this.connections[url];
connection.notify({
method: 'publish',
params: {
channel: channel,
message: message
}
});
}
}
// TODO: improve efficiency by having the hosts share the channels for which
// they have subscribers, so we only have to send a message to a
// particular host when it has subscribers to the channel.
};
/**
* Publish a channel to all subscribers on this host.
* @param {string} channel The name of the channel
* @param {*} message A message, can be any type. Must be serializable JSON.
* @private
*/
Host.prototype._publish = function (channel, message) {
// trigger local subscribers
var callbacks = this.channels[channel];
if (callbacks) {
callbacks.forEach(function (callback) {
callback(message);
});
}
};
/**
* Subscribe to a channel.
* @param {string} channel The name of the channel
* @param {function} callback Called as callback(message)
*/
Host.prototype.subscribe = function (channel, callback) {
// TODO: implement support for wildcards, like subscribing to "foo.*" or something like that
var callbacks = this.channels[channel];
if (!callbacks) {
callbacks = [];
this.channels[channel] = callbacks;
}
callbacks.push(callback);
};
/**
* Unsubscribe from a channel.
* @param {string} channel The name of the channel
* @param {function} callback A callback used before to subscribe
*/
Host.prototype.unsubscribe = function (channel, callback) {
var callbacks = this.channels[channel];
if (callbacks) {
var index = callbacks.indexOf(callback);
if (index !== -1) {
callbacks.splice(index, 1);
if (callbacks.length === 0) {
delete this.channels[channel];
}
}
}
};
/**
* Merge object b into object a: copy all properties of b to a
* @param {Object} a
* @param {Object} b
* @return {Object} returns the merged a
* @private
*/
function _merge (a, b) {
for (var prop in b) {
if (b.hasOwnProperty(prop)) {
a[prop] = b[prop];
}
}
return a;
}
/**
* Create an Error "Peer not found"
* @param {string} id The id of the peer
* @return {Error}
* @private
*/
function _peerNotFoundError(id) {
return new Error('Peer not found (id: ' + id + ')');
}
/**
* Create an Error "Peer unreachable"
* @param {string} id The id of the peer
* @param {string} url Url of the peers host
* @return {Error}
* @private
*/
function _peerUnreachable(id, url) {
return new Error('Peer unreachable (id: ' + id + ', url: ' + url + ')');
}
// TODO: implement a function list() which returns the id's of all peers in the system
module.exports = Host;
/***/ },
/* 41 */
/***/ function(module, exports, __webpack_require__) {
// Return a promise implementation.
module.exports = __webpack_require__(77);
/***/ },
/* 42 */
/***/ function(module, exports, __webpack_require__) {
var Stream = __webpack_require__(64);
var Response = __webpack_require__(53);
var Base64 = __webpack_require__(70);
var inherits = __webpack_require__(71);
var Request = module.exports = function (xhr, params) {
var self = this;
self.writable = true;
self.xhr = xhr;
self.body = [];
self.uri = (params.protocol || 'http:') + '//'
+ params.host
+ (params.port ? ':' + params.port : '')
+ (params.path || '/')
;
if (typeof params.withCredentials === 'undefined') {
params.withCredentials = true;
}
try { xhr.withCredentials = params.withCredentials }
catch (e) {}
if (params.responseType) try { xhr.responseType = params.responseType }
catch (e) {}
xhr.open(
params.method || 'GET',
self.uri,
true
);
xhr.onerror = function(event) {
self.emit('error', new Error('Network error'));
};
self._headers = {};
if (params.headers) {
var keys = objectKeys(params.headers);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (!self.isSafeRequestHeader(key)) continue;
var value = params.headers[key];
self.setHeader(key, value);
}
}
if (params.auth) {
//basic auth
this.setHeader('Authorization', 'Basic ' + Base64.btoa(params.auth));
}
var res = new Response;
res.on('close', function () {
self.emit('close');
});
res.on('ready', function () {
self.emit('response', res);
});
res.on('error', function (err) {
self.emit('error', err);
});
xhr.onreadystatechange = function () {
// Fix for IE9 bug
// SCRIPT575: Could not complete the operation due to error c00c023f
// It happens when a request is aborted, calling the success callback anyway with readyState === 4
if (xhr.__aborted) return;
res.handle(xhr);
};
};
inherits(Request, Stream);
Request.prototype.setHeader = function (key, value) {
this._headers[key.toLowerCase()] = value
};
Request.prototype.getHeader = function (key) {
return this._headers[key.toLowerCase()]
};
Request.prototype.removeHeader = function (key) {
delete this._headers[key.toLowerCase()]
};
Request.prototype.write = function (s) {
this.body.push(s);
};
Request.prototype.destroy = function (s) {
this.xhr.__aborted = true;
this.xhr.abort();
this.emit('close');
};
Request.prototype.end = function (s) {
if (s !== undefined) this.body.push(s);
var keys = objectKeys(this._headers);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var value = this._headers[key];
if (isArray(value)) {
for (var j = 0; j < value.length; j++) {
this.xhr.setRequestHeader(key, value[j]);
}
}
else this.xhr.setRequestHeader(key, value)
}
if (this.body.length === 0) {
this.xhr.send('');
}
else if (typeof this.body[0] === 'string') {
this.xhr.send(this.body.join(''));
}
else if (isArray(this.body[0])) {
var body = [];
for (var i = 0; i < this.body.length; i++) {
body.push.apply(body, this.body[i]);
}
this.xhr.send(body);
}
else if (/Array/.test(Object.prototype.toString.call(this.body[0]))) {
var len = 0;
for (var i = 0; i < this.body.length; i++) {
len += this.body[i].length;
}
var body = new(this.body[0].constructor)(len);
var k = 0;
for (var i = 0; i < this.body.length; i++) {
var b = this.body[i];
for (var j = 0; j < b.length; j++) {
body[k++] = b[j];
}
}
this.xhr.send(body);
}
else if (isXHR2Compatible(this.body[0])) {
this.xhr.send(this.body[0]);
}
else {
var body = '';
for (var i = 0; i < this.body.length; i++) {
body += this.body[i].toString();
}
this.xhr.send(body);
}
};
// Taken from http://dxr.mozilla.org/mozilla/mozilla-central/content/base/src/nsXMLHttpRequest.cpp.html
Request.unsafeHeaders = [
"accept-charset",
"accept-encoding",
"access-control-request-headers",
"access-control-request-method",
"connection",
"content-length",
"cookie",
"cookie2",
"content-transfer-encoding",
"date",
"expect",
"host",
"keep-alive",
"origin",
"referer",
"te",
"trailer",
"transfer-encoding",
"upgrade",
"user-agent",
"via"
];
Request.prototype.isSafeRequestHeader = function (headerName) {
if (!headerName) return false;
return indexOf(Request.unsafeHeaders, headerName.toLowerCase()) === -1;
};
var objectKeys = Object.keys || function (obj) {
var keys = [];
for (var key in obj) keys.push(key);
return keys;
};
var isArray = Array.isArray || function (xs) {
return Object.prototype.toString.call(xs) === '[object Array]';
};
var indexOf = function (xs, x) {
if (xs.indexOf) return xs.indexOf(x);
for (var i = 0; i < xs.length; i++) {
if (xs[i] === x) return i;
}
return -1;
};
var isXHR2Compatible = function (obj) {
if (typeof Blob !== 'undefined' && obj instanceof Blob) return true;
if (typeof ArrayBuffer !== 'undefined' && obj instanceof ArrayBuffer) return true;
if (typeof FormData !== 'undefined' && obj instanceof FormData) return true;
};
/***/ },
/* 43 */
/***/ function(module, exports, __webpack_require__) {
/* istanbul ignore else */
if (typeof Date.now === 'function') {
/**
* Helper function to get the current time
* @return {number} Current time
*/
exports.systemNow = function () {
return Date.now();
}
}
else {
/**
* Helper function to get the current time
* @return {number} Current time
*/
exports.systemNow = function () {
return new Date().valueOf();
}
}
/**
* Shuffle an array
*
* + Jonas Raoni Soares Silva
* @ http://jsfromhell.com/array/shuffle [v1.0]
*
* @param {Array} o Array to be shuffled
* @returns {Array} Returns the shuffled array
*/
exports.shuffle = function (o){
for(var j, x, i = o.length; i; j = Math.floor(Math.random() * i), x = o[--i], o[i] = o[j], o[j] = x);
return o;
};
/***/ },
/* 44 */
/***/ function(module, exports, __webpack_require__) {
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
function EventEmitter() {
this._events = this._events || {};
this._maxListeners = this._maxListeners || undefined;
}
module.exports = EventEmitter;
// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;
// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
EventEmitter.defaultMaxListeners = 10;
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function(n) {
if (!isNumber(n) || n < 0 || isNaN(n))
throw TypeError('n must be a positive number');
this._maxListeners = n;
return this;
};
EventEmitter.prototype.emit = function(type) {
var er, handler, len, args, i, listeners;
if (!this._events)
this._events = {};
// If there is no 'error' event listener then throw.
if (type === 'error') {
if (!this._events.error ||
(isObject(this._events.error) && !this._events.error.length)) {
er = arguments[1];
if (er instanceof Error) {
throw er; // Unhandled 'error' event
}
throw TypeError('Uncaught, unspecified "error" event.');
}
}
handler = this._events[type];
if (isUndefined(handler))
return false;
if (isFunction(handler)) {
switch (arguments.length) {
// fast cases
case 1:
handler.call(this);
break;
case 2:
handler.call(this, arguments[1]);
break;
case 3:
handler.call(this, arguments[1], arguments[2]);
break;
// slower
default:
len = arguments.length;
args = new Array(len - 1);
for (i = 1; i < len; i++)
args[i - 1] = arguments[i];
handler.apply(this, args);
}
} else if (isObject(handler)) {
len = arguments.length;
args = new Array(len - 1);
for (i = 1; i < len; i++)
args[i - 1] = arguments[i];
listeners = handler.slice();
len = listeners.length;
for (i = 0; i < len; i++)
listeners[i].apply(this, args);
}
return true;
};
EventEmitter.prototype.addListener = function(type, listener) {
var m;
if (!isFunction(listener))
throw TypeError('listener must be a function');
if (!this._events)
this._events = {};
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (this._events.newListener)
this.emit('newListener', type,
isFunction(listener.listener) ?
listener.listener : listener);
if (!this._events[type])
// Optimize the case of one listener. Don't need the extra array object.
this._events[type] = listener;
else if (isObject(this._events[type]))
// If we've already got an array, just append.
this._events[type].push(listener);
else
// Adding the second element, need to change to array.
this._events[type] = [this._events[type], listener];
// Check for listener leak
if (isObject(this._events[type]) && !this._events[type].warned) {
var m;
if (!isUndefined(this._maxListeners)) {
m = this._maxListeners;
} else {
m = EventEmitter.defaultMaxListeners;
}
if (m && m > 0 && this._events[type].length > m) {
this._events[type].warned = true;
console.error('(node) warning: possible EventEmitter memory ' +
'leak detected. %d listeners added. ' +
'Use emitter.setMaxListeners() to increase limit.',
this._events[type].length);
if (typeof console.trace === 'function') {
// not supported in IE 10
console.trace();
}
}
}
return this;
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.once = function(type, listener) {
if (!isFunction(listener))
throw TypeError('listener must be a function');
var fired = false;
function g() {
this.removeListener(type, g);
if (!fired) {
fired = true;
listener.apply(this, arguments);
}
}
g.listener = listener;
this.on(type, g);
return this;
};
// emits a 'removeListener' event iff the listener was removed
EventEmitter.prototype.removeListener = function(type, listener) {
var list, position, length, i;
if (!isFunction(listener))
throw TypeError('listener must be a function');
if (!this._events || !this._events[type])
return this;
list = this._events[type];
length = list.length;
position = -1;
if (list === listener ||
(isFunction(list.listener) && list.listener === listener)) {
delete this._events[type];
if (this._events.removeListener)
this.emit('removeListener', type, listener);
} else if (isObject(list)) {
for (i = length; i-- > 0;) {
if (list[i] === listener ||
(list[i].listener && list[i].listener === listener)) {
position = i;
break;
}
}
if (position < 0)
return this;
if (list.length === 1) {
list.length = 0;
delete this._events[type];
} else {
list.splice(position, 1);
}
if (this._events.removeListener)
this.emit('removeListener', type, listener);
}
return this;
};
EventEmitter.prototype.removeAllListeners = function(type) {
var key, listeners;
if (!this._events)
return this;
// not listening for removeListener, no need to emit
if (!this._events.removeListener) {
if (arguments.length === 0)
this._events = {};
else if (this._events[type])
delete this._events[type];
return this;
}
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
for (key in this._events) {
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = {};
return this;
}
listeners = this._events[type];
if (isFunction(listeners)) {
this.removeListener(type, listeners);
} else {
// LIFO order
while (listeners.length)
this.removeListener(type, listeners[listeners.length - 1]);
}
delete this._events[type];
return this;
};
EventEmitter.prototype.listeners = function(type) {
var ret;
if (!this._events || !this._events[type])
ret = [];
else if (isFunction(this._events[type]))
ret = [this._events[type]];
else
ret = this._events[type].slice();
return ret;
};
EventEmitter.listenerCount = function(emitter, type) {
var ret;
if (!emitter._events || !emitter._events[type])
ret = 0;
else if (isFunction(emitter._events[type]))
ret = 1;
else
ret = emitter._events[type].length;
return ret;
};
function isFunction(arg) {
return typeof arg === 'function';
}
function isNumber(arg) {
return typeof arg === 'number';
}
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
function isUndefined(arg) {
return arg === void 0;
}
/***/ },
/* 45 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
exports.decode = exports.parse = __webpack_require__(62);
exports.encode = exports.stringify = __webpack_require__(63);
/***/ },
/* 46 */
/***/ function(module, exports, __webpack_require__) {
var http = __webpack_require__(30);
var https = module.exports;
for (var key in http) {
if (http.hasOwnProperty(key)) https[key] = http[key];
};
https.request = function (params, cb) {
if (!params) params = {};
params.scheme = 'https';
return http.request.call(this, params, cb);
}
/***/ },
/* 47 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
* @license MIT
*/
var base64 = __webpack_require__(87)
var ieee754 = __webpack_require__(80)
var isArray = __webpack_require__(81)
exports.Buffer = Buffer
exports.SlowBuffer = Buffer
exports.INSPECT_MAX_BYTES = 50
Buffer.poolSize = 8192 // not used by this implementation
var kMaxLength = 0x3fffffff
/**
* If `Buffer.TYPED_ARRAY_SUPPORT`:
* === true Use Uint8Array implementation (fastest)
* === false Use Object implementation (most compatible, even IE6)
*
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
* Opera 11.6+, iOS 4.2+.
*
* Note:
*
* - Implementation must support adding new properties to `Uint8Array` instances.
* Firefox 4-29 lacked support, fixed in Firefox 30+.
* See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
*
* - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
*
* - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
* incorrect length in some situations.
*
* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they will
* get the Object implementation, which is slower but will work correctly.
*/
Buffer.TYPED_ARRAY_SUPPORT = (function () {
try {
var buf = new ArrayBuffer(0)
var arr = new Uint8Array(buf)
arr.foo = function () { return 42 }
return 42 === arr.foo() && // typed array instances can be augmented
typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
new Uint8Array(1).subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
} catch (e) {
return false
}
})()
/**
* Class: Buffer
* =============
*
* The Buffer constructor returns instances of `Uint8Array` that are augmented
* with function properties for all the node `Buffer` API functions. We use
* `Uint8Array` so that square bracket notation works as expected -- it returns
* a single octet.
*
* By augmenting the instances, we can avoid modifying the `Uint8Array`
* prototype.
*/
function Buffer (subject, encoding, noZero) {
if (!(this instanceof Buffer))
return new Buffer(subject, encoding, noZero)
var type = typeof subject
// Find the length
var length
if (type === 'number')
length = subject > 0 ? subject >>> 0 : 0
else if (type === 'string') {
if (encoding === 'base64')
subject = base64clean(subject)
length = Buffer.byteLength(subject, encoding)
} else if (type === 'object' && subject !== null) { // assume object is array-like
if (subject.type === 'Buffer' && isArray(subject.data))
subject = subject.data
length = +subject.length > 0 ? Math.floor(+subject.length) : 0
} else
throw new TypeError('must start with number, buffer, array or string')
if (this.length > kMaxLength)
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
'size: 0x' + kMaxLength.toString(16) + ' bytes')
var buf
if (Buffer.TYPED_ARRAY_SUPPORT) {
// Preferred: Return an augmented `Uint8Array` instance for best performance
buf = Buffer._augment(new Uint8Array(length))
} else {
// Fallback: Return THIS instance of Buffer (created by `new`)
buf = this
buf.length = length
buf._isBuffer = true
}
var i
if (Buffer.TYPED_ARRAY_SUPPORT && typeof subject.byteLength === 'number') {
// Speed optimization -- use set if we're copying from a typed array
buf._set(subject)
} else if (isArrayish(subject)) {
// Treat array-ish objects as a byte array
if (Buffer.isBuffer(subject)) {
for (i = 0; i < length; i++)
buf[i] = subject.readUInt8(i)
} else {
for (i = 0; i < length; i++)
buf[i] = ((subject[i] % 256) + 256) % 256
}
} else if (type === 'string') {
buf.write(subject, 0, encoding)
} else if (type === 'number' && !Buffer.TYPED_ARRAY_SUPPORT && !noZero) {
for (i = 0; i < length; i++) {
buf[i] = 0
}
}
return buf
}
Buffer.isBuffer = function (b) {
return !!(b != null && b._isBuffer)
}
Buffer.compare = function (a, b) {
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b))
throw new TypeError('Arguments must be Buffers')
var x = a.length
var y = b.length
for (var i = 0, len = Math.min(x, y); i < len && a[i] === b[i]; i++) {}
if (i !== len) {
x = a[i]
y = b[i]
}
if (x < y) return -1
if (y < x) return 1
return 0
}
Buffer.isEncoding = function (encoding) {
switch (String(encoding).toLowerCase()) {
case 'hex':
case 'utf8':
case 'utf-8':
case 'ascii':
case 'binary':
case 'base64':
case 'raw':
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return true
default:
return false
}
}
Buffer.concat = function (list, totalLength) {
if (!isArray(list)) throw new TypeError('Usage: Buffer.concat(list[, length])')
if (list.length === 0) {
return new Buffer(0)
} else if (list.length === 1) {
return list[0]
}
var i
if (totalLength === undefined) {
totalLength = 0
for (i = 0; i < list.length; i++) {
totalLength += list[i].length
}
}
var buf = new Buffer(totalLength)
var pos = 0
for (i = 0; i < list.length; i++) {
var item = list[i]
item.copy(buf, pos)
pos += item.length
}
return buf
}
Buffer.byteLength = function (str, encoding) {
var ret
str = str + ''
switch (encoding || 'utf8') {
case 'ascii':
case 'binary':
case 'raw':
ret = str.length
break
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
ret = str.length * 2
break
case 'hex':
ret = str.length >>> 1
break
case 'utf8':
case 'utf-8':
ret = utf8ToBytes(str).length
break
case 'base64':
ret = base64ToBytes(str).length
break
default:
ret = str.length
}
return ret
}
// pre-set for values that may exist in the future
Buffer.prototype.length = undefined
Buffer.prototype.parent = undefined
// toString(encoding, start=0, end=buffer.length)
Buffer.prototype.toString = function (encoding, start, end) {
var loweredCase = false
start = start >>> 0
end = end === undefined || end === Infinity ? this.length : end >>> 0
if (!encoding) encoding = 'utf8'
if (start < 0) start = 0
if (end > this.length) end = this.length
if (end <= start) return ''
while (true) {
switch (encoding) {
case 'hex':
return hexSlice(this, start, end)
case 'utf8':
case 'utf-8':
return utf8Slice(this, start, end)
case 'ascii':
return asciiSlice(this, start, end)
case 'binary':
return binarySlice(this, start, end)
case 'base64':
return base64Slice(this, start, end)
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return utf16leSlice(this, start, end)
default:
if (loweredCase)
throw new TypeError('Unknown encoding: ' + encoding)
encoding = (encoding + '').toLowerCase()
loweredCase = true
}
}
}
Buffer.prototype.equals = function (b) {
if(!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
return Buffer.compare(this, b) === 0
}
Buffer.prototype.inspect = function () {
var str = ''
var max = exports.INSPECT_MAX_BYTES
if (this.length > 0) {
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
if (this.length > max)
str += ' ... '
}
return '<Buffer ' + str + '>'
}
Buffer.prototype.compare = function (b) {
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
return Buffer.compare(this, b)
}
// `get` will be removed in Node 0.13+
Buffer.prototype.get = function (offset) {
console.log('.get() is deprecated. Access using array indexes instead.')
return this.readUInt8(offset)
}
// `set` will be removed in Node 0.13+
Buffer.prototype.set = function (v, offset) {
console.log('.set() is deprecated. Access using array indexes instead.')
return this.writeUInt8(v, offset)
}
function hexWrite (buf, string, offset, length) {
offset = Number(offset) || 0
var remaining = buf.length - offset
if (!length) {
length = remaining
} else {
length = Number(length)
if (length > remaining) {
length = remaining
}
}
// must be an even number of digits
var strLen = string.length
if (strLen % 2 !== 0) throw new Error('Invalid hex string')
if (length > strLen / 2) {
length = strLen / 2
}
for (var i = 0; i < length; i++) {
var byte = parseInt(string.substr(i * 2, 2), 16)
if (isNaN(byte)) throw new Error('Invalid hex string')
buf[offset + i] = byte
}
return i
}
function utf8Write (buf, string, offset, length) {
var charsWritten = blitBuffer(utf8ToBytes(string), buf, offset, length)
return charsWritten
}
function asciiWrite (buf, string, offset, length) {
var charsWritten = blitBuffer(asciiToBytes(string), buf, offset, length)
return charsWritten
}
function binaryWrite (buf, string, offset, length) {
return asciiWrite(buf, string, offset, length)
}
function base64Write (buf, string, offset, length) {
var charsWritten = blitBuffer(base64ToBytes(string), buf, offset, length)
return charsWritten
}
function utf16leWrite (buf, string, offset, length) {
var charsWritten = blitBuffer(utf16leToBytes(string), buf, offset, length)
return charsWritten
}
Buffer.prototype.write = function (string, offset, length, encoding) {
// Support both (string, offset, length, encoding)
// and the legacy (string, encoding, offset, length)
if (isFinite(offset)) {
if (!isFinite(length)) {
encoding = length
length = undefined
}
} else { // legacy
var swap = encoding
encoding = offset
offset = length
length = swap
}
offset = Number(offset) || 0
var remaining = this.length - offset
if (!length) {
length = remaining
} else {
length = Number(length)
if (length > remaining) {
length = remaining
}
}
encoding = String(encoding || 'utf8').toLowerCase()
var ret
switch (encoding) {
case 'hex':
ret = hexWrite(this, string, offset, length)
break
case 'utf8':
case 'utf-8':
ret = utf8Write(this, string, offset, length)
break
case 'ascii':
ret = asciiWrite(this, string, offset, length)
break
case 'binary':
ret = binaryWrite(this, string, offset, length)
break
case 'base64':
ret = base64Write(this, string, offset, length)
break
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
ret = utf16leWrite(this, string, offset, length)
break
default:
throw new TypeError('Unknown encoding: ' + encoding)
}
return ret
}
Buffer.prototype.toJSON = function () {
return {
type: 'Buffer',
data: Array.prototype.slice.call(this._arr || this, 0)
}
}
function base64Slice (buf, start, end) {
if (start === 0 && end === buf.length) {
return base64.fromByteArray(buf)
} else {
return base64.fromByteArray(buf.slice(start, end))
}
}
function utf8Slice (buf, start, end) {
var res = ''
var tmp = ''
end = Math.min(buf.length, end)
for (var i = start; i < end; i++) {
if (buf[i] <= 0x7F) {
res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])
tmp = ''
} else {
tmp += '%' + buf[i].toString(16)
}
}
return res + decodeUtf8Char(tmp)
}
function asciiSlice (buf, start, end) {
var ret = ''
end = Math.min(buf.length, end)
for (var i = start; i < end; i++) {
ret += String.fromCharCode(buf[i])
}
return ret
}
function binarySlice (buf, start, end) {
return asciiSlice(buf, start, end)
}
function hexSlice (buf, start, end) {
var len = buf.length
if (!start || start < 0) start = 0
if (!end || end < 0 || end > len) end = len
var out = ''
for (var i = start; i < end; i++) {
out += toHex(buf[i])
}
return out
}
function utf16leSlice (buf, start, end) {
var bytes = buf.slice(start, end)
var res = ''
for (var i = 0; i < bytes.length; i += 2) {
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
}
return res
}
Buffer.prototype.slice = function (start, end) {
var len = this.length
start = ~~start
end = end === undefined ? len : ~~end
if (start < 0) {
start += len;
if (start < 0)
start = 0
} else if (start > len) {
start = len
}
if (end < 0) {
end += len
if (end < 0)
end = 0
} else if (end > len) {
end = len
}
if (end < start)
end = start
if (Buffer.TYPED_ARRAY_SUPPORT) {
return Buffer._augment(this.subarray(start, end))
} else {
var sliceLen = end - start
var newBuf = new Buffer(sliceLen, undefined, true)
for (var i = 0; i < sliceLen; i++) {
newBuf[i] = this[i + start]
}
return newBuf
}
}
/*
* Need to make sure that buffer isn't trying to write out of bounds.
*/
function checkOffset (offset, ext, length) {
if ((offset % 1) !== 0 || offset < 0)
throw new RangeError('offset is not uint')
if (offset + ext > length)
throw new RangeError('Trying to access beyond buffer length')
}
Buffer.prototype.readUInt8 = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 1, this.length)
return this[offset]
}
Buffer.prototype.readUInt16LE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 2, this.length)
return this[offset] | (this[offset + 1] << 8)
}
Buffer.prototype.readUInt16BE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 2, this.length)
return (this[offset] << 8) | this[offset + 1]
}
Buffer.prototype.readUInt32LE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 4, this.length)
return ((this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16)) +
(this[offset + 3] * 0x1000000)
}
Buffer.prototype.readUInt32BE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 4, this.length)
return (this[offset] * 0x1000000) +
((this[offset + 1] << 16) |
(this[offset + 2] << 8) |
this[offset + 3])
}
Buffer.prototype.readInt8 = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 1, this.length)
if (!(this[offset] & 0x80))
return (this[offset])
return ((0xff - this[offset] + 1) * -1)
}
Buffer.prototype.readInt16LE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 2, this.length)
var val = this[offset] | (this[offset + 1] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}
Buffer.prototype.readInt16BE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 2, this.length)
var val = this[offset + 1] | (this[offset] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}
Buffer.prototype.readInt32LE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 4, this.length)
return (this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16) |
(this[offset + 3] << 24)
}
Buffer.prototype.readInt32BE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 4, this.length)
return (this[offset] << 24) |
(this[offset + 1] << 16) |
(this[offset + 2] << 8) |
(this[offset + 3])
}
Buffer.prototype.readFloatLE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 4, this.length)
return ieee754.read(this, offset, true, 23, 4)
}
Buffer.prototype.readFloatBE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 4, this.length)
return ieee754.read(this, offset, false, 23, 4)
}
Buffer.prototype.readDoubleLE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 8, this.length)
return ieee754.read(this, offset, true, 52, 8)
}
Buffer.prototype.readDoubleBE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 8, this.length)
return ieee754.read(this, offset, false, 52, 8)
}
function checkInt (buf, value, offset, ext, max, min) {
if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')
if (value > max || value < min) throw new TypeError('value is out of bounds')
if (offset + ext > buf.length) throw new TypeError('index out of range')
}
Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 1, 0xff, 0)
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
this[offset] = value
return offset + 1
}
function objectWriteUInt16 (buf, value, offset, littleEndian) {
if (value < 0) value = 0xffff + value + 1
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
(littleEndian ? i : 1 - i) * 8
}
}
Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0xffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
} else objectWriteUInt16(this, value, offset, true)
return offset + 2
}
Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0xffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8)
this[offset + 1] = value
} else objectWriteUInt16(this, value, offset, false)
return offset + 2
}
function objectWriteUInt32 (buf, value, offset, littleEndian) {
if (value < 0) value = 0xffffffff + value + 1
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
}
}
Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0xffffffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset + 3] = (value >>> 24)
this[offset + 2] = (value >>> 16)
this[offset + 1] = (value >>> 8)
this[offset] = value
} else objectWriteUInt32(this, value, offset, true)
return offset + 4
}
Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0xffffffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = value
} else objectWriteUInt32(this, value, offset, false)
return offset + 4
}
Buffer.prototype.writeInt8 = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 1, 0x7f, -0x80)
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
if (value < 0) value = 0xff + value + 1
this[offset] = value
return offset + 1
}
Buffer.prototype.writeInt16LE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0x7fff, -0x8000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
} else objectWriteUInt16(this, value, offset, true)
return offset + 2
}
Buffer.prototype.writeInt16BE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0x7fff, -0x8000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8)
this[offset + 1] = value
} else objectWriteUInt16(this, value, offset, false)
return offset + 2
}
Buffer.prototype.writeInt32LE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
this[offset + 2] = (value >>> 16)
this[offset + 3] = (value >>> 24)
} else objectWriteUInt32(this, value, offset, true)
return offset + 4
}
Buffer.prototype.writeInt32BE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
if (value < 0) value = 0xffffffff + value + 1
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = value
} else objectWriteUInt32(this, value, offset, false)
return offset + 4
}
function checkIEEE754 (buf, value, offset, ext, max, min) {
if (value > max || value < min) throw new TypeError('value is out of bounds')
if (offset + ext > buf.length) throw new TypeError('index out of range')
}
function writeFloat (buf, value, offset, littleEndian, noAssert) {
if (!noAssert)
checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
ieee754.write(buf, value, offset, littleEndian, 23, 4)
return offset + 4
}
Buffer.prototype.writeFloatLE = function (value, offset, noAssert) {
return writeFloat(this, value, offset, true, noAssert)
}
Buffer.prototype.writeFloatBE = function (value, offset, noAssert) {
return writeFloat(this, value, offset, false, noAssert)
}
function writeDouble (buf, value, offset, littleEndian, noAssert) {
if (!noAssert)
checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
ieee754.write(buf, value, offset, littleEndian, 52, 8)
return offset + 8
}
Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) {
return writeDouble(this, value, offset, true, noAssert)
}
Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) {
return writeDouble(this, value, offset, false, noAssert)
}
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
Buffer.prototype.copy = function (target, target_start, start, end) {
var source = this
if (!start) start = 0
if (!end && end !== 0) end = this.length
if (!target_start) target_start = 0
// Copy 0 bytes; we're done
if (end === start) return
if (target.length === 0 || source.length === 0) return
// Fatal error conditions
if (end < start) throw new TypeError('sourceEnd < sourceStart')
if (target_start < 0 || target_start >= target.length)
throw new TypeError('targetStart out of bounds')
if (start < 0 || start >= source.length) throw new TypeError('sourceStart out of bounds')
if (end < 0 || end > source.length) throw new TypeError('sourceEnd out of bounds')
// Are we oob?
if (end > this.length)
end = this.length
if (target.length - target_start < end - start)
end = target.length - target_start + start
var len = end - start
if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
for (var i = 0; i < len; i++) {
target[i + target_start] = this[i + start]
}
} else {
target._set(this.subarray(start, start + len), target_start)
}
}
// fill(value, start=0, end=buffer.length)
Buffer.prototype.fill = function (value, start, end) {
if (!value) value = 0
if (!start) start = 0
if (!end) end = this.length
if (end < start) throw new TypeError('end < start')
// Fill 0 bytes; we're done
if (end === start) return
if (this.length === 0) return
if (start < 0 || start >= this.length) throw new TypeError('start out of bounds')
if (end < 0 || end > this.length) throw new TypeError('end out of bounds')
var i
if (typeof value === 'number') {
for (i = start; i < end; i++) {
this[i] = value
}
} else {
var bytes = utf8ToBytes(value.toString())
var len = bytes.length
for (i = start; i < end; i++) {
this[i] = bytes[i % len]
}
}
return this
}
/**
* Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
* Added in Node 0.12. Only available in browsers that support ArrayBuffer.
*/
Buffer.prototype.toArrayBuffer = function () {
if (typeof Uint8Array !== 'undefined') {
if (Buffer.TYPED_ARRAY_SUPPORT) {
return (new Buffer(this)).buffer
} else {
var buf = new Uint8Array(this.length)
for (var i = 0, len = buf.length; i < len; i += 1) {
buf[i] = this[i]
}
return buf.buffer
}
} else {
throw new TypeError('Buffer.toArrayBuffer not supported in this browser')
}
}
// HELPER FUNCTIONS
// ================
var BP = Buffer.prototype
/**
* Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
*/
Buffer._augment = function (arr) {
arr.constructor = Buffer
arr._isBuffer = true
// save reference to original Uint8Array get/set methods before overwriting
arr._get = arr.get
arr._set = arr.set
// deprecated, will be removed in node 0.13+
arr.get = BP.get
arr.set = BP.set
arr.write = BP.write
arr.toString = BP.toString
arr.toLocaleString = BP.toString
arr.toJSON = BP.toJSON
arr.equals = BP.equals
arr.compare = BP.compare
arr.copy = BP.copy
arr.slice = BP.slice
arr.readUInt8 = BP.readUInt8
arr.readUInt16LE = BP.readUInt16LE
arr.readUInt16BE = BP.readUInt16BE
arr.readUInt32LE = BP.readUInt32LE
arr.readUInt32BE = BP.readUInt32BE
arr.readInt8 = BP.readInt8
arr.readInt16LE = BP.readInt16LE
arr.readInt16BE = BP.readInt16BE
arr.readInt32LE = BP.readInt32LE
arr.readInt32BE = BP.readInt32BE
arr.readFloatLE = BP.readFloatLE
arr.readFloatBE = BP.readFloatBE
arr.readDoubleLE = BP.readDoubleLE
arr.readDoubleBE = BP.readDoubleBE
arr.writeUInt8 = BP.writeUInt8
arr.writeUInt16LE = BP.writeUInt16LE
arr.writeUInt16BE = BP.writeUInt16BE
arr.writeUInt32LE = BP.writeUInt32LE
arr.writeUInt32BE = BP.writeUInt32BE
arr.writeInt8 = BP.writeInt8
arr.writeInt16LE = BP.writeInt16LE
arr.writeInt16BE = BP.writeInt16BE
arr.writeInt32LE = BP.writeInt32LE
arr.writeInt32BE = BP.writeInt32BE
arr.writeFloatLE = BP.writeFloatLE
arr.writeFloatBE = BP.writeFloatBE
arr.writeDoubleLE = BP.writeDoubleLE
arr.writeDoubleBE = BP.writeDoubleBE
arr.fill = BP.fill
arr.inspect = BP.inspect
arr.toArrayBuffer = BP.toArrayBuffer
return arr
}
var INVALID_BASE64_RE = /[^+\/0-9A-z]/g
function base64clean (str) {
// Node strips out invalid characters like \n and \t from the string, base64-js does not
str = stringtrim(str).replace(INVALID_BASE64_RE, '')
// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
while (str.length % 4 !== 0) {
str = str + '='
}
return str
}
function stringtrim (str) {
if (str.trim) return str.trim()
return str.replace(/^\s+|\s+$/g, '')
}
function isArrayish (subject) {
return isArray(subject) || Buffer.isBuffer(subject) ||
subject && typeof subject === 'object' &&
typeof subject.length === 'number'
}
function toHex (n) {
if (n < 16) return '0' + n.toString(16)
return n.toString(16)
}
function utf8ToBytes (str) {
var byteArray = []
for (var i = 0; i < str.length; i++) {
var b = str.charCodeAt(i)
if (b <= 0x7F) {
byteArray.push(b)
} else {
var start = i
if (b >= 0xD800 && b <= 0xDFFF) i++
var h = encodeURIComponent(str.slice(start, i+1)).substr(1).split('%')
for (var j = 0; j < h.length; j++) {
byteArray.push(parseInt(h[j], 16))
}
}
}
return byteArray
}
function asciiToBytes (str) {
var byteArray = []
for (var i = 0; i < str.length; i++) {
// Node's code seems to be doing this and not & 0x7F..
byteArray.push(str.charCodeAt(i) & 0xFF)
}
return byteArray
}
function utf16leToBytes (str) {
var c, hi, lo
var byteArray = []
for (var i = 0; i < str.length; i++) {
c = str.charCodeAt(i)
hi = c >> 8
lo = c % 256
byteArray.push(lo)
byteArray.push(hi)
}
return byteArray
}
function base64ToBytes (str) {
return base64.toByteArray(str)
}
function blitBuffer (src, dst, offset, length) {
for (var i = 0; i < length; i++) {
if ((i + offset >= dst.length) || (i >= src.length))
break
dst[i + offset] = src[i]
}
return i
}
function decodeUtf8Char (str) {
try {
return decodeURIComponent(str)
} catch (err) {
return String.fromCharCode(0xFFFD) // UTF 8 invalid char
}
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 48 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {var rng = __webpack_require__(65)
function error () {
var m = [].slice.call(arguments).join(' ')
throw new Error([
m,
'we accept pull requests',
'http://github.com/dominictarr/crypto-browserify'
].join('\n'))
}
exports.createHash = __webpack_require__(66)
exports.createHmac = __webpack_require__(67)
exports.randomBytes = function(size, callback) {
if (callback && callback.call) {
try {
callback.call(this, undefined, new Buffer(rng(size)))
} catch (err) { callback(err) }
} else {
return new Buffer(rng(size))
}
}
function each(a, f) {
for(var i in a)
f(a[i], i)
}
exports.getHashes = function () {
return ['sha1', 'sha256', 'sha512', 'md5', 'rmd160']
}
var p = __webpack_require__(68)(exports)
exports.pbkdf2 = p.pbkdf2
exports.pbkdf2Sync = p.pbkdf2Sync
__webpack_require__(84)(exports, module.exports);
// the least I can do is make error messages for the rest of the node.js/crypto api.
each(['createCredentials'
, 'createSign'
, 'createVerify'
, 'createDiffieHellman'
], function (name) {
exports[name] = function () {
error('sorry,', name, 'is not implemented yet')
}
})
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 49 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var uuid = __webpack_require__(85);
var Promise = __webpack_require__(90).Promise;
var messagebus = __webpack_require__(50);
var Conversation = __webpack_require__(69);
var Block = __webpack_require__(61);
var Then = __webpack_require__(58);
var Tell = __webpack_require__(56);
var Listen = __webpack_require__(57);
__webpack_require__(60); // append iif function to Block
/**
* Babbler
* @param {String} id
* @constructor
*/
function Babbler (id) {
if (!(this instanceof Babbler)) {
throw new SyntaxError('Constructor must be called with the new operator');
}
if (!id) {
throw new Error('id required');
}
this.id = id;
this.listeners = []; // Array.<Listen>
this.conversations = {}; // Array.<Array.<Conversation>> all open conversations
this.connect(); // automatically connect to the local message bus
}
/**
* Connect to a message bus
* @param {{connect: function, disconnect: function, send: function}} [bus]
* A messaging interface. Must have the following functions:
* - connect(params: {id: string,
* message: function, callback: function}) : string
* must return a token to disconnects again.
* parameter callback is optional.
* - disconnect(token: string)
* disconnect from a message bus.
* - send(id: string, message: *)
* send a message
* A number of interfaces is provided under babble.messagebus.
* Default interface is babble.messagebus['default']
* @return {Promise.<Babbler>} Returns a Promise which resolves when the
* babbler is connected.
*/
Babbler.prototype.connect = function (bus) {
// disconnect (in case we are already connected)
this.disconnect();
if (!bus) {
bus = messagebus['default']();
}
// validate the message bus functions
if (typeof bus.connect !== 'function') {
throw new Error('message bus must contain a function ' +
'connect(params: {id: string, callback: function}) : string');
}
if (typeof bus.disconnect !== 'function') {
throw new Error('message bus must contain a function ' +
'disconnect(token: string)');
}
if (typeof bus.send !== 'function') {
throw new Error('message bus must contain a function ' +
'send(params: {id: string, message: *})');
}
// we return a promise, but we run the message.connect function immediately
// (outside of the Promise), so that synchronous connects are done without
// the need to await the promise to resolve on the next tick.
var _resolve = null;
var connected = new Promise(function (resolve, reject) {
_resolve = resolve;
});
var token = bus.connect({
id: this.id,
message: this._receive.bind(this),
callback: _resolve
});
// link functions to disconnect and send
this.disconnect = function () {
bus.disconnect(token);
};
this.send = bus.send;
// return a promise
return connected;
};
/**
* Handle an incoming message
* @param {{id: string, from: string, to: string, message: string}} envelope
* @private
*/
Babbler.prototype._receive = function (envelope) {
// ignore when envelope does not contain an id and message
if (!envelope || !('id' in envelope) || !('message' in envelope)) {
return;
}
// console.log('_receive', envelope) // TODO: cleanup
var me = this;
var id = envelope.id;
var conversations = this.conversations[id];
if (conversations && conversations.length) {
// directly deliver to all open conversations with this id
conversations.forEach(function (conversation) {
conversation.deliver(envelope);
})
}
else {
// start new conversations at each of the listeners
if (!conversations) {
conversations = [];
}
this.conversations[id] = conversations;
this.listeners.forEach(function (block) {
// create a new conversation
var conversation = new Conversation({
id: id,
self: me.id,
other: envelope.from,
context: {
from: envelope.from
},
send: me.send
});
// append this conversation to the list with conversations
conversations.push(conversation);
// deliver the first message to the new conversation
conversation.deliver(envelope);
// process the conversation
return me._process(block, conversation)
.then(function() {
// remove the conversation from the list again
var index = conversations.indexOf(conversation);
if (index !== -1) {
conversations.splice(index, 1);
}
if (conversations.length === 0) {
delete me.conversations[id];
}
});
});
}
};
/**
* Disconnect from the babblebox
*/
Babbler.prototype.disconnect = function () {
// by default, do nothing. The disconnect function will be overwritten
// when the Babbler is connected to a message bus.
};
/**
* Send a message
* @param {String} to Id of a babbler
* @param {*} message Any message. Message must be a stringifiable JSON object.
*/
Babbler.prototype.send = function (to, message) {
// send is overridden when running connect
throw new Error('Cannot send: not connected');
};
/**
* Listen for a specific event
*
* Providing a condition will only start the flow when condition is met,
* this is equivalent of doing `listen().iif(condition)`
*
* Providing a callback function is equivalent of doing either
* `listen(message).then(callback)` or `listen().iif(message).then(callback)`.
*
* @param {function | RegExp | String | *} [condition]
* @param {Function} [callback] Invoked as callback(message, context),
* where `message` is the just received message,
* and `context` is an object where state can be
* stored during a conversation. This is equivalent
* of doing `listen().then(callback)`
* @return {Block} block Start block of a control flow.
*/
Babbler.prototype.listen = function (condition, callback) {
var listen = new Listen();
this.listeners.push(listen);
var block = listen;
if (condition) {
block = block.iif(condition);
}
if (callback) {
block = block.then(callback);
}
return block;
};
/**
* Listen for a specific event, and execute the flow once.
*
* Providing a condition will only start the flow when condition is met,
* this is equivalent of doing `listen().iif(condition)`
*
* Providing a callback function is equivalent of doing either
* `listen(message).then(callback)` or `listen().iif(message).then(callback)`.
*
* @param {function | RegExp | String | *} [condition]
* @param {Function} [callback] Invoked as callback(message, context),
* where `message` is the just received message,
* and `context` is an object where state can be
* stored during a conversation. This is equivalent
* of doing `listen().then(callback)`
* @return {Block} block Start block of a control flow.
*/
Babbler.prototype.listenOnce = function (condition, callback) {
var listen = new Listen();
this.listeners.push(listen);
var me = this;
var block = listen;
if (condition) {
block = block.iif(condition);
}
block = block.then(function (message) {
// remove the flow from the listeners after fired once
var index = me.listeners.indexOf(listen);
if (index !== -1) {
me.listeners.splice(index, 1);
}
return message;
});
if (callback) {
block = block.then(callback);
}
return block;
};
/**
* Send a message to the other peer
* Creates a block Tell, and runs the block immediately.
* @param {String} to Babbler id
* @param {Function | *} message
* @return {Block} block Last block in the created control flow
*/
Babbler.prototype.tell = function (to, message) {
var me = this;
var cid = uuid.v4(); // create an id for this conversation
// create a new conversation
var conversation = new Conversation({
id: cid,
self: this.id,
other: to,
context: {
from: to
},
send: me.send
});
this.conversations[cid] = [conversation];
var block = new Tell(message);
// run the Tell block on the next tick, when the conversation flow is created
setTimeout(function () {
me._process(block, conversation)
.then(function () {
// cleanup the conversation
delete me.conversations[cid];
})
}, 0);
return block;
};
/**
* Send a question, listen for a response.
* Creates two blocks: Tell and Listen, and runs them immediately.
* This is equivalent of doing `Babbler.tell(to, message).listen(callback)`
* @param {String} to Babbler id
* @param {* | Function} message A message or a callback returning a message.
* @param {Function} [callback] Invoked as callback(message, context),
* where `message` is the just received message,
* and `context` is an object where state can be
* stored during a conversation. This is equivalent
* of doing `listen().then(callback)`
* @return {Block} block Last block in the created control flow
*/
Babbler.prototype.ask = function (to, message, callback) {
return this
.tell(to, message)
.listen(callback);
};
/**
* Process a flow starting with `block`, given a conversation
* @param {Block} block
* @param {Conversation} conversation
* @return {Promise.<Conversation>} Resolves when the conversation is finished
* @private
*/
Babbler.prototype._process = function (block, conversation) {
return new Promise(function (resolve, reject) {
/**
* Process a block, given the conversation and a message which is chained
* from block to block.
* @param {Block} block
* @param {*} [message]
*/
function process(block, message) {
//console.log('process', conversation.self, conversation.id, block.constructor.name, message) // TODO: cleanup
block.execute(conversation, message)
.then(function (next) {
if (next.block) {
// recursively evaluate the next block in the conversation flow
process(next.block, next.result);
}
else {
// we are done, this is the end of the conversation
resolve(conversation);
}
});
}
// process the first block
process(block);
});
};
module.exports = Babbler;
/***/ },
/* 50 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(90).Promise;
// built-in messaging interfaces
/**
* pubsub-js messaging interface
* @returns {{connect: function, disconnect: function, send: function}}
*/
exports['pubsub-js'] = function () {
var PubSub = __webpack_require__(89);
return {
connect: function (params) {
var token = PubSub.subscribe(params.id, function (id, message) {
params.message(message);
});
if (typeof params.callback === 'function') {
params.callback();
}
return token;
},
disconnect: function(token) {
PubSub.unsubscribe(token);
},
send: function (to, message) {
PubSub.publish(to, message);
}
}
};
/**
* // pubnub messaging interface
* @param {{publish_key: string, subscribe_key: string}} params
* @returns {{connect: function, disconnect: function, send: function}}
*/
exports['pubnub'] = function (params) {
var PUBNUB;
if (typeof window !== 'undefined') {
// browser
if (typeof window['PUBNUB'] === 'undefined') {
throw new Error('Please load pubnub first in the browser');
}
PUBNUB = window['PUBNUB'];
}
else {
// node.js
PUBNUB = __webpack_require__(86);
}
var pubnub = PUBNUB.init(params);
return {
connect: function (params) {
pubnub.subscribe({
channel: params.id,
message: params.message,
connect: params.callback
});
return params.id;
},
disconnect: function (id) {
pubnub.unsubscribe(id);
},
send: function (to, message) {
return new Promise(function (resolve, reject) {
pubnub.publish({
channel: to,
message: message,
callback: resolve
});
})
}
}
};
// default interface
exports['default'] = exports['pubsub-js'];
/***/ },
/* 51 */
/***/ function(module, exports, __webpack_require__) {
var uuid = __webpack_require__(74),
Promise = __webpack_require__(41);
var TIMEOUT = 60000; // ms
// TODO: make timeout a configuration setting
/**
* Wrap a socket in a request/response handling layer.
* Requests are wrapped in an envelope with id and data, and responses
* are packed in an envelope with this same id and response data.
*
* The socket is extended with functions:
* request(data: *) : Promise.<*, Error>
* onrequest(data: *) : Promise.<*, Error>
*
* @param {WebSocket} socket
* @return {WebSocket} requestified socket
*/
function requestify (socket) {
return (function () {
var queue = {}; // queue with requests in progress
if ('request' in socket) {
throw new Error('Socket already has a request property');
}
var requestified = socket;
/**
* Event handler, handles incoming messages
* @param {Object} event
*/
socket.onmessage = function (event) {
var data = event.data;
if (data.charAt(0) == '{') {
var envelope = JSON.parse(data);
// match the request from the id in the response
var request = queue[envelope.id];
if (request) {
// handle an incoming response
clearTimeout(request.timeout);
delete queue[envelope.id];
// resolve the promise with response data
if (envelope.error) {
// TODO: implement a smarter way to serialize and deserialize errors
request.reject(new Error(envelope.error));
}
else {
request.resolve(envelope.message);
}
}
else {
if ('id' in envelope) {
try {
// handle an incoming request
requestified.onrequest(envelope.message)
.then(function (message) {
var response = {
id: envelope.id,
message: message,
error: null
};
socket.send(JSON.stringify(response));
})
.catch(function (error) {
var response = {
id: envelope.id,
message: null,
error: error.message || error.toString()
};
socket.send(JSON.stringify(response));
});
}
catch (err) {
var response = {
id: envelope.id,
message: null,
error: err.message || err.toString()
};
socket.send(JSON.stringify(response));
}
}
else {
// handle incoming notification (we don't do anything with the response)
requestified.onrequest(envelope.message);
}
}
}
};
/**
* Send a request
* @param {*} message
* @returns {Promise.<*, Error>} Returns a promise resolving with the response message
*/
requestified.request = function (message) {
return new Promise(function (resolve, reject) {
// put the data in an envelope with id
var id = uuid.v1();
var envelope = {
id: id,
message: message
};
// add the request to the list with requests in progress
queue[id] = {
resolve: resolve,
reject: reject,
timeout: setTimeout(function () {
delete queue[id];
reject(new Error('Timeout'));
}, TIMEOUT)
};
socket.send(JSON.stringify(envelope));
});
};
/**
* Send a notification. A notification does not receive a response.
* @param {*} message
* @returns {Promise.<null, Error>} Returns a promise resolving with the null
* when the notification has been sent.
*/
requestified.notify = function (message) {
return new Promise(function (resolve, reject) {
// put the data in an envelope
var envelope = {
// we don't add an id, so we send this as notification instead of a request
message: message
};
socket.send(JSON.stringify(envelope), function () {
resolve(null);
});
});
};
/**
* Handle an incoming request.
* @param {*} message Request message
* @returns {Promise.<*, Error>} Resolves with a response message
*/
requestified.onrequest = function (message) {
// this function must be implemented by the socket
return Promise.reject('No onrequest handler implemented');
};
// TODO: disable send and onmessage on the requestified socket
return requestified;
})();
}
module.exports = requestify;
/***/ },
/* 52 */
/***/ function(module, exports, __webpack_require__) {
//var Emitter = require('emitter-component');
/**
* Peer
* A peer can send and receive messages via a connected message bus
* @param {string} id
* @param {function(string, string, *)} send A function to send a message to an other peer
*/
function Peer(id, send) {
this.id = id;
this._send = send;
this.listeners = {};
}
/**
* Send a message to another peer
* @param {string} to Id of the recipient
* @param {*} message Message to be send, can be JSON
* @returns {Promise.<null, Error>} Resolves when sent
*/
Peer.prototype.send = function (to, message) {
return this._send(this.id, to, message);
};
// Extend the Peer with event emitter functionality
//Emitter(Peer.prototype);
// TODO: complete this custom event emitter, it's about 5 times as fast as Emitter because its not slicing arguments
/**
* Register an event listener
* @param {string} event Available events: 'message'
* @param {Function} callback Callback function, called as callback(from, message)
*/
Peer.prototype.on = function (event, callback) {
if (!(event in this.listeners)) this.listeners[event] = [];
this.listeners[event].push(callback);
};
// TODO: implement off
/**
* Emit an event
* @param {string} event For example 'message'
* @param {string} from Id of the sender, for example 'peer1'
* @param {*} message A message, can be any type. Must be serializable JSON.
*/
Peer.prototype.emit = function (event, from, message) {
var listeners = this.listeners[event];
if (listeners) {
for (var i = 0, ii = listeners.length; i < ii; i++) {
var listener = listeners[i];
listener(from, message);
}
}
};
module.exports = Peer;
/***/ },
/* 53 */
/***/ function(module, exports, __webpack_require__) {
var Stream = __webpack_require__(64);
var util = __webpack_require__(79);
var Response = module.exports = function (res) {
this.offset = 0;
this.readable = true;
};
util.inherits(Response, Stream);
var capable = {
streaming : true,
status2 : true
};
function parseHeaders (res) {
var lines = res.getAllResponseHeaders().split(/\r?\n/);
var headers = {};
for (var i = 0; i < lines.length; i++) {
var line = lines[i];
if (line === '') continue;
var m = line.match(/^([^:]+):\s*(.*)/);
if (m) {
var key = m[1].toLowerCase(), value = m[2];
if (headers[key] !== undefined) {
if (isArray(headers[key])) {
headers[key].push(value);
}
else {
headers[key] = [ headers[key], value ];
}
}
else {
headers[key] = value;
}
}
else {
headers[line] = true;
}
}
return headers;
}
Response.prototype.getResponse = function (xhr) {
var respType = String(xhr.responseType).toLowerCase();
if (respType === 'blob') return xhr.responseBlob || xhr.response;
if (respType === 'arraybuffer') return xhr.response;
return xhr.responseText;
}
Response.prototype.getHeader = function (key) {
return this.headers[key.toLowerCase()];
};
Response.prototype.handle = function (res) {
if (res.readyState === 2 && capable.status2) {
try {
this.statusCode = res.status;
this.headers = parseHeaders(res);
}
catch (err) {
capable.status2 = false;
}
if (capable.status2) {
this.emit('ready');
}
}
else if (capable.streaming && res.readyState === 3) {
try {
if (!this.statusCode) {
this.statusCode = res.status;
this.headers = parseHeaders(res);
this.emit('ready');
}
}
catch (err) {}
try {
this._emitData(res);
}
catch (err) {
capable.streaming = false;
}
}
else if (res.readyState === 4) {
if (!this.statusCode) {
this.statusCode = res.status;
this.emit('ready');
}
this._emitData(res);
if (res.error) {
this.emit('error', this.getResponse(res));
}
else this.emit('end');
this.emit('close');
}
};
Response.prototype._emitData = function (res) {
var respBody = this.getResponse(res);
if (respBody.toString().match(/ArrayBuffer/)) {
this.emit('data', new Uint8Array(respBody, this.offset));
this.offset = respBody.byteLength;
return;
}
if (respBody.length > this.offset) {
this.emit('data', respBody.slice(this.offset));
this.offset = respBody.length;
}
};
var isArray = Array.isArray || function (xs) {
return Object.prototype.toString.call(xs) === '[object Array]';
};
/***/ },
/* 54 */
/***/ function(module, exports, __webpack_require__) {
var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module, global) {/*! http://mths.be/punycode v1.2.4 by @mathias */
;(function(root) {
/** Detect free variables */
var freeExports = typeof exports == 'object' && exports;
var freeModule = typeof module == 'object' && module &&
module.exports == freeExports && module;
var freeGlobal = typeof global == 'object' && global;
if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
root = freeGlobal;
}
/**
* The `punycode` object.
* @name punycode
* @type Object
*/
var punycode,
/** Highest positive signed 32-bit float value */
maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
/** Bootstring parameters */
base = 36,
tMin = 1,
tMax = 26,
skew = 38,
damp = 700,
initialBias = 72,
initialN = 128, // 0x80
delimiter = '-', // '\x2D'
/** Regular expressions */
regexPunycode = /^xn--/,
regexNonASCII = /[^ -~]/, // unprintable ASCII chars + non-ASCII chars
regexSeparators = /\x2E|\u3002|\uFF0E|\uFF61/g, // RFC 3490 separators
/** Error messages */
errors = {
'overflow': 'Overflow: input needs wider integers to process',
'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
'invalid-input': 'Invalid input'
},
/** Convenience shortcuts */
baseMinusTMin = base - tMin,
floor = Math.floor,
stringFromCharCode = String.fromCharCode,
/** Temporary variable */
key;
/*--------------------------------------------------------------------------*/
/**
* A generic error utility function.
* @private
* @param {String} type The error type.
* @returns {Error} Throws a `RangeError` with the applicable error message.
*/
function error(type) {
throw RangeError(errors[type]);
}
/**
* A generic `Array#map` utility function.
* @private
* @param {Array} array The array to iterate over.
* @param {Function} callback The function that gets called for every array
* item.
* @returns {Array} A new array of values returned by the callback function.
*/
function map(array, fn) {
var length = array.length;
while (length--) {
array[length] = fn(array[length]);
}
return array;
}
/**
* A simple `Array#map`-like wrapper to work with domain name strings.
* @private
* @param {String} domain The domain name.
* @param {Function} callback The function that gets called for every
* character.
* @returns {Array} A new string of characters returned by the callback
* function.
*/
function mapDomain(string, fn) {
return map(string.split(regexSeparators), fn).join('.');
}
/**
* Creates an array containing the numeric code points of each Unicode
* character in the string. While JavaScript uses UCS-2 internally,
* this function will convert a pair of surrogate halves (each of which
* UCS-2 exposes as separate characters) into a single code point,
* matching UTF-16.
* @see `punycode.ucs2.encode`
* @see <http://mathiasbynens.be/notes/javascript-encoding>
* @memberOf punycode.ucs2
* @name decode
* @param {String} string The Unicode input string (UCS-2).
* @returns {Array} The new array of code points.
*/
function ucs2decode(string) {
var output = [],
counter = 0,
length = string.length,
value,
extra;
while (counter < length) {
value = string.charCodeAt(counter++);
if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
// high surrogate, and there is a next character
extra = string.charCodeAt(counter++);
if ((extra & 0xFC00) == 0xDC00) { // low surrogate
output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
} else {
// unmatched surrogate; only append this code unit, in case the next
// code unit is the high surrogate of a surrogate pair
output.push(value);
counter--;
}
} else {
output.push(value);
}
}
return output;
}
/**
* Creates a string based on an array of numeric code points.
* @see `punycode.ucs2.decode`
* @memberOf punycode.ucs2
* @name encode
* @param {Array} codePoints The array of numeric code points.
* @returns {String} The new Unicode string (UCS-2).
*/
function ucs2encode(array) {
return map(array, function(value) {
var output = '';
if (value > 0xFFFF) {
value -= 0x10000;
output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
value = 0xDC00 | value & 0x3FF;
}
output += stringFromCharCode(value);
return output;
}).join('');
}
/**
* Converts a basic code point into a digit/integer.
* @see `digitToBasic()`
* @private
* @param {Number} codePoint The basic numeric code point value.
* @returns {Number} The numeric value of a basic code point (for use in
* representing integers) in the range `0` to `base - 1`, or `base` if
* the code point does not represent a value.
*/
function basicToDigit(codePoint) {
if (codePoint - 48 < 10) {
return codePoint - 22;
}
if (codePoint - 65 < 26) {
return codePoint - 65;
}
if (codePoint - 97 < 26) {
return codePoint - 97;
}
return base;
}
/**
* Converts a digit/integer into a basic code point.
* @see `basicToDigit()`
* @private
* @param {Number} digit The numeric value of a basic code point.
* @returns {Number} The basic code point whose value (when used for
* representing integers) is `digit`, which needs to be in the range
* `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
* used; else, the lowercase form is used. The behavior is undefined
* if `flag` is non-zero and `digit` has no uppercase form.
*/
function digitToBasic(digit, flag) {
// 0..25 map to ASCII a..z or A..Z
// 26..35 map to ASCII 0..9
return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
}
/**
* Bias adaptation function as per section 3.4 of RFC 3492.
* http://tools.ietf.org/html/rfc3492#section-3.4
* @private
*/
function adapt(delta, numPoints, firstTime) {
var k = 0;
delta = firstTime ? floor(delta / damp) : delta >> 1;
delta += floor(delta / numPoints);
for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
delta = floor(delta / baseMinusTMin);
}
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
}
/**
* Converts a Punycode string of ASCII-only symbols to a string of Unicode
* symbols.
* @memberOf punycode
* @param {String} input The Punycode string of ASCII-only symbols.
* @returns {String} The resulting string of Unicode symbols.
*/
function decode(input) {
// Don't use UCS-2
var output = [],
inputLength = input.length,
out,
i = 0,
n = initialN,
bias = initialBias,
basic,
j,
index,
oldi,
w,
k,
digit,
t,
/** Cached calculation results */
baseMinusT;
// Handle the basic code points: let `basic` be the number of input code
// points before the last delimiter, or `0` if there is none, then copy
// the first basic code points to the output.
basic = input.lastIndexOf(delimiter);
if (basic < 0) {
basic = 0;
}
for (j = 0; j < basic; ++j) {
// if it's not a basic code point
if (input.charCodeAt(j) >= 0x80) {
error('not-basic');
}
output.push(input.charCodeAt(j));
}
// Main decoding loop: start just after the last delimiter if any basic code
// points were copied; start at the beginning otherwise.
for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
// `index` is the index of the next character to be consumed.
// Decode a generalized variable-length integer into `delta`,
// which gets added to `i`. The overflow checking is easier
// if we increase `i` as we go, then subtract off its starting
// value at the end to obtain `delta`.
for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
if (index >= inputLength) {
error('invalid-input');
}
digit = basicToDigit(input.charCodeAt(index++));
if (digit >= base || digit > floor((maxInt - i) / w)) {
error('overflow');
}
i += digit * w;
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
if (digit < t) {
break;
}
baseMinusT = base - t;
if (w > floor(maxInt / baseMinusT)) {
error('overflow');
}
w *= baseMinusT;
}
out = output.length + 1;
bias = adapt(i - oldi, out, oldi == 0);
// `i` was supposed to wrap around from `out` to `0`,
// incrementing `n` each time, so we'll fix that now:
if (floor(i / out) > maxInt - n) {
error('overflow');
}
n += floor(i / out);
i %= out;
// Insert `n` at position `i` of the output
output.splice(i++, 0, n);
}
return ucs2encode(output);
}
/**
* Converts a string of Unicode symbols to a Punycode string of ASCII-only
* symbols.
* @memberOf punycode
* @param {String} input The string of Unicode symbols.
* @returns {String} The resulting Punycode string of ASCII-only symbols.
*/
function encode(input) {
var n,
delta,
handledCPCount,
basicLength,
bias,
j,
m,
q,
k,
t,
currentValue,
output = [],
/** `inputLength` will hold the number of code points in `input`. */
inputLength,
/** Cached calculation results */
handledCPCountPlusOne,
baseMinusT,
qMinusT;
// Convert the input in UCS-2 to Unicode
input = ucs2decode(input);
// Cache the length
inputLength = input.length;
// Initialize the state
n = initialN;
delta = 0;
bias = initialBias;
// Handle the basic code points
for (j = 0; j < inputLength; ++j) {
currentValue = input[j];
if (currentValue < 0x80) {
output.push(stringFromCharCode(currentValue));
}
}
handledCPCount = basicLength = output.length;
// `handledCPCount` is the number of code points that have been handled;
// `basicLength` is the number of basic code points.
// Finish the basic string - if it is not empty - with a delimiter
if (basicLength) {
output.push(delimiter);
}
// Main encoding loop:
while (handledCPCount < inputLength) {
// All non-basic code points < n have been handled already. Find the next
// larger one:
for (m = maxInt, j = 0; j < inputLength; ++j) {
currentValue = input[j];
if (currentValue >= n && currentValue < m) {
m = currentValue;
}
}
// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
// but guard against overflow
handledCPCountPlusOne = handledCPCount + 1;
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
error('overflow');
}
delta += (m - n) * handledCPCountPlusOne;
n = m;
for (j = 0; j < inputLength; ++j) {
currentValue = input[j];
if (currentValue < n && ++delta > maxInt) {
error('overflow');
}
if (currentValue == n) {
// Represent delta as a generalized variable-length integer
for (q = delta, k = base; /* no condition */; k += base) {
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
if (q < t) {
break;
}
qMinusT = q - t;
baseMinusT = base - t;
output.push(
stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
);
q = floor(qMinusT / baseMinusT);
}
output.push(stringFromCharCode(digitToBasic(q, 0)));
bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
delta = 0;
++handledCPCount;
}
}
++delta;
++n;
}
return output.join('');
}
/**
* Converts a Punycode string representing a domain name to Unicode. Only the
* Punycoded parts of the domain name will be converted, i.e. it doesn't
* matter if you call it on a string that has already been converted to
* Unicode.
* @memberOf punycode
* @param {String} domain The Punycode domain name to convert to Unicode.
* @returns {String} The Unicode representation of the given Punycode
* string.
*/
function toUnicode(domain) {
return mapDomain(domain, function(string) {
return regexPunycode.test(string)
? decode(string.slice(4).toLowerCase())
: string;
});
}
/**
* Converts a Unicode string representing a domain name to Punycode. Only the
* non-ASCII parts of the domain name will be converted, i.e. it doesn't
* matter if you call it with a domain that's already in ASCII.
* @memberOf punycode
* @param {String} domain The domain name to convert, as a Unicode string.
* @returns {String} The Punycode representation of the given domain name.
*/
function toASCII(domain) {
return mapDomain(domain, function(string) {
return regexNonASCII.test(string)
? 'xn--' + encode(string)
: string;
});
}
/*--------------------------------------------------------------------------*/
/** Define the public API */
punycode = {
/**
* A string representing the current Punycode.js version number.
* @memberOf punycode
* @type String
*/
'version': '1.2.4',
/**
* An object of methods to convert from JavaScript's internal character
* representation (UCS-2) to Unicode code points, and back.
* @see <http://mathiasbynens.be/notes/javascript-encoding>
* @memberOf punycode
* @type Object
*/
'ucs2': {
'decode': ucs2decode,
'encode': ucs2encode
},
'decode': decode,
'encode': encode,
'toASCII': toASCII,
'toUnicode': toUnicode
};
/** Expose `punycode` */
// Some AMD build optimizers, like r.js, check for specific condition patterns
// like the following:
if (
true
) {
!(__WEBPACK_AMD_DEFINE_RESULT__ = function() {
return punycode;
}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
} else if (freeExports && !freeExports.nodeType) {
if (freeModule) { // in Node.js or RingoJS v0.8.0+
freeModule.exports = punycode;
} else { // in Narwhal or RingoJS v0.7.0-
for (key in punycode) {
punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
}
}
} else { // in Rhino or a web browser
root.punycode = punycode;
}
}(this));
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(83)(module), (function() { return this; }())))
/***/ },
/* 55 */
/***/ function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(75);
/***/ },
/* 56 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(90).Promise;
var Block = __webpack_require__(61);
var isPromise = __webpack_require__(73).isPromise;
__webpack_require__(58); // extend Block with function then
__webpack_require__(57); // extend Block with function listen
/**
* Tell
* Send a message to the other peer.
* @param {* | Function} message A static message or callback function
* returning a message dynamically.
* When `message` is a function, it will be
* invoked as callback(message, context),
* where `message` is the output from the
* previous block in the chain, and `context` is
* an object where state can be stored during a
* conversation.
* @constructor
* @extends {Block}
*/
function Tell (message) {
if (!(this instanceof Tell)) {
throw new SyntaxError('Constructor must be called with the new operator');
}
this.message = message;
}
Tell.prototype = Object.create(Block.prototype);
Tell.prototype.constructor = Tell;
/**
* Execute the block
* @param {Conversation} conversation
* @param {*} [message] A message is ignored by the Tell block
* @return {Promise.<{result: *, block: Block}, Error>} next
*/
Tell.prototype.execute = function (conversation, message) {
// resolve the message
var me = this;
var resolve;
if (typeof this.message === 'function') {
var result = this.message(message, conversation.context);
resolve = isPromise(result) ? result : Promise.resolve(result);
}
else {
resolve = Promise.resolve(this.message); // static string or value
}
return resolve
.then(function (result) {
var res = conversation.send(result);
var done = isPromise(res) ? res : Promise.resolve(res);
return done.then(function () {
return {
result: result,
block: me.next
};
});
});
};
/**
* Create a Tell block and chain it to the current block
* @param {* | Function} [message] A static message or callback function
* returning a message dynamically.
* When `message` is a function, it will be
* invoked as callback(message, context),
* where `message` is the output from the
* previous block in the chain, and `context` is
* an object where state can be stored during a
* conversation.
* @return {Block} Returns the appended block
*/
Block.prototype.tell = function (message) {
var block = new Tell(message);
return this.then(block);
};
/**
* Send a question, listen for a response.
* Creates two blocks: Tell and Listen.
* This is equivalent of doing `babble.tell(message).listen(callback)`
* @param {* | Function} message
* @param {Function} [callback] Invoked as callback(message, context),
* where `message` is the just received message,
* and `context` is an object where state can be
* stored during a conversation. This is equivalent
* of doing `listen().then(callback)`
* @return {Block} Returns the appended block
*/
Block.prototype.ask = function (message, callback) {
// FIXME: this doesn't work
return this
.tell(message)
.listen(callback);
};
module.exports = Tell;
/***/ },
/* 57 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(90).Promise;
var Block = __webpack_require__(61);
var Then = __webpack_require__(58);
/**
* Listen
* Wait until a message comes in from the connected peer, then continue
* with the next block in the control flow.
*
* @constructor
* @extends {Block}
*/
function Listen () {
if (!(this instanceof Listen)) {
throw new SyntaxError('Constructor must be called with the new operator');
}
}
Listen.prototype = Object.create(Block.prototype);
Listen.prototype.constructor = Listen;
/**
* Execute the block
* @param {Conversation} conversation
* @param {*} [message] Message is ignored by Listen blocks
* @return {Promise.<{result: *, block: Block}, Error>} next
*/
Listen.prototype.execute = function (conversation, message) {
var me = this;
// wait until a message is received
return conversation.receive()
.then(function (message) {
return {
result: message,
block: me.next
}
});
};
/**
* Create a Listen block and chain it to the current block
*
* Optionally a callback function can be provided, which is equivalent of
* doing `listen().then(callback)`.
*
* @param {Function} [callback] Executed as callback(message: *, context: Object)
* Must return a result
* @return {Block} Returns the appended block
*/
Block.prototype.listen = function (callback) {
var listen = new Listen();
var block = this.then(listen);
if (callback) {
block = block.then(callback);
}
return block;
};
module.exports = Listen;
/***/ },
/* 58 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(90).Promise;
var Block = __webpack_require__(61);
var isPromise = __webpack_require__(73).isPromise;
/**
* Then
* Execute a callback function or a next block in the chain.
* @param {Function} callback Invoked as callback(message, context),
* where `message` is the output from the previous
* block in the chain, and `context` is an object
* where state can be stored during a conversation.
* @constructor
* @extends {Block}
*/
function Then (callback) {
if (!(this instanceof Then)) {
throw new SyntaxError('Constructor must be called with the new operator');
}
if (!(typeof callback === 'function')) {
throw new TypeError('Parameter callback must be a Function');
}
this.callback = callback;
}
Then.prototype = Object.create(Block.prototype);
Then.prototype.constructor = Then;
/**
* Execute the block
* @param {Conversation} conversation
* @param {*} message
* @return {Promise.<{result: *, block: Block}, Error>} next
*/
Then.prototype.execute = function (conversation, message) {
var me = this;
var result = this.callback(message, conversation.context);
var resolve = isPromise(result) ? result : Promise.resolve(result);
return resolve.then(function (result) {
return {
result: result,
block: me.next
}
});
};
/**
* Chain a block to the current block.
*
* When a function is provided, a Then block will be generated which
* executes the function. The function is invoked as callback(message, context),
* where `message` is the output from the previous block in the chain,
* and `context` is an object where state can be stored during a conversation.
*
* @param {Block | function} next A callback function or Block.
* @return {Block} Returns the appended block
*/
Block.prototype.then = function (next) {
// turn a callback function into a Then block
if (typeof next === 'function') {
next = new Then(next);
}
if (!(next instanceof Block)) {
throw new TypeError('Parameter next must be a Block or function');
}
// append after the last block
next.previous = this;
this.next = next;
// return the appended block
return next;
};
module.exports = Then;
/***/ },
/* 59 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(90).Promise;
var Block = __webpack_require__(61);
var isPromise =__webpack_require__(73).isPromise;
__webpack_require__(58); // extend Block with function then
/**
* Decision
* A decision is made by executing the provided callback function, which returns
* a next control flow block.
*
* Syntax:
*
* new Decision(choices)
* new Decision(decision, choices)
*
* Where:
*
* {Function | Object} [decision]
* When a `decision` function is provided, the
* function is invoked as decision(message, context),
* where `message` is the output from the previous
* block in the chain, and `context` is an object
* where state can be stored during a conversation.
* The function must return the id for the next
* block in the control flow, which must be
* available in the provided `choices`.
* If `decision` is not provided, the next block
* will be mapped directly from the message.
* {Object.<String, Block>} choices
* A map with the possible next blocks in the flow
* The next block is selected by the id returned
* by the decision function.
*
* There is one special id for choices: 'default'. This id is called when either
* the decision function returns an id which does not match any of the available
* choices.
*
* @param arg1
* @param arg2
* @constructor
* @extends {Block}
*/
function Decision (arg1, arg2) {
var decision, choices;
if (!(this instanceof Decision)) {
throw new SyntaxError('Constructor must be called with the new operator');
}
if (typeof arg1 === 'function') {
decision = arg1;
choices = arg2;
}
else {
decision = null;
choices = arg1;
}
if (decision) {
if (typeof decision !== 'function') {
throw new TypeError('Parameter decision must be a function');
}
}
else {
decision = function (message, context) {
return message;
}
}
if (choices && (choices instanceof Function)) {
throw new TypeError('Parameter choices must be an object');
}
this.decision = decision;
this.choices = {};
// append all choices
if (choices) {
var me = this;
Object.keys(choices).forEach(function (id) {
me.addChoice(id, choices[id]);
});
}
}
Decision.prototype = Object.create(Block.prototype);
Decision.prototype.constructor = Decision;
/**
* Execute the block
* @param {Conversation} conversation
* @param {*} message
* @return {Promise.<{result: *, block: Block}, Error>} next
*/
Decision.prototype.execute = function (conversation, message) {
var me = this;
var id = this.decision(message, conversation.context);
var resolve = isPromise(id) ? id : Promise.resolve(id);
return resolve.then(function (id) {
var next = me.choices[id];
if (!next) {
// there is no match, fall back on the default choice
next = me.choices['default'];
}
if (!next) {
throw new Error('Block with id "' + id + '" not found');
}
return {
result: message,
block: next
};
});
};
/**
* Add a choice to the decision block.
* The choice can be a new chain of blocks. The first block of the chain
* will be triggered when the this id comes out of the decision function.
* @param {String | 'default'} id
* @param {Block} block
* @return {Decision} self
*/
Decision.prototype.addChoice = function (id, block) {
if (typeof id !== 'string') {
throw new TypeError('String expected as choice id');
}
if (!(block instanceof Block)) {
throw new TypeError('Block expected as choice');
}
if (id in this.choices) {
throw new Error('Choice with id "' + id + '" already exists');
}
// find the first block of the chain
var first = block;
while (first && first.previous) {
first = first.previous;
}
this.choices[id] = first;
return this;
};
/**
* Create a decision block and chain it to the current block.
* Returns the first block in the chain.
*
* Syntax:
*
* decide(choices)
* decide(decision, choices)
*
* Where:
*
* {Function | Object} [decision]
* When a `decision` function is provided, the
* function is invoked as decision(message, context),
* where `message` is the output from the previous
* block in the chain, and `context` is an object
* where state can be stored during a conversation.
* The function must return the id for the next
* block in the control flow, which must be
* available in the provided `choices`.
* If `decision` is not provided, the next block
* will be mapped directly from the message.
* {Object.<String, Block>} choices
* A map with the possible next blocks in the flow
* The next block is selected by the id returned
* by the decision function.
*
* There is one special id for choices: 'default'. This id is called when either
* the decision function returns an id which does not match any of the available
* choices.
*
* @param {Function | Object} arg1 Can be {function} decision or {Object} choices
* @param {Object} [arg2] choices
* @return {Block} first First block in the chain
*/
Block.prototype.decide = function (arg1, arg2) {
var decision = new Decision(arg1, arg2);
return this.then(decision);
};
module.exports = Decision;
/***/ },
/* 60 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var Promise = __webpack_require__(90).Promise;
var Block = __webpack_require__(61);
var isPromise = __webpack_require__(73).isPromise;
__webpack_require__(58); // extend Block with function then
/**
* IIf
* Create an iif block, which checks a condition and continues either with
* the trueBlock or the falseBlock. The input message is passed to the next
* block in the flow.
*
* Can be used as follows:
* - When `condition` evaluates true:
* - when `trueBlock` is provided, the flow continues with `trueBlock`
* - else, when there is a block connected to the IIf block, the flow continues
* with that block.
* - When `condition` evaluates false:
* - when `falseBlock` is provided, the flow continues with `falseBlock`
*
* Syntax:
*
* new IIf(condition, trueBlock)
* new IIf(condition, trueBlock [, falseBlock])
* new IIf(condition).then(...)
*
* @param {Function | RegExp | *} condition A condition returning true or false
* In case of a function,
* the function is invoked as
* `condition(message, context)` and
* must return a boolean. In case of
* a RegExp, condition will be tested
* to return true. In other cases,
* non-strict equality is tested on
* the input.
* @param {Block} [trueBlock]
* @param {Block} [falseBlock]
* @constructor
* @extends {Block}
*/
function IIf (condition, trueBlock, falseBlock) {
if (!(this instanceof IIf)) {
throw new SyntaxError('Constructor must be called with the new operator');
}
if (condition instanceof Function) {
this.condition = condition;
}
else if (condition instanceof RegExp) {
this.condition = function (message, context) {
return condition.test(message);
}
}
else {
this.condition = function (message, context) {
return message == condition;
}
}
if (trueBlock && !(trueBlock instanceof Block)) {
throw new TypeError('Parameter trueBlock must be a Block');
}
if (falseBlock && !(falseBlock instanceof Block)) {
throw new TypeError('Parameter falseBlock must be a Block');
}
this.trueBlock = trueBlock || null;
this.falseBlock = falseBlock || null;
}
IIf.prototype = Object.create(Block.prototype);
IIf.prototype.constructor = IIf;
/**
* Execute the block
* @param {Conversation} conversation
* @param {*} message
* @return {Promise.<{result: *, block: Block}, Error>} next
*/
IIf.prototype.execute = function (conversation, message) {
var me = this;
var condition = this.condition(message, conversation.context);
var resolve = isPromise(condition) ? condition : Promise.resolve(condition);
return resolve.then(function (condition) {
var next = condition ? (me.trueBlock || me.next) : me.falseBlock;
return {
result: message,
block: next
};
});
};
/**
* IIf
* Create an iif block, which checks a condition and continues either with
* the trueBlock or the falseBlock. The input message is passed to the next
* block in the flow.
*
* Can be used as follows:
* - When `condition` evaluates true:
* - when `trueBlock` is provided, the flow continues with `trueBlock`
* - else, when there is a block connected to the IIf block, the flow continues
* with that block.
* - When `condition` evaluates false:
* - when `falseBlock` is provided, the flow continues with `falseBlock`
*
* Syntax:
*
* new IIf(condition, trueBlock)
* new IIf(condition, trueBlock [, falseBlock])
* new IIf(condition).then(...)
*
* @param {Function | RegExp | *} condition A condition returning true or false
* In case of a function,
* the function is invoked as
* `condition(message, context)` and
* must return a boolean. In case of
* a RegExp, condition will be tested
* to return true. In other cases,
* non-strict equality is tested on
* the input.
* @param {Block} [trueBlock]
* @param {Block} [falseBlock]
* @returns {Block} Returns the created IIf block
*/
Block.prototype.iif = function (condition, trueBlock, falseBlock) {
var iif = new IIf(condition, trueBlock, falseBlock);
return this.then(iif);
};
module.exports = IIf;
/***/ },
/* 61 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
/**
* Abstract control flow diagram block
* @constructor
*/
function Block() {
this.next = null;
this.previous = null;
}
/**
* Execute the block
* @param {Conversation} conversation
* @param {*} message
* @return {Promise.<{result: *, block: Block}, Error>} next
*/
Block.prototype.execute = function (conversation, message) {
throw new Error('Cannot run an abstract Block');
};
module.exports = Block;
/***/ },
/* 62 */
/***/ function(module, exports, __webpack_require__) {
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
'use strict';
// If obj.hasOwnProperty has been overridden, then calling
// obj.hasOwnProperty(prop) will break.
// See: https://github.com/joyent/node/issues/1707
function hasOwnProperty(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
}
module.exports = function(qs, sep, eq, options) {
sep = sep || '&';
eq = eq || '=';
var obj = {};
if (typeof qs !== 'string' || qs.length === 0) {
return obj;
}
var regexp = /\+/g;
qs = qs.split(sep);
var maxKeys = 1000;
if (options && typeof options.maxKeys === 'number') {
maxKeys = options.maxKeys;
}
var len = qs.length;
// maxKeys <= 0 means that we should not limit keys count
if (maxKeys > 0 && len > maxKeys) {
len = maxKeys;
}
for (var i = 0; i < len; ++i) {
var x = qs[i].replace(regexp, '%20'),
idx = x.indexOf(eq),
kstr, vstr, k, v;
if (idx >= 0) {
kstr = x.substr(0, idx);
vstr = x.substr(idx + 1);
} else {
kstr = x;
vstr = '';
}
k = decodeURIComponent(kstr);
v = decodeURIComponent(vstr);
if (!hasOwnProperty(obj, k)) {
obj[k] = v;
} else if (isArray(obj[k])) {
obj[k].push(v);
} else {
obj[k] = [obj[k], v];
}
}
return obj;
};
var isArray = Array.isArray || function (xs) {
return Object.prototype.toString.call(xs) === '[object Array]';
};
/***/ },
/* 63 */
/***/ function(module, exports, __webpack_require__) {
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
'use strict';
var stringifyPrimitive = function(v) {
switch (typeof v) {
case 'string':
return v;
case 'boolean':
return v ? 'true' : 'false';
case 'number':
return isFinite(v) ? v : '';
default:
return '';
}
};
module.exports = function(obj, sep, eq, name) {
sep = sep || '&';
eq = eq || '=';
if (obj === null) {
obj = undefined;
}
if (typeof obj === 'object') {
return map(objectKeys(obj), function(k) {
var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
if (isArray(obj[k])) {
return map(obj[k], function(v) {
return ks + encodeURIComponent(stringifyPrimitive(v));
}).join(sep);
} else {
return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
}
}).join(sep);
}
if (!name) return '';
return encodeURIComponent(stringifyPrimitive(name)) + eq +
encodeURIComponent(stringifyPrimitive(obj));
};
var isArray = Array.isArray || function (xs) {
return Object.prototype.toString.call(xs) === '[object Array]';
};
function map (xs, f) {
if (xs.map) return xs.map(f);
var res = [];
for (var i = 0; i < xs.length; i++) {
res.push(f(xs[i], i));
}
return res;
}
var objectKeys = Object.keys || function (obj) {
var res = [];
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
}
return res;
};
/***/ },
/* 64 */
/***/ function(module, exports, __webpack_require__) {
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
module.exports = Stream;
var EE = __webpack_require__(44).EventEmitter;
var inherits = __webpack_require__(101);
inherits(Stream, EE);
Stream.Readable = __webpack_require__(93);
Stream.Writable = __webpack_require__(94);
Stream.Duplex = __webpack_require__(95);
Stream.Transform = __webpack_require__(96);
Stream.PassThrough = __webpack_require__(97);
// Backwards-compat with node 0.4.x
Stream.Stream = Stream;
// old-style streams. Note that the pipe method (the only relevant
// part of this class) is overridden in the Readable class.
function Stream() {
EE.call(this);
}
Stream.prototype.pipe = function(dest, options) {
var source = this;
function ondata(chunk) {
if (dest.writable) {
if (false === dest.write(chunk) && source.pause) {
source.pause();
}
}
}
source.on('data', ondata);
function ondrain() {
if (source.readable && source.resume) {
source.resume();
}
}
dest.on('drain', ondrain);
// If the 'end' option is not supplied, dest.end() will be called when
// source gets the 'end' or 'close' events. Only dest.end() once.
if (!dest._isStdio && (!options || options.end !== false)) {
source.on('end', onend);
source.on('close', onclose);
}
var didOnEnd = false;
function onend() {
if (didOnEnd) return;
didOnEnd = true;
dest.end();
}
function onclose() {
if (didOnEnd) return;
didOnEnd = true;
if (typeof dest.destroy === 'function') dest.destroy();
}
// don't leave dangling pipes when there are errors.
function onerror(er) {
cleanup();
if (EE.listenerCount(this, 'error') === 0) {
throw er; // Unhandled stream error in pipe.
}
}
source.on('error', onerror);
dest.on('error', onerror);
// remove all the event listeners that were added.
function cleanup() {
source.removeListener('data', ondata);
dest.removeListener('drain', ondrain);
source.removeListener('end', onend);
source.removeListener('close', onclose);
source.removeListener('error', onerror);
dest.removeListener('error', onerror);
source.removeListener('end', cleanup);
source.removeListener('close', cleanup);
dest.removeListener('close', cleanup);
}
source.on('end', cleanup);
source.on('close', cleanup);
dest.on('close', cleanup);
dest.emit('pipe', source);
// Allow for unix-like usage: A.pipe(B).pipe(C)
return dest;
};
/***/ },
/* 65 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(global, Buffer) {(function() {
var g = ('undefined' === typeof window ? global : window) || {}
_crypto = (
g.crypto || g.msCrypto || __webpack_require__(78)
)
module.exports = function(size) {
// Modern Browsers
if(_crypto.getRandomValues) {
var bytes = new Buffer(size); //in browserify, this is an extended Uint8Array
/* This will not work in older browsers.
* See https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
*/
_crypto.getRandomValues(bytes);
return bytes;
}
else if (_crypto.randomBytes) {
return _crypto.randomBytes(size)
}
else
throw new Error(
'secure random number generation not supported by this browser\n'+
'use chrome, FireFox or Internet Explorer 11'
)
}
}())
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(47).Buffer))
/***/ },
/* 66 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {var createHash = __webpack_require__(92)
var md5 = toConstructor(__webpack_require__(82))
var rmd160 = toConstructor(__webpack_require__(102))
function toConstructor (fn) {
return function () {
var buffers = []
var m= {
update: function (data, enc) {
if(!Buffer.isBuffer(data)) data = new Buffer(data, enc)
buffers.push(data)
return this
},
digest: function (enc) {
var buf = Buffer.concat(buffers)
var r = fn(buf)
buffers = null
return enc ? r.toString(enc) : r
}
}
return m
}
}
module.exports = function (alg) {
if('md5' === alg) return new md5()
if('rmd160' === alg) return new rmd160()
return createHash(alg)
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 67 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {var createHash = __webpack_require__(66)
var zeroBuffer = new Buffer(128)
zeroBuffer.fill(0)
module.exports = Hmac
function Hmac (alg, key) {
if(!(this instanceof Hmac)) return new Hmac(alg, key)
this._opad = opad
this._alg = alg
var blocksize = (alg === 'sha512') ? 128 : 64
key = this._key = !Buffer.isBuffer(key) ? new Buffer(key) : key
if(key.length > blocksize) {
key = createHash(alg).update(key).digest()
} else if(key.length < blocksize) {
key = Buffer.concat([key, zeroBuffer], blocksize)
}
var ipad = this._ipad = new Buffer(blocksize)
var opad = this._opad = new Buffer(blocksize)
for(var i = 0; i < blocksize; i++) {
ipad[i] = key[i] ^ 0x36
opad[i] = key[i] ^ 0x5C
}
this._hash = createHash(alg).update(ipad)
}
Hmac.prototype.update = function (data, enc) {
this._hash.update(data, enc)
return this
}
Hmac.prototype.digest = function (enc) {
var h = this._hash.digest()
return createHash(this._alg).update(this._opad).update(h).digest(enc)
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 68 */
/***/ function(module, exports, __webpack_require__) {
var pbkdf2Export = __webpack_require__(100)
module.exports = function (crypto, exports) {
exports = exports || {}
var exported = pbkdf2Export(crypto)
exports.pbkdf2 = exported.pbkdf2
exports.pbkdf2Sync = exported.pbkdf2Sync
return exports
}
/***/ },
/* 69 */
/***/ function(module, exports, __webpack_require__) {
var uuid = __webpack_require__(85);
var Promise = __webpack_require__(90).Promise;
/**
* A conversation
* Holds meta data for a conversation between two peers
* @param {Object} [config] Configuration options:
* {string} [id] A unique id for the conversation. If not provided, a uuid is generated
* {string} self Id of the peer on this side of the conversation
* {string} other Id of the peer on the other side of the conversation
* {Object} [context] Context passed with all callbacks of the conversation
* {function(to: string, message: *): Promise} send Function to send a message
* @constructor
*/
function Conversation (config) {
if (!(this instanceof Conversation)) {
throw new SyntaxError('Constructor must be called with the new operator');
}
// public properties
this.id = config && config.id || uuid.v4();
this.self = config && config.self || null;
this.other = config && config.other || null;
this.context = config && config.context || {};
// private properties
this._send = config && config.send || null;
this._inbox = []; // queue with received but not yet picked messages
this._receivers = []; // queue with handlers waiting for a new message
}
/**
* Send a message
* @param {*} message
* @return {Promise.<null>} Resolves when the message has been sent
*/
Conversation.prototype.send = function (message) {
return this._send(this.other, {
id: this.id,
from: this.self,
to: this.other,
message: message
});
};
/**
* Deliver a message
* @param {{id: string, from: string, to: string, message: string}} envelope
*/
Conversation.prototype.deliver = function (envelope) {
if (this._receivers.length) {
var receiver = this._receivers.shift();
receiver(envelope.message);
}
else {
this._inbox.push(envelope.message);
}
};
/**
* Receive a message.
* @returns {Promise.<*>} Resolves with a message as soon as a message
* is delivered.
*/
Conversation.prototype.receive = function () {
var me = this;
if (this._inbox.length) {
return Promise.resolve(this._inbox.shift());
}
else {
return new Promise(function (resolve) {
me._receivers.push(resolve);
})
}
};
module.exports = Conversation;
/***/ },
/* 70 */
/***/ function(module, exports, __webpack_require__) {
;(function () {
var object = true ? exports : this; // #8: web workers
var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
function InvalidCharacterError(message) {
this.message = message;
}
InvalidCharacterError.prototype = new Error;
InvalidCharacterError.prototype.name = 'InvalidCharacterError';
// encoder
// [https://gist.github.com/999166] by [https://github.com/nignag]
object.btoa || (
object.btoa = function (input) {
for (
// initialize result and counter
var block, charCode, idx = 0, map = chars, output = '';
// if the next input index does not exist:
// change the mapping table to "="
// check if d has no fractional digits
input.charAt(idx | 0) || (map = '=', idx % 1);
// "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8
output += map.charAt(63 & block >> 8 - idx % 1 * 8)
) {
charCode = input.charCodeAt(idx += 3/4);
if (charCode > 0xFF) {
throw new InvalidCharacterError("'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.");
}
block = block << 8 | charCode;
}
return output;
});
// decoder
// [https://gist.github.com/1020396] by [https://github.com/atk]
object.atob || (
object.atob = function (input) {
input = input.replace(/=+$/, '');
if (input.length % 4 == 1) {
throw new InvalidCharacterError("'atob' failed: The string to be decoded is not correctly encoded.");
}
for (
// initialize result and counters
var bc = 0, bs, buffer, idx = 0, output = '';
// get next character
buffer = input.charAt(idx++);
// character found in table? initialize bit storage and add its ascii value;
~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,
// and if not first of each 4 characters,
// convert the first 8 bits to one ascii character
bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0
) {
// try to find character in table (0-63, not found => -1)
buffer = chars.indexOf(buffer);
}
return output;
});
}());
/***/ },
/* 71 */
/***/ function(module, exports, __webpack_require__) {
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
};
} else {
// old school shim for old browsers
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
TempCtor.prototype = superCtor.prototype
ctor.prototype = new TempCtor()
ctor.prototype.constructor = ctor
}
}
/***/ },
/* 72 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {
// Use the fastest possible means to execute a task in a future turn
// of the event loop.
// linked list of tasks (single, with head node)
var head = {task: void 0, next: null};
var tail = head;
var flushing = false;
var requestFlush = void 0;
var isNodeJS = false;
function flush() {
/* jshint loopfunc: true */
while (head.next) {
head = head.next;
var task = head.task;
head.task = void 0;
var domain = head.domain;
if (domain) {
head.domain = void 0;
domain.enter();
}
try {
task();
} catch (e) {
if (isNodeJS) {
// In node, uncaught exceptions are considered fatal errors.
// Re-throw them synchronously to interrupt flushing!
// Ensure continuation if the uncaught exception is suppressed
// listening "uncaughtException" events (as domains does).
// Continue in next event to avoid tick recursion.
if (domain) {
domain.exit();
}
setTimeout(flush, 0);
if (domain) {
domain.enter();
}
throw e;
} else {
// In browsers, uncaught exceptions are not fatal.
// Re-throw them asynchronously to avoid slow-downs.
setTimeout(function() {
throw e;
}, 0);
}
}
if (domain) {
domain.exit();
}
}
flushing = false;
}
if (typeof process !== "undefined" && process.nextTick) {
// Node.js before 0.9. Note that some fake-Node environments, like the
// Mocha test runner, introduce a `process` global without a `nextTick`.
isNodeJS = true;
requestFlush = function () {
process.nextTick(flush);
};
} else if (typeof setImmediate === "function") {
// In IE10, Node.js 0.9+, or https://github.com/NobleJS/setImmediate
if (typeof window !== "undefined") {
requestFlush = setImmediate.bind(window, flush);
} else {
requestFlush = function () {
setImmediate(flush);
};
}
} else if (typeof MessageChannel !== "undefined") {
// modern browsers
// http://www.nonblocking.io/2011/06/windownexttick.html
var channel = new MessageChannel();
channel.port1.onmessage = flush;
requestFlush = function () {
channel.port2.postMessage(0);
};
} else {
// old browsers
requestFlush = function () {
setTimeout(flush, 0);
};
}
function asap(task) {
tail = tail.next = {
task: task,
domain: isNodeJS && process.domain,
next: null
};
if (!flushing) {
flushing = true;
requestFlush();
}
};
module.exports = asap;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(99)))
/***/ },
/* 73 */
/***/ function(module, exports, __webpack_require__) {
/**
* Test whether the provided value is a Promise.
* A value is marked as a Promise when it is an object containing functions
* `then` and `catch`.
* @param {*} value
* @return {boolean} Returns true when `value` is a Promise
*/
exports.isPromise = function (value) {
return value &&
typeof value['then'] === 'function' &&
typeof value['catch'] === 'function'
};
/***/ },
/* 74 */
/***/ function(module, exports, __webpack_require__) {
var __WEBPACK_AMD_DEFINE_RESULT__;// uuid.js
//
// Copyright (c) 2010-2012 Robert Kieffer
// MIT License - http://opensource.org/licenses/mit-license.php
(function() {
var _global = this;
// Unique ID creation requires a high quality random # generator. We feature
// detect to determine the best RNG source, normalizing to a function that
// returns 128-bits of randomness, since that's what's usually required
var _rng;
// Node.js crypto-based RNG - http://nodejs.org/docs/v0.6.2/api/crypto.html
//
// Moderately fast, high quality
if (typeof(_global.require) == 'function') {
try {
var _rb = _global.require('crypto').randomBytes;
_rng = _rb && function() {return _rb(16);};
} catch(e) {}
}
if (!_rng && _global.crypto && crypto.getRandomValues) {
// WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
//
// Moderately fast, high quality
var _rnds8 = new Uint8Array(16);
_rng = function whatwgRNG() {
crypto.getRandomValues(_rnds8);
return _rnds8;
};
}
if (!_rng) {
// Math.random()-based (RNG)
//
// If all else fails, use Math.random(). It's fast, but is of unspecified
// quality.
var _rnds = new Array(16);
_rng = function() {
for (var i = 0, r; i < 16; i++) {
if ((i & 0x03) === 0) r = Math.random() * 0x100000000;
_rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
}
return _rnds;
};
}
// Buffer class to use
var BufferClass = typeof(_global.Buffer) == 'function' ? _global.Buffer : Array;
// Maps for number <-> hex string conversion
var _byteToHex = [];
var _hexToByte = {};
for (var i = 0; i < 256; i++) {
_byteToHex[i] = (i + 0x100).toString(16).substr(1);
_hexToByte[_byteToHex[i]] = i;
}
// **`parse()` - Parse a UUID into it's component bytes**
function parse(s, buf, offset) {
var i = (buf && offset) || 0, ii = 0;
buf = buf || [];
s.toLowerCase().replace(/[0-9a-f]{2}/g, function(oct) {
if (ii < 16) { // Don't overflow!
buf[i + ii++] = _hexToByte[oct];
}
});
// Zero out remaining bytes if string was short
while (ii < 16) {
buf[i + ii++] = 0;
}
return buf;
}
// **`unparse()` - Convert UUID byte array (ala parse()) into a string**
function unparse(buf, offset) {
var i = offset || 0, bth = _byteToHex;
return bth[buf[i++]] + bth[buf[i++]] +
bth[buf[i++]] + bth[buf[i++]] + '-' +
bth[buf[i++]] + bth[buf[i++]] + '-' +
bth[buf[i++]] + bth[buf[i++]] + '-' +
bth[buf[i++]] + bth[buf[i++]] + '-' +
bth[buf[i++]] + bth[buf[i++]] +
bth[buf[i++]] + bth[buf[i++]] +
bth[buf[i++]] + bth[buf[i++]];
}
// **`v1()` - Generate time-based UUID**
//
// Inspired by https://github.com/LiosK/UUID.js
// and http://docs.python.org/library/uuid.html
// random #'s we need to init node and clockseq
var _seedBytes = _rng();
// Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
var _nodeId = [
_seedBytes[0] | 0x01,
_seedBytes[1], _seedBytes[2], _seedBytes[3], _seedBytes[4], _seedBytes[5]
];
// Per 4.2.2, randomize (14 bit) clockseq
var _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
// Previous uuid creation time
var _lastMSecs = 0, _lastNSecs = 0;
// See https://github.com/broofa/node-uuid for API details
function v1(options, buf, offset) {
var i = buf && offset || 0;
var b = buf || [];
options = options || {};
var clockseq = options.clockseq != null ? options.clockseq : _clockseq;
// UUID timestamps are 100 nano-second units since the Gregorian epoch,
// (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
// time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
// (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
var msecs = options.msecs != null ? options.msecs : new Date().getTime();
// Per 4.2.1.2, use count of uuid's generated during the current clock
// cycle to simulate higher resolution clock
var nsecs = options.nsecs != null ? options.nsecs : _lastNSecs + 1;
// Time since last uuid creation (in msecs)
var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;
// Per 4.2.1.2, Bump clockseq on clock regression
if (dt < 0 && options.clockseq == null) {
clockseq = clockseq + 1 & 0x3fff;
}
// Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
// time interval
if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) {
nsecs = 0;
}
// Per 4.2.1.2 Throw error if too many uuids are requested
if (nsecs >= 10000) {
throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec');
}
_lastMSecs = msecs;
_lastNSecs = nsecs;
_clockseq = clockseq;
// Per 4.1.4 - Convert from unix epoch to Gregorian epoch
msecs += 12219292800000;
// `time_low`
var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
b[i++] = tl >>> 24 & 0xff;
b[i++] = tl >>> 16 & 0xff;
b[i++] = tl >>> 8 & 0xff;
b[i++] = tl & 0xff;
// `time_mid`
var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
b[i++] = tmh >>> 8 & 0xff;
b[i++] = tmh & 0xff;
// `time_high_and_version`
b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
b[i++] = tmh >>> 16 & 0xff;
// `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
b[i++] = clockseq >>> 8 | 0x80;
// `clock_seq_low`
b[i++] = clockseq & 0xff;
// `node`
var node = options.node || _nodeId;
for (var n = 0; n < 6; n++) {
b[i + n] = node[n];
}
return buf ? buf : unparse(b);
}
// **`v4()` - Generate random UUID**
// See https://github.com/broofa/node-uuid for API details
function v4(options, buf, offset) {
// Deprecated - 'format' argument, as supported in v1.2
var i = buf && offset || 0;
if (typeof(options) == 'string') {
buf = options == 'binary' ? new BufferClass(16) : null;
options = null;
}
options = options || {};
var rnds = options.random || (options.rng || _rng)();
// Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
rnds[6] = (rnds[6] & 0x0f) | 0x40;
rnds[8] = (rnds[8] & 0x3f) | 0x80;
// Copy bytes to buffer, if provided
if (buf) {
for (var ii = 0; ii < 16; ii++) {
buf[i + ii] = rnds[ii];
}
}
return buf || unparse(rnds);
}
// Export public API
var uuid = v4;
uuid.v1 = v1;
uuid.v4 = v4;
uuid.parse = parse;
uuid.unparse = unparse;
uuid.BufferClass = BufferClass;
if (true) {
// Publish as AMD module
!(__WEBPACK_AMD_DEFINE_RESULT__ = function() {return uuid;}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
} else if (typeof(module) != 'undefined' && module.exports) {
// Publish as node.js module
module.exports = uuid;
} else {
// Publish as global (in browsers)
var _previousRoot = _global.uuid;
// **`noConflict()` - (browser only) to reset global 'uuid' var**
uuid.noConflict = function() {
_global.uuid = _previousRoot;
return uuid;
};
_global.uuid = uuid;
}
}).call(this);
/***/ },
/* 75 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**!
* agentkeepalive - lib/agent.js
*
* refer:
* * @atimb "Real keep-alive HTTP agent": https://gist.github.com/2963672
* * https://github.com/joyent/node/blob/master/lib/http.js
* * https://github.com/joyent/node/blob/master/lib/_http_agent.js
*
* Copyright(c) 2012 - 2013 fengmk2 <fengmk2@gmail.com>
* MIT Licensed
*/
"use strict";
/**
* Module dependencies.
*/
var http = __webpack_require__(30);
var https = __webpack_require__(46);
var util = __webpack_require__(79);
var debug;
if (process.env.NODE_DEBUG && /agentkeepalive/.test(process.env.NODE_DEBUG)) {
debug = function (x) {
console.error.apply(console, arguments);
};
} else {
debug = function () { };
}
var OriginalAgent = http.Agent;
if (process.version.indexOf('v0.8.') === 0 || process.version.indexOf('v0.10.') === 0) {
OriginalAgent = __webpack_require__(88).Agent;
debug('%s use _http_agent', process.version);
}
function Agent(options) {
options = options || {};
options.keepAlive = options.keepAlive !== false;
options.keepAliveMsecs = options.keepAliveMsecs || options.maxKeepAliveTime;
OriginalAgent.call(this, options);
var self = this;
// max requests per keepalive socket, default is 0, no limit.
self.maxKeepAliveRequests = parseInt(options.maxKeepAliveRequests, 10) || 0;
// max keep alive time, default 60 seconds.
// if set `keepAliveMsecs = 0`, will disable keepalive feature.
self.createSocketCount = 0;
self.timeoutSocketCount = 0;
self.requestFinishedCount = 0;
// override the `free` event listener
self.removeAllListeners('free');
self.on('free', function (socket, options) {
self.requestFinishedCount++;
socket._requestCount++;
var name = self.getName(options);
debug('agent.on(free)', name);
if (!self.isDestroyed(socket) &&
self.requests[name] && self.requests[name].length) {
self.requests[name].shift().onSocket(socket);
if (self.requests[name].length === 0) {
// don't leak
delete self.requests[name];
}
} else {
// If there are no pending requests, then put it in
// the freeSockets pool, but only if we're allowed to do so.
var req = socket._httpMessage;
if (req &&
req.shouldKeepAlive &&
!self.isDestroyed(socket) &&
self.options.keepAlive) {
var freeSockets = self.freeSockets[name];
var freeLen = freeSockets ? freeSockets.length : 0;
var count = freeLen;
if (self.sockets[name])
count += self.sockets[name].length;
if (count >= self.maxSockets || freeLen >= self.maxFreeSockets) {
self.removeSocket(socket, options);
socket.destroy();
} else {
freeSockets = freeSockets || [];
self.freeSockets[name] = freeSockets;
socket.setKeepAlive(true, self.keepAliveMsecs);
socket.unref && socket.unref();
socket._httpMessage = null;
self.removeSocket(socket, options);
freeSockets.push(socket);
// Avoid duplicitive timeout events by removing timeout listeners set on
// socket by previous requests. node does not do this normally because it
// assumes sockets are too short-lived for it to matter. It becomes a
// problem when sockets are being reused. Steps are being taken to fix
// this issue upstream in node v0.10.0.
//
// See https://github.com/joyent/node/commit/451ff1540ab536237e8d751d241d7fc3391a4087
if (self.keepAliveMsecs && socket._events && Array.isArray(socket._events.timeout)) {
socket.removeAllListeners('timeout');
// Restore the socket's setTimeout() that was remove as collateral
// damage.
socket.setTimeout(self.keepAliveMsecs, socket._maxKeepAliveTimeout);
}
}
} else {
self.removeSocket(socket, options);
socket.destroy();
}
}
});
}
util.inherits(Agent, OriginalAgent);
module.exports = Agent;
Agent.prototype.createSocket = function (req, options) {
var self = this;
var socket = OriginalAgent.prototype.createSocket.call(this, req, options);
socket._requestCount = 0;
if (self.keepAliveMsecs) {
socket._maxKeepAliveTimeout = function () {
debug('maxKeepAliveTimeout, socket destroy()');
socket.destroy();
self.timeoutSocketCount++;
};
socket.setTimeout(self.keepAliveMsecs, socket._maxKeepAliveTimeout);
// Disable Nagle's algorithm: http://blog.caustik.com/2012/04/08/scaling-node-js-to-100k-concurrent-connections/
socket.setNoDelay(true);
}
this.createSocketCount++;
return socket;
};
Agent.prototype.removeSocket = function (s, options) {
OriginalAgent.prototype.removeSocket.call(this, s, options);
var name = this.getName(options);
debug('removeSocket', name, 'destroyed:', this.isDestroyed(s));
if (this.isDestroyed(s) && this.freeSockets[name]) {
var index = this.freeSockets[name].indexOf(s);
if (index !== -1) {
this.freeSockets[name].splice(index, 1);
if (this.freeSockets[name].length === 0) {
// don't leak
delete this.freeSockets[name];
}
}
}
};
function HttpsAgent(options) {
Agent.call(this, options);
this.defaultPort = 443;
this.protocol = 'https:';
}
util.inherits(HttpsAgent, Agent);
HttpsAgent.prototype.createConnection = https.globalAgent.createConnection;
HttpsAgent.prototype.getName = function(options) {
var name = Agent.prototype.getName.call(this, options);
name += ':';
if (options.ca)
name += options.ca;
name += ':';
if (options.cert)
name += options.cert;
name += ':';
if (options.ciphers)
name += options.ciphers;
name += ':';
if (options.key)
name += options.key;
name += ':';
if (options.pfx)
name += options.pfx;
name += ':';
if (options.rejectUnauthorized !== undefined)
name += options.rejectUnauthorized;
return name;
};
Agent.HttpsAgent = HttpsAgent;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(99)))
/***/ },
/* 76 */
/***/ function(module, exports, __webpack_require__) {
/**
* Module dependencies.
*/
var global = (function() { return this; })();
/**
* WebSocket constructor.
*/
var WebSocket = global.WebSocket || global.MozWebSocket;
/**
* Module exports.
*/
module.exports = WebSocket ? ws : null;
/**
* WebSocket constructor.
*
* The third `opts` options object gets ignored in web browsers, since it's
* non-standard, and throws a TypeError if passed to the constructor.
* See: https://github.com/einaros/ws/issues/227
*
* @param {String} uri
* @param {Array} protocols (optional)
* @param {Object) opts (optional)
* @api public
*/
function ws(uri, protocols, opts) {
var instance;
if (protocols) {
instance = new WebSocket(uri, protocols);
} else {
instance = new WebSocket(uri);
}
return instance;
}
if (WebSocket) ws.prototype = WebSocket.prototype;
/***/ },
/* 77 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
var Promise = __webpack_require__(91)();
module.exports = Promise;
/***/ },
/* 78 */
/***/ function(module, exports, __webpack_require__) {
/* (ignored) */
/***/ },
/* 79 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(global, process) {// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var formatRegExp = /%[sdj%]/g;
exports.format = function(f) {
if (!isString(f)) {
var objects = [];
for (var i = 0; i < arguments.length; i++) {
objects.push(inspect(arguments[i]));
}
return objects.join(' ');
}
var i = 1;
var args = arguments;
var len = args.length;
var str = String(f).replace(formatRegExp, function(x) {
if (x === '%%') return '%';
if (i >= len) return x;
switch (x) {
case '%s': return String(args[i++]);
case '%d': return Number(args[i++]);
case '%j':
try {
return JSON.stringify(args[i++]);
} catch (_) {
return '[Circular]';
}
default:
return x;
}
});
for (var x = args[i]; i < len; x = args[++i]) {
if (isNull(x) || !isObject(x)) {
str += ' ' + x;
} else {
str += ' ' + inspect(x);
}
}
return str;
};
// Mark that a method should not be used.
// Returns a modified function which warns once by default.
// If --no-deprecation is set, then it is a no-op.
exports.deprecate = function(fn, msg) {
// Allow for deprecating things in the process of starting up.
if (isUndefined(global.process)) {
return function() {
return exports.deprecate(fn, msg).apply(this, arguments);
};
}
if (process.noDeprecation === true) {
return fn;
}
var warned = false;
function deprecated() {
if (!warned) {
if (process.throwDeprecation) {
throw new Error(msg);
} else if (process.traceDeprecation) {
console.trace(msg);
} else {
console.error(msg);
}
warned = true;
}
return fn.apply(this, arguments);
}
return deprecated;
};
var debugs = {};
var debugEnviron;
exports.debuglog = function(set) {
if (isUndefined(debugEnviron))
debugEnviron = process.env.NODE_DEBUG || '';
set = set.toUpperCase();
if (!debugs[set]) {
if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
var pid = process.pid;
debugs[set] = function() {
var msg = exports.format.apply(exports, arguments);
console.error('%s %d: %s', set, pid, msg);
};
} else {
debugs[set] = function() {};
}
}
return debugs[set];
};
/**
* Echos the value of a value. Trys to print the value out
* in the best way possible given the different types.
*
* @param {Object} obj The object to print out.
* @param {Object} opts Optional options object that alters the output.
*/
/* legacy: obj, showHidden, depth, colors*/
function inspect(obj, opts) {
// default options
var ctx = {
seen: [],
stylize: stylizeNoColor
};
// legacy...
if (arguments.length >= 3) ctx.depth = arguments[2];
if (arguments.length >= 4) ctx.colors = arguments[3];
if (isBoolean(opts)) {
// legacy...
ctx.showHidden = opts;
} else if (opts) {
// got an "options" object
exports._extend(ctx, opts);
}
// set default options
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
if (isUndefined(ctx.depth)) ctx.depth = 2;
if (isUndefined(ctx.colors)) ctx.colors = false;
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
if (ctx.colors) ctx.stylize = stylizeWithColor;
return formatValue(ctx, obj, ctx.depth);
}
exports.inspect = inspect;
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
inspect.colors = {
'bold' : [1, 22],
'italic' : [3, 23],
'underline' : [4, 24],
'inverse' : [7, 27],
'white' : [37, 39],
'grey' : [90, 39],
'black' : [30, 39],
'blue' : [34, 39],
'cyan' : [36, 39],
'green' : [32, 39],
'magenta' : [35, 39],
'red' : [31, 39],
'yellow' : [33, 39]
};
// Don't use 'blue' not visible on cmd.exe
inspect.styles = {
'special': 'cyan',
'number': 'yellow',
'boolean': 'yellow',
'undefined': 'grey',
'null': 'bold',
'string': 'green',
'date': 'magenta',
// "name": intentionally not styling
'regexp': 'red'
};
function stylizeWithColor(str, styleType) {
var style = inspect.styles[styleType];
if (style) {
return '\u001b[' + inspect.colors[style][0] + 'm' + str +
'\u001b[' + inspect.colors[style][1] + 'm';
} else {
return str;
}
}
function stylizeNoColor(str, styleType) {
return str;
}
function arrayToHash(array) {
var hash = {};
array.forEach(function(val, idx) {
hash[val] = true;
});
return hash;
}
function formatValue(ctx, value, recurseTimes) {
// Provide a hook for user-specified inspect functions.
// Check that value is an object with an inspect function on it
if (ctx.customInspect &&
value &&
isFunction(value.inspect) &&
// Filter out the util module, it's inspect function is special
value.inspect !== exports.inspect &&
// Also filter out any prototype objects using the circular check.
!(value.constructor && value.constructor.prototype === value)) {
var ret = value.inspect(recurseTimes, ctx);
if (!isString(ret)) {
ret = formatValue(ctx, ret, recurseTimes);
}
return ret;
}
// Primitive types cannot have properties
var primitive = formatPrimitive(ctx, value);
if (primitive) {
return primitive;
}
// Look up the keys of the object.
var keys = Object.keys(value);
var visibleKeys = arrayToHash(keys);
if (ctx.showHidden) {
keys = Object.getOwnPropertyNames(value);
}
// IE doesn't make error fields non-enumerable
// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
if (isError(value)
&& (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
return formatError(value);
}
// Some type of object without properties can be shortcutted.
if (keys.length === 0) {
if (isFunction(value)) {
var name = value.name ? ': ' + value.name : '';
return ctx.stylize('[Function' + name + ']', 'special');
}
if (isRegExp(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
}
if (isDate(value)) {
return ctx.stylize(Date.prototype.toString.call(value), 'date');
}
if (isError(value)) {
return formatError(value);
}
}
var base = '', array = false, braces = ['{', '}'];
// Make Array say that they are Array
if (isArray(value)) {
array = true;
braces = ['[', ']'];
}
// Make functions say that they are functions
if (isFunction(value)) {
var n = value.name ? ': ' + value.name : '';
base = ' [Function' + n + ']';
}
// Make RegExps say that they are RegExps
if (isRegExp(value)) {
base = ' ' + RegExp.prototype.toString.call(value);
}
// Make dates with properties first say the date
if (isDate(value)) {
base = ' ' + Date.prototype.toUTCString.call(value);
}
// Make error with message first say the error
if (isError(value)) {
base = ' ' + formatError(value);
}
if (keys.length === 0 && (!array || value.length == 0)) {
return braces[0] + base + braces[1];
}
if (recurseTimes < 0) {
if (isRegExp(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
} else {
return ctx.stylize('[Object]', 'special');
}
}
ctx.seen.push(value);
var output;
if (array) {
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
} else {
output = keys.map(function(key) {
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
});
}
ctx.seen.pop();
return reduceToSingleString(output, base, braces);
}
function formatPrimitive(ctx, value) {
if (isUndefined(value))
return ctx.stylize('undefined', 'undefined');
if (isString(value)) {
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
.replace(/'/g, "\\'")
.replace(/\\"/g, '"') + '\'';
return ctx.stylize(simple, 'string');
}
if (isNumber(value))
return ctx.stylize('' + value, 'number');
if (isBoolean(value))
return ctx.stylize('' + value, 'boolean');
// For some reason typeof null is "object", so special case here.
if (isNull(value))
return ctx.stylize('null', 'null');
}
function formatError(value) {
return '[' + Error.prototype.toString.call(value) + ']';
}
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
var output = [];
for (var i = 0, l = value.length; i < l; ++i) {
if (hasOwnProperty(value, String(i))) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
String(i), true));
} else {
output.push('');
}
}
keys.forEach(function(key) {
if (!key.match(/^\d+$/)) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
key, true));
}
});
return output;
}
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
var name, str, desc;
desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
if (desc.get) {
if (desc.set) {
str = ctx.stylize('[Getter/Setter]', 'special');
} else {
str = ctx.stylize('[Getter]', 'special');
}
} else {
if (desc.set) {
str = ctx.stylize('[Setter]', 'special');
}
}
if (!hasOwnProperty(visibleKeys, key)) {
name = '[' + key + ']';
}
if (!str) {
if (ctx.seen.indexOf(desc.value) < 0) {
if (isNull(recurseTimes)) {
str = formatValue(ctx, desc.value, null);
} else {
str = formatValue(ctx, desc.value, recurseTimes - 1);
}
if (str.indexOf('\n') > -1) {
if (array) {
str = str.split('\n').map(function(line) {
return ' ' + line;
}).join('\n').substr(2);
} else {
str = '\n' + str.split('\n').map(function(line) {
return ' ' + line;
}).join('\n');
}
}
} else {
str = ctx.stylize('[Circular]', 'special');
}
}
if (isUndefined(name)) {
if (array && key.match(/^\d+$/)) {
return str;
}
name = JSON.stringify('' + key);
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
name = name.substr(1, name.length - 2);
name = ctx.stylize(name, 'name');
} else {
name = name.replace(/'/g, "\\'")
.replace(/\\"/g, '"')
.replace(/(^"|"$)/g, "'");
name = ctx.stylize(name, 'string');
}
}
return name + ': ' + str;
}
function reduceToSingleString(output, base, braces) {
var numLinesEst = 0;
var length = output.reduce(function(prev, cur) {
numLinesEst++;
if (cur.indexOf('\n') >= 0) numLinesEst++;
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
}, 0);
if (length > 60) {
return braces[0] +
(base === '' ? '' : base + '\n ') +
' ' +
output.join(',\n ') +
' ' +
braces[1];
}
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
}
// NOTE: These type checking functions intentionally don't use `instanceof`
// because it is fragile and can be easily faked with `Object.create()`.
function isArray(ar) {
return Array.isArray(ar);
}
exports.isArray = isArray;
function isBoolean(arg) {
return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;
function isNull(arg) {
return arg === null;
}
exports.isNull = isNull;
function isNullOrUndefined(arg) {
return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;
function isNumber(arg) {
return typeof arg === 'number';
}
exports.isNumber = isNumber;
function isString(arg) {
return typeof arg === 'string';
}
exports.isString = isString;
function isSymbol(arg) {
return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;
function isUndefined(arg) {
return arg === void 0;
}
exports.isUndefined = isUndefined;
function isRegExp(re) {
return isObject(re) && objectToString(re) === '[object RegExp]';
}
exports.isRegExp = isRegExp;
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;
function isDate(d) {
return isObject(d) && objectToString(d) === '[object Date]';
}
exports.isDate = isDate;
function isError(e) {
return isObject(e) &&
(objectToString(e) === '[object Error]' || e instanceof Error);
}
exports.isError = isError;
function isFunction(arg) {
return typeof arg === 'function';
}
exports.isFunction = isFunction;
function isPrimitive(arg) {
return arg === null ||
typeof arg === 'boolean' ||
typeof arg === 'number' ||
typeof arg === 'string' ||
typeof arg === 'symbol' || // ES6 symbol
typeof arg === 'undefined';
}
exports.isPrimitive = isPrimitive;
exports.isBuffer = __webpack_require__(106);
function objectToString(o) {
return Object.prototype.toString.call(o);
}
function pad(n) {
return n < 10 ? '0' + n.toString(10) : n.toString(10);
}
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
'Oct', 'Nov', 'Dec'];
// 26 Feb 16:19:34
function timestamp() {
var d = new Date();
var time = [pad(d.getHours()),
pad(d.getMinutes()),
pad(d.getSeconds())].join(':');
return [d.getDate(), months[d.getMonth()], time].join(' ');
}
// log is just a thin wrapper to console.log that prepends a timestamp
exports.log = function() {
console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
};
/**
* Inherit the prototype methods from one constructor into another.
*
* The Function.prototype.inherits from lang.js rewritten as a standalone
* function (not on Function.prototype). NOTE: If this file is to be loaded
* during bootstrapping this function needs to be rewritten using some native
* functions as prototype setup using normal JavaScript does not work as
* expected during bootstrapping (see mirror.js in r114903).
*
* @param {function} ctor Constructor function which needs to inherit the
* prototype.
* @param {function} superCtor Constructor function to inherit prototype from.
*/
exports.inherits = __webpack_require__(146);
exports._extend = function(origin, add) {
// Don't do anything if add isn't an object
if (!add || !isObject(add)) return origin;
var keys = Object.keys(add);
var i = keys.length;
while (i--) {
origin[keys[i]] = add[keys[i]];
}
return origin;
};
function hasOwnProperty(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
}
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(99)))
/***/ },
/* 80 */
/***/ function(module, exports, __webpack_require__) {
exports.read = function(buffer, offset, isLE, mLen, nBytes) {
var e, m,
eLen = nBytes * 8 - mLen - 1,
eMax = (1 << eLen) - 1,
eBias = eMax >> 1,
nBits = -7,
i = isLE ? (nBytes - 1) : 0,
d = isLE ? -1 : 1,
s = buffer[offset + i];
i += d;
e = s & ((1 << (-nBits)) - 1);
s >>= (-nBits);
nBits += eLen;
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
m = e & ((1 << (-nBits)) - 1);
e >>= (-nBits);
nBits += mLen;
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
if (e === 0) {
e = 1 - eBias;
} else if (e === eMax) {
return m ? NaN : ((s ? -1 : 1) * Infinity);
} else {
m = m + Math.pow(2, mLen);
e = e - eBias;
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
};
exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c,
eLen = nBytes * 8 - mLen - 1,
eMax = (1 << eLen) - 1,
eBias = eMax >> 1,
rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
i = isLE ? 0 : (nBytes - 1),
d = isLE ? 1 : -1,
s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
value = Math.abs(value);
if (isNaN(value) || value === Infinity) {
m = isNaN(value) ? 1 : 0;
e = eMax;
} else {
e = Math.floor(Math.log(value) / Math.LN2);
if (value * (c = Math.pow(2, -e)) < 1) {
e--;
c *= 2;
}
if (e + eBias >= 1) {
value += rt / c;
} else {
value += rt * Math.pow(2, 1 - eBias);
}
if (value * c >= 2) {
e++;
c /= 2;
}
if (e + eBias >= eMax) {
m = 0;
e = eMax;
} else if (e + eBias >= 1) {
m = (value * c - 1) * Math.pow(2, mLen);
e = e + eBias;
} else {
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
e = 0;
}
}
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);
e = (e << mLen) | m;
eLen += mLen;
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);
buffer[offset + i - d] |= s * 128;
};
/***/ },
/* 81 */
/***/ function(module, exports, __webpack_require__) {
/**
* isArray
*/
var isArray = Array.isArray;
/**
* toString
*/
var str = Object.prototype.toString;
/**
* Whether or not the given `val`
* is an array.
*
* example:
*
* isArray([]);
* // > true
* isArray(arguments);
* // > false
* isArray('');
* // > false
*
* @param {mixed} val
* @return {bool}
*/
module.exports = isArray || function (val) {
return !! val && '[object Array]' == str.call(val);
};
/***/ },
/* 82 */
/***/ function(module, exports, __webpack_require__) {
/*
* A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
* Digest Algorithm, as defined in RFC 1321.
* Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* See http://pajhome.org.uk/crypt/md5 for more info.
*/
var helpers = __webpack_require__(98);
/*
* Calculate the MD5 of an array of little-endian words, and a bit length
*/
function core_md5(x, len)
{
/* append padding */
x[len >> 5] |= 0x80 << ((len) % 32);
x[(((len + 64) >>> 9) << 4) + 14] = len;
var a = 1732584193;
var b = -271733879;
var c = -1732584194;
var d = 271733878;
for(var i = 0; i < x.length; i += 16)
{
var olda = a;
var oldb = b;
var oldc = c;
var oldd = d;
a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
c = md5_ff(c, d, a, b, x[i+ 2], 17, 606105819);
b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
d = md5_ff(d, a, b, c, x[i+ 5], 12, 1200080426);
c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
a = md5_ff(a, b, c, d, x[i+ 8], 7 , 1770035416);
d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
a = md5_ff(a, b, c, d, x[i+12], 7 , 1804603682);
d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
b = md5_ff(b, c, d, a, x[i+15], 22, 1236535329);
a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
c = md5_gg(c, d, a, b, x[i+11], 14, 643717713);
b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
d = md5_gg(d, a, b, c, x[i+10], 9 , 38016083);
c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
a = md5_gg(a, b, c, d, x[i+ 9], 5 , 568446438);
d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
b = md5_gg(b, c, d, a, x[i+ 8], 20, 1163531501);
a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
c = md5_gg(c, d, a, b, x[i+ 7], 14, 1735328473);
b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
c = md5_hh(c, d, a, b, x[i+11], 16, 1839030562);
b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
d = md5_hh(d, a, b, c, x[i+ 4], 11, 1272893353);
c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
a = md5_hh(a, b, c, d, x[i+13], 4 , 681279174);
d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
b = md5_hh(b, c, d, a, x[i+ 6], 23, 76029189);
a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
c = md5_hh(c, d, a, b, x[i+15], 16, 530742520);
b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
d = md5_ii(d, a, b, c, x[i+ 7], 10, 1126891415);
c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
a = md5_ii(a, b, c, d, x[i+12], 6 , 1700485571);
d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
a = md5_ii(a, b, c, d, x[i+ 8], 6 , 1873313359);
d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
b = md5_ii(b, c, d, a, x[i+13], 21, 1309151649);
a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
c = md5_ii(c, d, a, b, x[i+ 2], 15, 718787259);
b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
a = safe_add(a, olda);
b = safe_add(b, oldb);
c = safe_add(c, oldc);
d = safe_add(d, oldd);
}
return Array(a, b, c, d);
}
/*
* These functions implement the four basic operations the algorithm uses.
*/
function md5_cmn(q, a, b, x, s, t)
{
return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
}
function md5_ff(a, b, c, d, x, s, t)
{
return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
}
function md5_gg(a, b, c, d, x, s, t)
{
return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
}
function md5_hh(a, b, c, d, x, s, t)
{
return md5_cmn(b ^ c ^ d, a, b, x, s, t);
}
function md5_ii(a, b, c, d, x, s, t)
{
return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
}
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
function safe_add(x, y)
{
var lsw = (x & 0xFFFF) + (y & 0xFFFF);
var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
return (msw << 16) | (lsw & 0xFFFF);
}
/*
* Bitwise rotate a 32-bit number to the left.
*/
function bit_rol(num, cnt)
{
return (num << cnt) | (num >>> (32 - cnt));
}
module.exports = function md5(buf) {
return helpers.hash(buf, core_md5, 16);
};
/***/ },
/* 83 */
/***/ function(module, exports, __webpack_require__) {
module.exports = function(module) {
if(!module.webpackPolyfill) {
module.deprecate = function() {};
module.paths = [];
// module.parent = undefined by default
module.children = [];
module.webpackPolyfill = 1;
}
return module;
}
/***/ },
/* 84 */
/***/ function(module, exports, __webpack_require__) {
module.exports = function (crypto, exports) {
exports = exports || {};
var ciphers = __webpack_require__(103)(crypto);
exports.createCipher = ciphers.createCipher;
exports.createCipheriv = ciphers.createCipheriv;
var deciphers = __webpack_require__(104)(crypto);
exports.createDecipher = deciphers.createDecipher;
exports.createDecipheriv = deciphers.createDecipheriv;
var modes = __webpack_require__(105);
function listCiphers () {
return Object.keys(modes);
}
exports.listCiphers = listCiphers;
};
/***/ },
/* 85 */
/***/ function(module, exports, __webpack_require__) {
var __WEBPACK_AMD_DEFINE_RESULT__;// uuid.js
//
// Copyright (c) 2010-2012 Robert Kieffer
// MIT License - http://opensource.org/licenses/mit-license.php
(function() {
var _global = this;
// Unique ID creation requires a high quality random # generator. We feature
// detect to determine the best RNG source, normalizing to a function that
// returns 128-bits of randomness, since that's what's usually required
var _rng;
// Node.js crypto-based RNG - http://nodejs.org/docs/v0.6.2/api/crypto.html
//
// Moderately fast, high quality
if (typeof(_global.require) == 'function') {
try {
var _rb = _global.require('crypto').randomBytes;
_rng = _rb && function() {return _rb(16);};
} catch(e) {}
}
if (!_rng && _global.crypto && crypto.getRandomValues) {
// WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
//
// Moderately fast, high quality
var _rnds8 = new Uint8Array(16);
_rng = function whatwgRNG() {
crypto.getRandomValues(_rnds8);
return _rnds8;
};
}
if (!_rng) {
// Math.random()-based (RNG)
//
// If all else fails, use Math.random(). It's fast, but is of unspecified
// quality.
var _rnds = new Array(16);
_rng = function() {
for (var i = 0, r; i < 16; i++) {
if ((i & 0x03) === 0) r = Math.random() * 0x100000000;
_rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
}
return _rnds;
};
}
// Buffer class to use
var BufferClass = typeof(_global.Buffer) == 'function' ? _global.Buffer : Array;
// Maps for number <-> hex string conversion
var _byteToHex = [];
var _hexToByte = {};
for (var i = 0; i < 256; i++) {
_byteToHex[i] = (i + 0x100).toString(16).substr(1);
_hexToByte[_byteToHex[i]] = i;
}
// **`parse()` - Parse a UUID into it's component bytes**
function parse(s, buf, offset) {
var i = (buf && offset) || 0, ii = 0;
buf = buf || [];
s.toLowerCase().replace(/[0-9a-f]{2}/g, function(oct) {
if (ii < 16) { // Don't overflow!
buf[i + ii++] = _hexToByte[oct];
}
});
// Zero out remaining bytes if string was short
while (ii < 16) {
buf[i + ii++] = 0;
}
return buf;
}
// **`unparse()` - Convert UUID byte array (ala parse()) into a string**
function unparse(buf, offset) {
var i = offset || 0, bth = _byteToHex;
return bth[buf[i++]] + bth[buf[i++]] +
bth[buf[i++]] + bth[buf[i++]] + '-' +
bth[buf[i++]] + bth[buf[i++]] + '-' +
bth[buf[i++]] + bth[buf[i++]] + '-' +
bth[buf[i++]] + bth[buf[i++]] + '-' +
bth[buf[i++]] + bth[buf[i++]] +
bth[buf[i++]] + bth[buf[i++]] +
bth[buf[i++]] + bth[buf[i++]];
}
// **`v1()` - Generate time-based UUID**
//
// Inspired by https://github.com/LiosK/UUID.js
// and http://docs.python.org/library/uuid.html
// random #'s we need to init node and clockseq
var _seedBytes = _rng();
// Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
var _nodeId = [
_seedBytes[0] | 0x01,
_seedBytes[1], _seedBytes[2], _seedBytes[3], _seedBytes[4], _seedBytes[5]
];
// Per 4.2.2, randomize (14 bit) clockseq
var _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
// Previous uuid creation time
var _lastMSecs = 0, _lastNSecs = 0;
// See https://github.com/broofa/node-uuid for API details
function v1(options, buf, offset) {
var i = buf && offset || 0;
var b = buf || [];
options = options || {};
var clockseq = options.clockseq != null ? options.clockseq : _clockseq;
// UUID timestamps are 100 nano-second units since the Gregorian epoch,
// (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
// time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
// (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
var msecs = options.msecs != null ? options.msecs : new Date().getTime();
// Per 4.2.1.2, use count of uuid's generated during the current clock
// cycle to simulate higher resolution clock
var nsecs = options.nsecs != null ? options.nsecs : _lastNSecs + 1;
// Time since last uuid creation (in msecs)
var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;
// Per 4.2.1.2, Bump clockseq on clock regression
if (dt < 0 && options.clockseq == null) {
clockseq = clockseq + 1 & 0x3fff;
}
// Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
// time interval
if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) {
nsecs = 0;
}
// Per 4.2.1.2 Throw error if too many uuids are requested
if (nsecs >= 10000) {
throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec');
}
_lastMSecs = msecs;
_lastNSecs = nsecs;
_clockseq = clockseq;
// Per 4.1.4 - Convert from unix epoch to Gregorian epoch
msecs += 12219292800000;
// `time_low`
var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
b[i++] = tl >>> 24 & 0xff;
b[i++] = tl >>> 16 & 0xff;
b[i++] = tl >>> 8 & 0xff;
b[i++] = tl & 0xff;
// `time_mid`
var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
b[i++] = tmh >>> 8 & 0xff;
b[i++] = tmh & 0xff;
// `time_high_and_version`
b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
b[i++] = tmh >>> 16 & 0xff;
// `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
b[i++] = clockseq >>> 8 | 0x80;
// `clock_seq_low`
b[i++] = clockseq & 0xff;
// `node`
var node = options.node || _nodeId;
for (var n = 0; n < 6; n++) {
b[i + n] = node[n];
}
return buf ? buf : unparse(b);
}
// **`v4()` - Generate random UUID**
// See https://github.com/broofa/node-uuid for API details
function v4(options, buf, offset) {
// Deprecated - 'format' argument, as supported in v1.2
var i = buf && offset || 0;
if (typeof(options) == 'string') {
buf = options == 'binary' ? new BufferClass(16) : null;
options = null;
}
options = options || {};
var rnds = options.random || (options.rng || _rng)();
// Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
rnds[6] = (rnds[6] & 0x0f) | 0x40;
rnds[8] = (rnds[8] & 0x3f) | 0x80;
// Copy bytes to buffer, if provided
if (buf) {
for (var ii = 0; ii < 16; ii++) {
buf[i + ii] = rnds[ii];
}
}
return buf || unparse(rnds);
}
// Export public API
var uuid = v4;
uuid.v1 = v1;
uuid.v4 = v4;
uuid.parse = parse;
uuid.unparse = unparse;
uuid.BufferClass = BufferClass;
if (true) {
// Publish as AMD module
!(__WEBPACK_AMD_DEFINE_RESULT__ = function() {return uuid;}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
} else if (typeof(module) != 'undefined' && module.exports) {
// Publish as node.js module
module.exports = uuid;
} else {
// Publish as global (in browsers)
var _previousRoot = _global.uuid;
// **`noConflict()` - (browser only) to reset global 'uuid' var**
uuid.noConflict = function() {
_global.uuid = _previousRoot;
return uuid;
};
_global.uuid = uuid;
}
}).call(this);
/***/ },
/* 86 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {// Version: 3.6.8
var NOW = 1
, READY = false
, READY_BUFFER = []
, PRESENCE_SUFFIX = '-pnpres'
, DEF_WINDOWING = 10 // MILLISECONDS.
, DEF_TIMEOUT = 10000 // MILLISECONDS.
, DEF_SUB_TIMEOUT = 310 // SECONDS.
, DEF_KEEPALIVE = 60 // SECONDS (FOR TIMESYNC).
, SECOND = 1000 // A THOUSAND MILLISECONDS.
, URLBIT = '/'
, PARAMSBIT = '&'
, PRESENCE_HB_THRESHOLD = 5
, PRESENCE_HB_DEFAULT = 30
, SDK_VER = '3.6.8'
, REPL = /{([\w\-]+)}/g;
/**
* UTILITIES
*/
function unique() { return'x'+ ++NOW+''+(+new Date) }
function rnow() { return+new Date }
/**
* NEXTORIGIN
* ==========
* var next_origin = nextorigin();
*/
var nextorigin = (function() {
var max = 20
, ori = Math.floor(Math.random() * max);
return function( origin, failover ) {
return origin.indexOf('pubsub.') > 0
&& origin.replace(
'pubsub', 'ps' + (
failover ? uuid().split('-')[0] :
(++ori < max? ori : ori=1)
) ) || origin;
}
})();
/**
* Build Url
* =======
*
*/
function build_url( url_components, url_params ) {
var url = url_components.join(URLBIT)
, params = [];
if (!url_params) return url;
each( url_params, function( key, value ) {
var value_str = (typeof value == 'object')?JSON['stringify'](value):value;
(typeof value != 'undefined' &&
value != null && encode(value_str).length > 0
) && params.push(key + "=" + encode(value_str));
} );
url += "?" + params.join(PARAMSBIT);
return url;
}
/**
* UPDATER
* =======
* var timestamp = unique();
*/
function updater( fun, rate ) {
var timeout
, last = 0
, runnit = function() {
if (last + rate > rnow()) {
clearTimeout(timeout);
timeout = setTimeout( runnit, rate );
}
else {
last = rnow();
fun();
}
};
return runnit;
}
/**
* GREP
* ====
* var list = grep( [1,2,3], function(item) { return item % 2 } )
*/
function grep( list, fun ) {
var fin = [];
each( list || [], function(l) { fun(l) && fin.push(l) } );
return fin
}
/**
* SUPPLANT
* ========
* var text = supplant( 'Hello {name}!', { name : 'John' } )
*/
function supplant( str, values ) {
return str.replace( REPL, function( _, match ) {
return values[match] || _
} );
}
/**
* timeout
* =======
* timeout( function(){}, 100 );
*/
function timeout( fun, wait ) {
return setTimeout( fun, wait );
}
/**
* uuid
* ====
* var my_uuid = uuid();
*/
function uuid(callback) {
var u = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g,
function(c) {
var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
return v.toString(16);
});
if (callback) callback(u);
return u;
}
function isArray(arg) {
return !!arg && (Array.isArray && Array.isArray(arg) || typeof(arg.length) === "number")
}
/**
* EACH
* ====
* each( [1,2,3], function(item) { } )
*/
function each( o, f) {
if ( !o || !f ) return;
if ( isArray(o) )
for ( var i = 0, l = o.length; i < l; )
f.call( o[i], o[i], i++ );
else
for ( var i in o )
o.hasOwnProperty &&
o.hasOwnProperty(i) &&
f.call( o[i], i, o[i] );
}
/**
* MAP
* ===
* var list = map( [1,2,3], function(item) { return item + 1 } )
*/
function map( list, fun ) {
var fin = [];
each( list || [], function( k, v ) { fin.push(fun( k, v )) } );
return fin;
}
/**
* ENCODE
* ======
* var encoded_data = encode('path');
*/
function encode(path) { return encodeURIComponent(path) }
/**
* Generate Subscription Channel List
* ==================================
* generate_channel_list(channels_object);
*/
function generate_channel_list(channels, nopresence) {
var list = [];
each( channels, function( channel, status ) {
if (nopresence) {
if(channel.search('-pnpres') < 0) {
if (status.subscribed) list.push(channel);
}
} else {
if (status.subscribed) list.push(channel);
}
});
return list.sort();
}
// PUBNUB READY TO CONNECT
function ready() { timeout( function() {
if (READY) return;
READY = 1;
each( READY_BUFFER, function(connect) { connect() } );
}, SECOND ); }
function PNmessage(args) {
msg = args || {'apns' : {}},
msg['getPubnubMessage'] = function() {
var m = {};
if (Object.keys(msg['apns']).length) {
m['pn_apns'] = {
'aps' : {
'alert' : msg['apns']['alert'] ,
'badge' : msg['apns']['badge']
}
}
for (var k in msg['apns']) {
m['pn_apns'][k] = msg['apns'][k];
}
var exclude1 = ['badge','alert'];
for (var k in exclude1) {
//console.log(exclude[k]);
delete m['pn_apns'][exclude1[k]];
}
}
if (msg['gcm']) {
m['pn_gcm'] = {
'data' : msg['gcm']
}
}
for (var k in msg) {
m[k] = msg[k];
}
var exclude = ['apns','gcm','publish', 'channel','callback','error'];
for (var k in exclude) {
delete m[exclude[k]];
}
return m;
};
msg['publish'] = function() {
var m = msg.getPubnubMessage();
if (msg['pubnub'] && msg['channel']) {
msg['pubnub'].publish({
'message' : m,
'channel' : msg['channel'],
'callback' : msg['callback'],
'error' : msg['error']
})
}
};
return msg;
}
function PN_API(setup) {
var SUB_WINDOWING = +setup['windowing'] || DEF_WINDOWING
, SUB_TIMEOUT = (+setup['timeout'] || DEF_SUB_TIMEOUT) * SECOND
, KEEPALIVE = (+setup['keepalive'] || DEF_KEEPALIVE) * SECOND
, NOLEAVE = setup['noleave'] || 0
, PUBLISH_KEY = setup['publish_key'] || 'demo'
, SUBSCRIBE_KEY = setup['subscribe_key'] || 'demo'
, AUTH_KEY = setup['auth_key'] || ''
, SECRET_KEY = setup['secret_key'] || ''
, hmac_SHA256 = setup['hmac_SHA256']
, SSL = setup['ssl'] ? 's' : ''
, ORIGIN = 'http'+SSL+'://'+(setup['origin']||'pubsub.pubnub.com')
, STD_ORIGIN = nextorigin(ORIGIN)
, SUB_ORIGIN = nextorigin(ORIGIN)
, CONNECT = function(){}
, PUB_QUEUE = []
, TIME_DRIFT = 0
, SUB_CALLBACK = 0
, SUB_CHANNEL = 0
, SUB_RECEIVER = 0
, SUB_RESTORE = setup['restore'] || 0
, SUB_BUFF_WAIT = 0
, TIMETOKEN = 0
, RESUMED = false
, CHANNELS = {}
, STATE = {}
, PRESENCE_HB_TIMEOUT = null
, PRESENCE_HB = validate_presence_heartbeat(setup['heartbeat'] || setup['pnexpires'] || 0, setup['error'])
, PRESENCE_HB_INTERVAL = setup['heartbeat_interval'] || PRESENCE_HB - 3
, PRESENCE_HB_RUNNING = false
, NO_WAIT_FOR_PENDING = setup['no_wait_for_pending']
, COMPATIBLE_35 = setup['compatible_3.5'] || false
, xdr = setup['xdr']
, params = setup['params'] || {}
, error = setup['error'] || function() {}
, _is_online = setup['_is_online'] || function() { return 1 }
, jsonp_cb = setup['jsonp_cb'] || function() { return 0 }
, db = setup['db'] || {'get': function(){}, 'set': function(){}}
, CIPHER_KEY = setup['cipher_key']
, UUID = setup['uuid'] || ( db && db['get'](SUBSCRIBE_KEY+'uuid') || '');
var crypto_obj = setup['crypto_obj'] ||
{
'encrypt' : function(a,key){ return a},
'decrypt' : function(b,key){return b}
};
function _get_url_params(data) {
if (!data) data = {};
each( params , function( key, value ) {
if (!(key in data)) data[key] = value;
});
return data;
}
function _object_to_key_list(o) {
var l = []
each( o , function( key, value ) {
l.push(key);
});
return l;
}
function _object_to_key_list_sorted(o) {
return _object_to_key_list(o).sort();
}
function _get_pam_sign_input_from_params(params) {
var si = "";
var l = _object_to_key_list_sorted(params);
for (var i in l) {
var k = l[i]
si += k + "=" + encode(params[k]) ;
if (i != l.length - 1) si += "&"
}
return si;
}
function validate_presence_heartbeat(heartbeat, cur_heartbeat, error) {
var err = false;
if (typeof heartbeat === 'number') {
if (heartbeat > PRESENCE_HB_THRESHOLD || heartbeat == 0)
err = false;
else
err = true;
} else if(typeof heartbeat === 'boolean'){
if (!heartbeat) {
return 0;
} else {
return PRESENCE_HB_DEFAULT;
}
} else {
err = true;
}
if (err) {
error && error("Presence Heartbeat value invalid. Valid range ( x > " + PRESENCE_HB_THRESHOLD + " or x = 0). Current Value : " + (cur_heartbeat || PRESENCE_HB_THRESHOLD));
return cur_heartbeat || PRESENCE_HB_THRESHOLD;
} else return heartbeat;
}
function encrypt(input, key) {
return crypto_obj['encrypt'](input, key || CIPHER_KEY) || input;
}
function decrypt(input, key) {
return crypto_obj['decrypt'](input, key || CIPHER_KEY) ||
crypto_obj['decrypt'](input, CIPHER_KEY) ||
input;
}
function error_common(message, callback) {
callback && callback({ 'error' : message || "error occurred"});
error && error(message);
}
function _presence_heartbeat() {
clearTimeout(PRESENCE_HB_TIMEOUT);
if (!PRESENCE_HB_INTERVAL || PRESENCE_HB_INTERVAL >= 500 || PRESENCE_HB_INTERVAL < 1 || !generate_channel_list(CHANNELS,true).length){
PRESENCE_HB_RUNNING = false;
return;
}
PRESENCE_HB_RUNNING = true;
SELF['presence_heartbeat']({
'callback' : function(r) {
PRESENCE_HB_TIMEOUT = timeout( _presence_heartbeat, (PRESENCE_HB_INTERVAL) * SECOND );
},
'error' : function(e) {
error && error("Presence Heartbeat unable to reach Pubnub servers." + JSON.stringify(e));
PRESENCE_HB_TIMEOUT = timeout( _presence_heartbeat, (PRESENCE_HB_INTERVAL) * SECOND );
}
});
}
function start_presence_heartbeat() {
!PRESENCE_HB_RUNNING && _presence_heartbeat();
}
function publish(next) {
if (NO_WAIT_FOR_PENDING) {
if (!PUB_QUEUE.length) return;
} else {
if (next) PUB_QUEUE.sending = 0;
if ( PUB_QUEUE.sending || !PUB_QUEUE.length ) return;
PUB_QUEUE.sending = 1;
}
xdr(PUB_QUEUE.shift());
}
function each_channel(callback) {
var count = 0;
each( generate_channel_list(CHANNELS), function(channel) {
var chan = CHANNELS[channel];
if (!chan) return;
count++;
(callback||function(){})(chan);
} );
return count;
}
function _invoke_callback(response, callback, err) {
if (typeof response == 'object') {
if (response['error'] && response['message'] && response['payload']) {
err({'message' : response['message'], 'payload' : response['payload']});
return;
}
if (response['payload']) {
callback(response['payload']);
return;
}
}
callback(response);
}
function _invoke_error(response,err) {
if (typeof response == 'object' && response['error'] &&
response['message'] && response['payload']) {
err({'message' : response['message'], 'payload' : response['payload']});
} else err(response);
}
// Announce Leave Event
var SELF = {
'LEAVE' : function( channel, blocking, callback, error ) {
var data = { 'uuid' : UUID, 'auth' : AUTH_KEY }
, origin = nextorigin(ORIGIN)
, callback = callback || function(){}
, err = error || function(){}
, jsonp = jsonp_cb();
// Prevent Leaving a Presence Channel
if (channel.indexOf(PRESENCE_SUFFIX) > 0) return true;
if (COMPATIBLE_35) {
if (!SSL) return false;
if (jsonp == '0') return false;
}
if (NOLEAVE) return false;
if (jsonp != '0') data['callback'] = jsonp;
xdr({
blocking : blocking || SSL,
timeout : 2000,
callback : jsonp,
data : _get_url_params(data),
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) {
_invoke_error(response, err);
},
url : [
origin, 'v2', 'presence', 'sub_key',
SUBSCRIBE_KEY, 'channel', encode(channel), 'leave'
]
});
return true;
},
'set_resumed' : function(resumed) {
RESUMED = resumed;
},
'get_cipher_key' : function() {
return CIPHER_KEY;
},
'set_cipher_key' : function(key) {
CIPHER_KEY = key;
},
'raw_encrypt' : function(input, key) {
return encrypt(input, key);
},
'raw_decrypt' : function(input, key) {
return decrypt(input, key);
},
'get_heartbeat' : function() {
return PRESENCE_HB;
},
'set_heartbeat' : function(heartbeat) {
PRESENCE_HB = validate_presence_heartbeat(heartbeat, PRESENCE_HB_INTERVAL, error);
PRESENCE_HB_INTERVAL = (PRESENCE_HB - 3 >= 1)?PRESENCE_HB - 3:1;
CONNECT();
_presence_heartbeat();
},
'get_heartbeat_interval' : function() {
return PRESENCE_HB_INTERVAL;
},
'set_heartbeat_interval' : function(heartbeat_interval) {
PRESENCE_HB_INTERVAL = heartbeat_interval;
_presence_heartbeat();
},
'get_version' : function() {
return SDK_VER;
},
'getGcmMessageObject' : function(obj) {
return {
'data' : obj
}
},
'getApnsMessageObject' : function(obj) {
var x = {
'aps' : { 'badge' : 1, 'alert' : ''}
}
for (k in obj) {
k[x] = obj[k];
}
return x;
},
'newPnMessage' : function() {
var x = {};
if (gcm) x['pn_gcm'] = gcm;
if (apns) x['pn_apns'] = apns;
for ( k in n ) {
x[k] = n[k];
}
return x;
},
'_add_param' : function(key,val) {
params[key] = val;
},
/*
PUBNUB.history({
channel : 'my_chat_channel',
limit : 100,
callback : function(history) { }
});
*/
'history' : function( args, callback ) {
var callback = args['callback'] || callback
, count = args['count'] || args['limit'] || 100
, reverse = args['reverse'] || "false"
, err = args['error'] || function(){}
, auth_key = args['auth_key'] || AUTH_KEY
, cipher_key = args['cipher_key']
, channel = args['channel']
, start = args['start']
, end = args['end']
, include_token = args['include_token']
, params = {}
, jsonp = jsonp_cb();
// Make sure we have a Channel
if (!channel) return error('Missing Channel');
if (!callback) return error('Missing Callback');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
params['stringtoken'] = 'true';
params['count'] = count;
params['reverse'] = reverse;
params['auth'] = auth_key;
if (jsonp) params['callback'] = jsonp;
if (start) params['start'] = start;
if (end) params['end'] = end;
if (include_token) params['include_token'] = 'true';
// Send Message
xdr({
callback : jsonp,
data : _get_url_params(params),
success : function(response) {
if (typeof response == 'object' && response['error']) {
err({'message' : response['message'], 'payload' : response['payload']});
return;
}
var messages = response[0];
var decrypted_messages = [];
for (var a = 0; a < messages.length; a++) {
var new_message = decrypt(messages[a],cipher_key);
try {
decrypted_messages['push'](JSON['parse'](new_message));
} catch (e) {
decrypted_messages['push']((new_message));
}
}
callback([decrypted_messages, response[1], response[2]]);
},
fail : function(response) {
_invoke_error(response, err);
},
url : [
STD_ORIGIN, 'v2', 'history', 'sub-key',
SUBSCRIBE_KEY, 'channel', encode(channel)
]
});
},
/*
PUBNUB.replay({
source : 'my_channel',
destination : 'new_channel'
});
*/
'replay' : function(args, callback) {
var callback = callback || args['callback'] || function(){}
, auth_key = args['auth_key'] || AUTH_KEY
, source = args['source']
, destination = args['destination']
, stop = args['stop']
, start = args['start']
, end = args['end']
, reverse = args['reverse']
, limit = args['limit']
, jsonp = jsonp_cb()
, data = {}
, url;
// Check User Input
if (!source) return error('Missing Source Channel');
if (!destination) return error('Missing Destination Channel');
if (!PUBLISH_KEY) return error('Missing Publish Key');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
// Setup URL Params
if (jsonp != '0') data['callback'] = jsonp;
if (stop) data['stop'] = 'all';
if (reverse) data['reverse'] = 'true';
if (start) data['start'] = start;
if (end) data['end'] = end;
if (limit) data['count'] = limit;
data['auth'] = auth_key;
// Compose URL Parts
url = [
STD_ORIGIN, 'v1', 'replay',
PUBLISH_KEY, SUBSCRIBE_KEY,
source, destination
];
// Start (or Stop) Replay!
xdr({
callback : jsonp,
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function() { callback([ 0, 'Disconnected' ]) },
url : url,
data : _get_url_params(data)
});
},
/*
PUBNUB.auth('AJFLKAJSDKLA');
*/
'auth' : function(auth) {
AUTH_KEY = auth;
CONNECT();
},
/*
PUBNUB.time(function(time){ });
*/
'time' : function(callback) {
var jsonp = jsonp_cb();
xdr({
callback : jsonp,
data : _get_url_params({ 'uuid' : UUID, 'auth' : AUTH_KEY }),
timeout : SECOND * 5,
url : [STD_ORIGIN, 'time', jsonp],
success : function(response) { callback(response[0]) },
fail : function() { callback(0) }
});
},
/*
PUBNUB.publish({
channel : 'my_chat_channel',
message : 'hello!'
});
*/
'publish' : function( args, callback ) {
var msg = args['message'];
if (!msg) return error('Missing Message');
var callback = callback || args['callback'] || msg['callback'] || function(){}
, channel = args['channel'] || msg['channel']
, auth_key = args['auth_key'] || AUTH_KEY
, cipher_key = args['cipher_key']
, err = args['error'] || msg['error'] || function() {}
, post = args['post'] || false
, store = ('store_in_history' in args) ? args['store_in_history']: true
, jsonp = jsonp_cb()
, add_msg = 'push'
, url;
if (args['prepend']) add_msg = 'unshift'
if (!channel) return error('Missing Channel');
if (!PUBLISH_KEY) return error('Missing Publish Key');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
if (msg['getPubnubMessage']) {
msg = msg['getPubnubMessage']();
}
// If trying to send Object
msg = JSON['stringify'](encrypt(msg, cipher_key));
// Create URL
url = [
STD_ORIGIN, 'publish',
PUBLISH_KEY, SUBSCRIBE_KEY,
0, encode(channel),
jsonp, encode(msg)
];
params = { 'uuid' : UUID, 'auth' : auth_key }
if (!store) params['store'] ="0"
// Queue Message Send
PUB_QUEUE[add_msg]({
callback : jsonp,
timeout : SECOND * 5,
url : url,
data : _get_url_params(params),
fail : function(response){
_invoke_error(response, err);
publish(1);
},
success : function(response) {
_invoke_callback(response, callback, err);
publish(1);
},
mode : (post)?'POST':'GET'
});
// Send Message
publish();
},
/*
PUBNUB.unsubscribe({ channel : 'my_chat' });
*/
'unsubscribe' : function(args, callback) {
var channel = args['channel']
, callback = callback || args['callback'] || function(){}
, err = args['error'] || function(){};
TIMETOKEN = 0;
//SUB_RESTORE = 1; REVISIT !!!!
// Prepare Channel(s)
channel = map( (
channel.join ? channel.join(',') : ''+channel
).split(','), function(channel) {
if (!CHANNELS[channel]) return;
return channel + ',' + channel + PRESENCE_SUFFIX;
} ).join(',');
// Iterate over Channels
each( channel.split(','), function(channel) {
var CB_CALLED = true;
if (!channel) return;
if (READY) {
CB_CALLED = SELF['LEAVE']( channel, 0 , callback, err);
}
if (!CB_CALLED) callback({action : "leave"});
CHANNELS[channel] = 0;
if (channel in STATE) delete STATE[channel];
} );
// Reset Connection if Count Less
CONNECT();
},
/*
PUBNUB.subscribe({
channel : 'my_chat'
callback : function(message) { }
});
*/
'subscribe' : function( args, callback ) {
var channel = args['channel']
, callback = callback || args['callback']
, callback = callback || args['message']
, auth_key = args['auth_key'] || AUTH_KEY
, connect = args['connect'] || function(){}
, reconnect = args['reconnect'] || function(){}
, disconnect = args['disconnect'] || function(){}
, errcb = args['error'] || function(){}
, idlecb = args['idle'] || function(){}
, presence = args['presence'] || 0
, noheresync = args['noheresync'] || 0
, backfill = args['backfill'] || 0
, timetoken = args['timetoken'] || 0
, sub_timeout = args['timeout'] || SUB_TIMEOUT
, windowing = args['windowing'] || SUB_WINDOWING
, state = args['state']
, heartbeat = args['heartbeat'] || args['pnexpires']
, restore = args['restore'] || SUB_RESTORE;
// Restore Enabled?
SUB_RESTORE = restore;
// Always Reset the TT
TIMETOKEN = timetoken;
// Make sure we have a Channel
if (!channel) return error('Missing Channel');
if (!callback) return error('Missing Callback');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
if (heartbeat || heartbeat === 0) {
SELF['set_heartbeat'](heartbeat);
}
// Setup Channel(s)
each( (channel.join ? channel.join(',') : ''+channel).split(','),
function(channel) {
var settings = CHANNELS[channel] || {};
// Store Channel State
CHANNELS[SUB_CHANNEL = channel] = {
name : channel,
connected : settings.connected,
disconnected : settings.disconnected,
subscribed : 1,
callback : SUB_CALLBACK = callback,
'cipher_key' : args['cipher_key'],
connect : connect,
disconnect : disconnect,
reconnect : reconnect
};
if (state) {
if (channel in state) {
STATE[channel] = state[channel];
} else {
STATE[channel] = state;
}
}
// Presence Enabled?
if (!presence) return;
// Subscribe Presence Channel
SELF['subscribe']({
'channel' : channel + PRESENCE_SUFFIX,
'callback' : presence,
'restore' : restore
});
// Presence Subscribed?
if (settings.subscribed) return;
// See Who's Here Now?
if (noheresync) return;
SELF['here_now']({
'channel' : channel,
'callback' : function(here) {
each( 'uuids' in here ? here['uuids'] : [],
function(uid) { presence( {
'action' : 'join',
'uuid' : uid,
'timestamp' : Math.floor(rnow() / 1000),
'occupancy' : here['occupancy'] || 1
}, here, channel ); } );
}
});
} );
// Test Network Connection
function _test_connection(success) {
if (success) {
// Begin Next Socket Connection
timeout( CONNECT, SECOND );
}
else {
// New Origin on Failed Connection
STD_ORIGIN = nextorigin( ORIGIN, 1 );
SUB_ORIGIN = nextorigin( ORIGIN, 1 );
// Re-test Connection
timeout( function() {
SELF['time'](_test_connection);
}, SECOND );
}
// Disconnect & Reconnect
each_channel(function(channel){
// Reconnect
if (success && channel.disconnected) {
channel.disconnected = 0;
return channel.reconnect(channel.name);
}
// Disconnect
if (!success && !channel.disconnected) {
channel.disconnected = 1;
channel.disconnect(channel.name);
}
});
}
// Evented Subscribe
function _connect() {
var jsonp = jsonp_cb()
, channels = generate_channel_list(CHANNELS).join(',');
// Stop Connection
if (!channels) return;
// Connect to PubNub Subscribe Servers
_reset_offline();
var data = _get_url_params({ 'uuid' : UUID, 'auth' : auth_key });
var st = JSON.stringify(STATE);
if (st.length > 2) data['state'] = JSON.stringify(STATE);
if (PRESENCE_HB) data['heartbeat'] = PRESENCE_HB;
start_presence_heartbeat();
SUB_RECEIVER = xdr({
timeout : sub_timeout,
callback : jsonp,
fail : function(response) {
_invoke_error(response, errcb);
//SUB_RECEIVER = null;
SELF['time'](_test_connection);
},
data : _get_url_params(data),
url : [
SUB_ORIGIN, 'subscribe',
SUBSCRIBE_KEY, encode(channels),
jsonp, TIMETOKEN
],
success : function(messages) {
//SUB_RECEIVER = null;
// Check for Errors
if (!messages || (
typeof messages == 'object' &&
'error' in messages &&
messages['error']
)) {
errcb(messages['error']);
return timeout( CONNECT, SECOND );
}
// User Idle Callback
idlecb(messages[1]);
// Restore Previous Connection Point if Needed
TIMETOKEN = !TIMETOKEN &&
SUB_RESTORE &&
db['get'](SUBSCRIBE_KEY) || messages[1];
// Connect
each_channel(function(channel){
if (channel.connected) return;
channel.connected = 1;
channel.connect(channel.name);
});
if (RESUMED && !SUB_RESTORE) {
TIMETOKEN = 0;
RESUMED = false;
// Update Saved Timetoken
db['set']( SUBSCRIBE_KEY, 0 );
timeout( _connect, windowing );
return;
}
// Invoke Memory Catchup and Receive Up to 100
// Previous Messages from the Queue.
if (backfill) {
TIMETOKEN = 10000;
backfill = 0;
}
// Update Saved Timetoken
db['set']( SUBSCRIBE_KEY, messages[1] );
// Route Channel <---> Callback for Message
var next_callback = (function() {
var channels = (messages.length>2?messages[2]:map(
generate_channel_list(CHANNELS), function(chan) { return map(
Array(messages[0].length)
.join(',').split(','),
function() { return chan; }
) }).join(','));
var list = channels.split(',');
return function() {
var channel = list.shift()||SUB_CHANNEL;
return [
(CHANNELS[channel]||{})
.callback||SUB_CALLBACK,
channel.split(PRESENCE_SUFFIX)[0]
];
};
})();
var latency = detect_latency(+messages[1]);
each( messages[0], function(msg) {
var next = next_callback();
var decrypted_msg = decrypt(msg,
(CHANNELS[next[1]])?CHANNELS[next[1]]['cipher_key']:null);
next[0]( decrypted_msg, messages, next[1], latency);
});
timeout( _connect, windowing );
}
});
}
CONNECT = function() {
_reset_offline();
timeout( _connect, windowing );
};
// Reduce Status Flicker
if (!READY) return READY_BUFFER.push(CONNECT);
// Connect Now
CONNECT();
},
/*
PUBNUB.here_now({ channel : 'my_chat', callback : fun });
*/
'here_now' : function( args, callback ) {
var callback = args['callback'] || callback
, err = args['error'] || function(){}
, auth_key = args['auth_key'] || AUTH_KEY
, channel = args['channel']
, jsonp = jsonp_cb()
, uuids = ('uuids' in args) ? args['uuids'] : true
, state = args['state']
, data = { 'uuid' : UUID, 'auth' : auth_key };
if (!uuids) data['disable_uuids'] = 1;
if (state) data['state'] = 1;
// Make sure we have a Channel
if (!callback) return error('Missing Callback');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
var url = [
STD_ORIGIN, 'v2', 'presence',
'sub_key', SUBSCRIBE_KEY
];
channel && url.push('channel') && url.push(encode(channel));
if (jsonp != '0') { data['callback'] = jsonp; }
xdr({
callback : jsonp,
data : _get_url_params(data),
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) {
_invoke_error(response, err);
},
url : url
});
},
/*
PUBNUB.current_channels_by_uuid({ channel : 'my_chat', callback : fun });
*/
'where_now' : function( args, callback ) {
var callback = args['callback'] || callback
, err = args['error'] || function(){}
, auth_key = args['auth_key'] || AUTH_KEY
, jsonp = jsonp_cb()
, uuid = args['uuid'] || UUID
, data = { 'auth' : auth_key };
// Make sure we have a Channel
if (!callback) return error('Missing Callback');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
if (jsonp != '0') { data['callback'] = jsonp; }
xdr({
callback : jsonp,
data : _get_url_params(data),
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) {
_invoke_error(response, err);
},
url : [
STD_ORIGIN, 'v2', 'presence',
'sub_key', SUBSCRIBE_KEY,
'uuid', encode(uuid)
]
});
},
'state' : function(args, callback) {
var callback = args['callback'] || callback || function(r) {}
, err = args['error'] || function(){}
, auth_key = args['auth_key'] || AUTH_KEY
, jsonp = jsonp_cb()
, state = args['state']
, uuid = args['uuid'] || UUID
, channel = args['channel']
, url
, data = _get_url_params({ 'auth' : auth_key });
// Make sure we have a Channel
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
if (!uuid) return error('Missing UUID');
if (!channel) return error('Missing Channel');
if (jsonp != '0') { data['callback'] = jsonp; }
if (CHANNELS[channel] && CHANNELS[channel].subscribed && state) STATE[channel] = state;
data['state'] = JSON.stringify(state);
if (state) {
url = [
STD_ORIGIN, 'v2', 'presence',
'sub-key', SUBSCRIBE_KEY,
'channel', encode(channel),
'uuid', uuid, 'data'
]
} else {
url = [
STD_ORIGIN, 'v2', 'presence',
'sub-key', SUBSCRIBE_KEY,
'channel', encode(channel),
'uuid', encode(uuid)
]
}
xdr({
callback : jsonp,
data : _get_url_params(data),
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) {
_invoke_error(response, err);
},
url : url
});
},
/*
PUBNUB.grant({
channel : 'my_chat',
callback : fun,
error : fun,
ttl : 24 * 60, // Minutes
read : true,
write : true,
auth_key : '3y8uiajdklytowsj'
});
*/
'grant' : function( args, callback ) {
var callback = args['callback'] || callback
, err = args['error'] || function(){}
, channel = args['channel']
, jsonp = jsonp_cb()
, ttl = args['ttl']
, r = (args['read'] )?"1":"0"
, w = (args['write'])?"1":"0"
, auth_key = args['auth_key'];
if (!callback) return error('Missing Callback');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
if (!PUBLISH_KEY) return error('Missing Publish Key');
if (!SECRET_KEY) return error('Missing Secret Key');
var timestamp = Math.floor(new Date().getTime() / 1000)
, sign_input = SUBSCRIBE_KEY + "\n" + PUBLISH_KEY + "\n"
+ "grant" + "\n";
var data = {
'w' : w,
'r' : r,
'timestamp' : timestamp
};
if (channel != 'undefined' && channel != null && channel.length > 0) data['channel'] = channel;
if (jsonp != '0') { data['callback'] = jsonp; }
if (ttl || ttl === 0) data['ttl'] = ttl;
if (auth_key) data['auth'] = auth_key;
data = _get_url_params(data)
if (!auth_key) delete data['auth'];
sign_input += _get_pam_sign_input_from_params(data);
var signature = hmac_SHA256( sign_input, SECRET_KEY );
signature = signature.replace( /\+/g, "-" );
signature = signature.replace( /\//g, "_" );
data['signature'] = signature;
xdr({
callback : jsonp,
data : data,
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) {
_invoke_error(response, err);
},
url : [
STD_ORIGIN, 'v1', 'auth', 'grant' ,
'sub-key', SUBSCRIBE_KEY
]
});
},
/*
PUBNUB.audit({
channel : 'my_chat',
callback : fun,
error : fun,
read : true,
write : true,
auth_key : '3y8uiajdklytowsj'
});
*/
'audit' : function( args, callback ) {
var callback = args['callback'] || callback
, err = args['error'] || function(){}
, channel = args['channel']
, auth_key = args['auth_key']
, jsonp = jsonp_cb();
// Make sure we have a Channel
if (!callback) return error('Missing Callback');
if (!SUBSCRIBE_KEY) return error('Missing Subscribe Key');
if (!PUBLISH_KEY) return error('Missing Publish Key');
if (!SECRET_KEY) return error('Missing Secret Key');
var timestamp = Math.floor(new Date().getTime() / 1000)
, sign_input = SUBSCRIBE_KEY + "\n"
+ PUBLISH_KEY + "\n"
+ "audit" + "\n";
var data = {'timestamp' : timestamp };
if (jsonp != '0') { data['callback'] = jsonp; }
if (channel != 'undefined' && channel != null && channel.length > 0) data['channel'] = channel;
if (auth_key) data['auth'] = auth_key;
data = _get_url_params(data)
if (!auth_key) delete data['auth'];
sign_input += _get_pam_sign_input_from_params(data);
var signature = hmac_SHA256( sign_input, SECRET_KEY );
signature = signature.replace( /\+/g, "-" );
signature = signature.replace( /\//g, "_" );
data['signature'] = signature;
xdr({
callback : jsonp,
data : data,
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) {
_invoke_error(response, err);
},
url : [
STD_ORIGIN, 'v1', 'auth', 'audit' ,
'sub-key', SUBSCRIBE_KEY
]
});
},
/*
PUBNUB.revoke({
channel : 'my_chat',
callback : fun,
error : fun,
auth_key : '3y8uiajdklytowsj'
});
*/
'revoke' : function( args, callback ) {
args['read'] = false;
args['write'] = false;
SELF['grant']( args, callback );
},
'set_uuid' : function(uuid) {
UUID = uuid;
CONNECT();
},
'get_uuid' : function() {
return UUID;
},
'presence_heartbeat' : function(args) {
var callback = args['callback'] || function() {}
var err = args['error'] || function() {}
var jsonp = jsonp_cb();
var data = { 'uuid' : UUID, 'auth' : AUTH_KEY };
var st = JSON['stringify'](STATE);
if (st.length > 2) data['state'] = JSON['stringify'](STATE);
if (PRESENCE_HB > 0 && PRESENCE_HB < 320) data['heartbeat'] = PRESENCE_HB;
if (jsonp != '0') { data['callback'] = jsonp; }
xdr({
callback : jsonp,
data : _get_url_params(data),
timeout : SECOND * 5,
url : [
STD_ORIGIN, 'v2', 'presence',
'sub-key', SUBSCRIBE_KEY,
'channel' , encode(generate_channel_list(CHANNELS, true)['join'](',')),
'heartbeat'
],
success : function(response) {
_invoke_callback(response, callback, err);
},
fail : function(response) { _invoke_error(response, err); }
});
},
// Expose PUBNUB Functions
'xdr' : xdr,
'ready' : ready,
'db' : db,
'uuid' : uuid,
'map' : map,
'each' : each,
'each-channel' : each_channel,
'grep' : grep,
'offline' : function(){_reset_offline(1, { "message":"Offline. Please check your network settings." })},
'supplant' : supplant,
'now' : rnow,
'unique' : unique,
'updater' : updater
};
function _poll_online() {
_is_online() || _reset_offline( 1, {
"error" : "Offline. Please check your network settings. "
});
timeout( _poll_online, SECOND );
}
function _poll_online2() {
SELF['time'](function(success){
detect_time_detla( function(){}, success );
success || _reset_offline( 1, {
"error" : "Heartbeat failed to connect to Pubnub Servers." +
"Please check your network settings."
});
timeout( _poll_online2, KEEPALIVE );
});
}
function _reset_offline(err, msg) {
SUB_RECEIVER && SUB_RECEIVER(err, msg);
SUB_RECEIVER = null;
}
if (!UUID) UUID = SELF['uuid']();
db['set']( SUBSCRIBE_KEY + 'uuid', UUID );
timeout( _poll_online, SECOND );
timeout( _poll_online2, KEEPALIVE );
PRESENCE_HB_TIMEOUT = timeout( start_presence_heartbeat, ( PRESENCE_HB_INTERVAL - 3 ) * SECOND ) ;
// Detect Age of Message
function detect_latency(tt) {
var adjusted_time = rnow() - TIME_DRIFT;
return adjusted_time - tt / 10000;
}
detect_time_detla();
function detect_time_detla( cb, time ) {
var stime = rnow();
time && calculate(time) || SELF['time'](calculate);
function calculate(time) {
if (!time) return;
var ptime = time / 10000
, latency = (rnow() - stime) / 2;
TIME_DRIFT = rnow() - (ptime + latency);
cb && cb(TIME_DRIFT);
}
}
return SELF;
}
/* ---------------------------------------------------------------------------
WAIT! - This file depends on instructions from the PUBNUB Cloud.
http://www.pubnub.com/account
--------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------
PubNub Real-time Cloud-Hosted Push API and Push Notification Client Frameworks
Copyright (c) 2011 TopMambo Inc.
http://www.pubnub.com/
http://www.pubnub.com/terms
--------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
--------------------------------------------------------------------------- */
/**
* UTIL LOCALS
*/
var NOW = 1
, http = __webpack_require__(30)
, https = __webpack_require__(46)
, keepAliveAgent = new (keepAliveIsEmbedded() ? http.Agent : __webpack_require__(156))({
keepAlive: true,
keepAliveMsecs: 300000,
maxSockets: 5
})
, XHRTME = 310000
, DEF_TIMEOUT = 10000
, SECOND = 1000
, PNSDK = 'PubNub-JS-' + 'Nodejs' + '/' + '3.6.8'
, crypto = __webpack_require__(48)
, proxy = null
, XORIGN = 1;
function get_hmac_SHA256(data, key) {
return crypto.createHmac('sha256',
new Buffer(key, 'utf8')).update(data).digest('base64');
}
/**
* ERROR
* ===
* error('message');
*/
function error(message) { console['error'](message) }
/**
* Request
* =======
* xdr({
* url : ['http://www.blah.com/url'],
* success : function(response) {},
* fail : function() {}
* });
*/
function xdr( setup ) {
var request
, response
, success = setup.success || function(){}
, fail = setup.fail || function(){}
, origin = setup.origin || 'pubsub.pubnub.com'
, ssl = setup.ssl
, failed = 0
, complete = 0
, loaded = 0
, mode = setup['mode'] || 'GET'
, data = setup['data'] || {}
, xhrtme = setup.timeout || DEF_TIMEOUT
, body = ''
, finished = function() {
if (loaded) return;
loaded = 1;
clearTimeout(timer);
try { response = JSON['parse'](body); }
catch (r) { return done(1); }
success(response);
}
, done = function(failed, response) {
if (complete) return;
complete = 1;
clearTimeout(timer);
if (request) {
request.on('error', function(){});
request.on('data', function(){});
request.on('end', function(){});
request.abort && request.abort();
request = null;
}
failed && fail(response);
}
, timer = timeout( function(){done(1);} , xhrtme );
data['pnsdk'] = PNSDK;
var options = {};
var headers = {};
var payload = '';
if (mode == 'POST')
payload = decodeURIComponent(setup.url.pop());
var url = build_url( setup.url, data );
if (!ssl) ssl = (url.split('://')[0] == 'https')?true:false;
url = '/' + url.split('/').slice(3).join('/');
var origin = setup.url[0].split("//")[1]
options.hostname = proxy ? proxy.hostname : setup.url[0].split("//")[1];
options.port = proxy ? proxy.port : ssl ? 443 : 80;
options.path = proxy ? "http://" + origin + url:url;
options.headers = proxy ? { 'Host': origin }:null;
options.method = mode;
options.keepAlive= !!keepAliveAgent;
options.agent = keepAliveAgent;
options.body = payload;
__webpack_require__(30).globalAgent.maxSockets = Infinity;
try {
request = (ssl ? https : http)['request'](options, function(response) {
response.setEncoding('utf8');
response.on( 'error', function(){console.log('error');done(1, body || { "error" : "Network Connection Error"})});
response.on( 'abort', function(){console.log('abort');done(1, body || { "error" : "Network Connection Error"})});
response.on( 'data', function (chunk) {
if (chunk) body += chunk;
} );
response.on( 'end', function(){
var statusCode = response.statusCode;
switch(statusCode) {
case 401:
case 402:
case 403:
try {
response = JSON['parse'](body);
done(1,response);
}
catch (r) { return done(1, body); }
return;
default:
break;
}
finished();
});
});
request.timeout = xhrtme;
request.on( 'error', function() {
done( 1, {"error":"Network Connection Error"} );
} );
if (mode == 'POST') request.write(payload);
request.end();
} catch(e) {
done(0);
return xdr(setup);
}
return done;
}
/**
* LOCAL STORAGE
*/
var db = (function(){
var store = {};
return {
'get' : function(key) {
return store[key];
},
'set' : function( key, value ) {
store[key] = value;
}
};
})();
function crypto_obj() {
var iv = "0123456789012345";
function get_padded_key(key) {
return crypto.createHash('sha256').update(key).digest("hex").slice(0,32);
}
return {
'encrypt' : function(input, key) {
if (!key) return input;
var plain_text = JSON['stringify'](input);
var cipher = crypto.createCipheriv('aes-256-cbc', get_padded_key(key), iv);
var base_64_encrypted = cipher.update(plain_text, 'utf8', 'base64') + cipher.final('base64');
return base_64_encrypted || input;
},
'decrypt' : function(input, key) {
if (!key) return input;
var decipher = crypto.createDecipheriv('aes-256-cbc', get_padded_key(key), iv);
try {
var decrypted = decipher.update(input, 'base64', 'utf8') + decipher.final('utf8');
} catch (e) {
return null;
}
return JSON.parse(decrypted);
}
}
}
function keepAliveIsEmbedded() {
return 'EventEmitter' in http.Agent.super_;
}
var CREATE_PUBNUB = function(setup) {
proxy = setup['proxy'];
setup['xdr'] = xdr;
setup['db'] = db;
setup['error'] = setup['error'] || error;
setup['hmac_SHA256'] = get_hmac_SHA256;
setup['crypto_obj'] = crypto_obj();
setup['params'] = {'pnsdk' : PNSDK};
if (setup['keepAlive'] === false) {
keepAliveAgent = undefined;
}
SELF = function(setup) {
return CREATE_PUBNUB(setup);
}
var PN = PN_API(setup);
for (var prop in PN) {
if (PN.hasOwnProperty(prop)) {
SELF[prop] = PN[prop];
}
}
SELF.init = SELF;
SELF.secure = SELF;
SELF.ready();
return SELF;
}
CREATE_PUBNUB.init = CREATE_PUBNUB;
CREATE_PUBNUB.unique = unique
CREATE_PUBNUB.secure = CREATE_PUBNUB;
module.exports = CREATE_PUBNUB
module.exports.PNmessage = PNmessage;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 87 */
/***/ function(module, exports, __webpack_require__) {
var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
;(function (exports) {
'use strict';
var Arr = (typeof Uint8Array !== 'undefined')
? Uint8Array
: Array
var PLUS = '+'.charCodeAt(0)
var SLASH = '/'.charCodeAt(0)
var NUMBER = '0'.charCodeAt(0)
var LOWER = 'a'.charCodeAt(0)
var UPPER = 'A'.charCodeAt(0)
function decode (elt) {
var code = elt.charCodeAt(0)
if (code === PLUS)
return 62 // '+'
if (code === SLASH)
return 63 // '/'
if (code < NUMBER)
return -1 //no match
if (code < NUMBER + 10)
return code - NUMBER + 26 + 26
if (code < UPPER + 26)
return code - UPPER
if (code < LOWER + 26)
return code - LOWER + 26
}
function b64ToByteArray (b64) {
var i, j, l, tmp, placeHolders, arr
if (b64.length % 4 > 0) {
throw new Error('Invalid string. Length must be a multiple of 4')
}
// the number of equal signs (place holders)
// if there are two placeholders, than the two characters before it
// represent one byte
// if there is only one, then the three characters before it represent 2 bytes
// this is just a cheap hack to not do indexOf twice
var len = b64.length
placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
// base64 is 4/3 + up to two characters of the original data
arr = new Arr(b64.length * 3 / 4 - placeHolders)
// if there are placeholders, only get up to the last complete 4 chars
l = placeHolders > 0 ? b64.length - 4 : b64.length
var L = 0
function push (v) {
arr[L++] = v
}
for (i = 0, j = 0; i < l; i += 4, j += 3) {
tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
push((tmp & 0xFF0000) >> 16)
push((tmp & 0xFF00) >> 8)
push(tmp & 0xFF)
}
if (placeHolders === 2) {
tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
push(tmp & 0xFF)
} else if (placeHolders === 1) {
tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
push((tmp >> 8) & 0xFF)
push(tmp & 0xFF)
}
return arr
}
function uint8ToBase64 (uint8) {
var i,
extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
output = "",
temp, length
function encode (num) {
return lookup.charAt(num)
}
function tripletToBase64 (num) {
return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
}
// go through the array every three bytes, we'll deal with trailing stuff later
for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
output += tripletToBase64(temp)
}
// pad the end with zeros, but make sure to not forget the extra bytes
switch (extraBytes) {
case 1:
temp = uint8[uint8.length - 1]
output += encode(temp >> 2)
output += encode((temp << 4) & 0x3F)
output += '=='
break
case 2:
temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
output += encode(temp >> 10)
output += encode((temp >> 4) & 0x3F)
output += encode((temp << 2) & 0x3F)
output += '='
break
}
return output
}
exports.toByteArray = b64ToByteArray
exports.fromByteArray = uint8ToBase64
}(false ? (this.base64js = {}) : exports))
/***/ },
/* 88 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// copy from https://github.com/joyent/node/blob/master/lib/_http_agent.js
var net = __webpack_require__(!(function webpackMissingModule() { var e = new Error("Cannot find module \"net\""); e.code = 'MODULE_NOT_FOUND'; throw e; }()));
var url = __webpack_require__(31);
var util = __webpack_require__(79);
var EventEmitter = __webpack_require__(44).EventEmitter;
// var ClientRequest = require('_http_client').ClientRequest;
// var debug = util.debuglog('http');
var ClientRequest = __webpack_require__(30).ClientRequest;
var debug;
if (process.env.NODE_DEBUG && /agentkeepalive/.test(process.env.NODE_DEBUG)) {
debug = function (x) {
console.error.apply(console, arguments);
};
} else {
debug = function () { };
}
// New Agent code.
// The largest departure from the previous implementation is that
// an Agent instance holds connections for a variable number of host:ports.
// Surprisingly, this is still API compatible as far as third parties are
// concerned. The only code that really notices the difference is the
// request object.
// Another departure is that all code related to HTTP parsing is in
// ClientRequest.onSocket(). The Agent is now *strictly*
// concerned with managing a connection pool.
function Agent(options) {
if (!(this instanceof Agent))
return new Agent(options);
EventEmitter.call(this);
var self = this;
self.defaultPort = 80;
self.protocol = 'http:';
self.options = util._extend({}, options);
// don't confuse net and make it think that we're connecting to a pipe
self.options.path = null;
self.requests = {};
self.sockets = {};
self.freeSockets = {};
self.keepAliveMsecs = self.options.keepAliveMsecs || 1000;
self.keepAlive = self.options.keepAlive || false;
self.maxSockets = self.options.maxSockets || Agent.defaultMaxSockets;
self.maxFreeSockets = self.options.maxFreeSockets || 256;
self.on('free', function(socket, options) {
var name = self.getName(options);
debug('agent.on(free)', name);
if (!self.isDestroyed(socket) &&
self.requests[name] && self.requests[name].length) {
self.requests[name].shift().onSocket(socket);
if (self.requests[name].length === 0) {
// don't leak
delete self.requests[name];
}
} else {
// If there are no pending requests, then put it in
// the freeSockets pool, but only if we're allowed to do so.
var req = socket._httpMessage;
if (req &&
req.shouldKeepAlive &&
!self.isDestroyed(socket) &&
self.options.keepAlive) {
var freeSockets = self.freeSockets[name];
var freeLen = freeSockets ? freeSockets.length : 0;
var count = freeLen;
if (self.sockets[name])
count += self.sockets[name].length;
if (count >= self.maxSockets || freeLen >= self.maxFreeSockets) {
self.removeSocket(socket, options);
socket.destroy();
} else {
freeSockets = freeSockets || [];
self.freeSockets[name] = freeSockets;
socket.setKeepAlive(true, self.keepAliveMsecs);
socket.unref && socket.unref();
socket._httpMessage = null;
self.removeSocket(socket, options);
freeSockets.push(socket);
}
} else {
self.removeSocket(socket, options);
socket.destroy();
}
}
});
}
util.inherits(Agent, EventEmitter);
exports.Agent = Agent;
Agent.defaultMaxSockets = Infinity;
Agent.prototype.createConnection = net.createConnection;
// Get the key for a given set of request options
Agent.prototype.getName = function(options) {
var name = '';
if (options.host)
name += options.host;
else
name += 'localhost';
name += ':';
if (options.port)
name += options.port;
name += ':';
if (options.localAddress)
name += options.localAddress;
name += ':';
return name;
};
Agent.prototype.addRequest = function(req, options) {
// Legacy API: addRequest(req, host, port, path)
if (typeof options === 'string') {
options = {
host: options,
port: arguments[2],
path: arguments[3]
};
}
var name = this.getName(options);
if (!this.sockets[name]) {
this.sockets[name] = [];
}
var freeLen = this.freeSockets[name] ? this.freeSockets[name].length : 0;
var sockLen = freeLen + this.sockets[name].length;
if (freeLen) {
// we have a free socket, so use that.
var socket = this.freeSockets[name].shift();
debug('have free socket');
// don't leak
if (!this.freeSockets[name].length)
delete this.freeSockets[name];
socket.ref && socket.ref();
req.onSocket(socket);
this.sockets[name].push(socket);
} else if (sockLen < this.maxSockets) {
debug('call onSocket', sockLen, freeLen);
// If we are under maxSockets create a new one.
req.onSocket(this.createSocket(req, options));
} else {
debug('wait for socket');
// We are over limit so we'll add it to the queue.
if (!this.requests[name]) {
this.requests[name] = [];
}
this.requests[name].push(req);
}
};
Agent.prototype.createSocket = function(req, options) {
var self = this;
options = util._extend({}, options);
options = util._extend(options, self.options);
options.servername = options.host;
if (req) {
var hostHeader = req.getHeader('host');
if (hostHeader) {
options.servername = hostHeader.replace(/:.*$/, '');
}
}
var name = self.getName(options);
debug('createConnection', name, options);
var s = self.createConnection(options);
if (!self.sockets[name]) {
self.sockets[name] = [];
}
this.sockets[name].push(s);
debug('sockets', name, this.sockets[name].length);
function onFree() {
self.emit('free', s, options);
}
s.on('free', onFree);
function onClose(err) {
debug('CLIENT socket onClose');
// This is the only place where sockets get removed from the Agent.
// If you want to remove a socket from the pool, just close it.
// All socket errors end in a close event anyway.
self.removeSocket(s, options);
}
s.on('close', onClose);
function onRemove() {
// We need this function for cases like HTTP 'upgrade'
// (defined by WebSockets) where we need to remove a socket from the
// pool because it'll be locked up indefinitely
debug('CLIENT socket onRemove');
self.removeSocket(s, options, 'agentRemove');
s.removeListener('close', onClose);
s.removeListener('free', onFree);
s.removeListener('agentRemove', onRemove);
}
s.on('agentRemove', onRemove);
return s;
};
Agent.prototype.removeSocket = function(s, options) {
var name = this.getName(options);
debug('removeSocket', name, 'destroyed:', this.isDestroyed(s));
var sets = [this.sockets];
if (this.isDestroyed(s)) {
// If the socket was destroyed, we need to remove it from the free buffers.
sets.push(this.freeSockets);
}
sets.forEach(function(sockets) {
if (sockets[name]) {
var index = sockets[name].indexOf(s);
if (index !== -1) {
sockets[name].splice(index, 1);
if (sockets[name].length === 0) {
// don't leak
delete sockets[name];
}
}
}
});
if (this.requests[name] && this.requests[name].length) {
debug('removeSocket, have a request, make a socket');
var req = this.requests[name][0];
// If we have pending requests and a socket gets closed make a new one
this.createSocket(req, options).emit('free');
}
};
Agent.prototype.destroy = function() {
var sets = [this.freeSockets, this.sockets];
sets.forEach(function(set) {
Object.keys(set).forEach(function(name) {
set[name].forEach(function(socket) {
socket.destroy();
});
});
});
};
Agent.prototype.request = function(options, cb) {
// if (util.isString(options)) {
// options = url.parse(options);
// }
if (typeof options === 'string') {
options = url.parse(options);
}
// don't try to do dns lookups of foo.com:8080, just foo.com
if (options.hostname) {
options.host = options.hostname;
}
if (options && options.path && / /.test(options.path)) {
// The actual regex is more like /[^A-Za-z0-9\-._~!$&'()*+,;=/:@]/
// with an additional rule for ignoring percentage-escaped characters
// but that's a) hard to capture in a regular expression that performs
// well, and b) possibly too restrictive for real-world usage. That's
// why it only scans for spaces because those are guaranteed to create
// an invalid request.
throw new TypeError('Request path contains unescaped characters.');
} else if (options.protocol && options.protocol !== this.protocol) {
throw new Error('Protocol:' + options.protocol + ' not supported.');
}
options = util._extend({
agent: this,
keepAlive: this.keepAlive
}, options);
// if it's false, then make a new one, just like this one.
if (options.agent === false)
options.agent = new this.constructor();
debug('agent.request', options);
return new ClientRequest(options, cb);
};
Agent.prototype.get = function(options, cb) {
var req = this.request(options, cb);
req.end();
return req;
};
Agent.prototype.isDestroyed = function(socket){
return socket.destroyed || socket._destroyed;
}
exports.globalAgent = new Agent();
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(99)))
/***/ },
/* 89 */
/***/ function(module, exports, __webpack_require__) {
var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module) {/*
Copyright (c) 2010,2011,2012,2013 Morgan Roderick http://roderick.dk
License: MIT - http://mrgnrdrck.mit-license.org
https://github.com/mroderick/PubSubJS
*/
/*jslint white:true, plusplus:true, stupid:true*/
/*global
setTimeout,
module,
exports,
define,
require,
window
*/
(function(root, factory){
'use strict';
// CommonJS
if (typeof exports === 'object' && module){
module.exports = factory();
// AMD
} else if (true){
!(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
// Browser
} else {
root.PubSub = factory();
}
}( ( typeof window === 'object' && window ) || this, function(){
'use strict';
var PubSub = {},
messages = {},
lastUid = -1;
function hasKeys(obj){
var key;
for (key in obj){
if ( obj.hasOwnProperty(key) ){
return true;
}
}
return false;
}
/**
* Returns a function that throws the passed exception, for use as argument for setTimeout
* @param { Object } ex An Error object
*/
function throwException( ex ){
return function reThrowException(){
throw ex;
};
}
function callSubscriberWithDelayedExceptions( subscriber, message, data ){
try {
subscriber( message, data );
} catch( ex ){
setTimeout( throwException( ex ), 0);
}
}
function callSubscriberWithImmediateExceptions( subscriber, message, data ){
subscriber( message, data );
}
function deliverMessage( originalMessage, matchedMessage, data, immediateExceptions ){
var subscribers = messages[matchedMessage],
callSubscriber = immediateExceptions ? callSubscriberWithImmediateExceptions : callSubscriberWithDelayedExceptions,
s;
if ( !messages.hasOwnProperty( matchedMessage ) ) {
return;
}
for (s in subscribers){
if ( subscribers.hasOwnProperty(s)){
callSubscriber( subscribers[s], originalMessage, data );
}
}
}
function createDeliveryFunction( message, data, immediateExceptions ){
return function deliverNamespaced(){
var topic = String( message ),
position = topic.lastIndexOf( '.' );
// deliver the message as it is now
deliverMessage(message, message, data, immediateExceptions);
// trim the hierarchy and deliver message to each level
while( position !== -1 ){
topic = topic.substr( 0, position );
position = topic.lastIndexOf('.');
deliverMessage( message, topic, data );
}
};
}
function messageHasSubscribers( message ){
var topic = String( message ),
found = Boolean(messages.hasOwnProperty( topic ) && hasKeys(messages[topic])),
position = topic.lastIndexOf( '.' );
while ( !found && position !== -1 ){
topic = topic.substr( 0, position );
position = topic.lastIndexOf( '.' );
found = Boolean(messages.hasOwnProperty( topic ) && hasKeys(messages[topic]));
}
return found;
}
function publish( message, data, sync, immediateExceptions ){
var deliver = createDeliveryFunction( message, data, immediateExceptions ),
hasSubscribers = messageHasSubscribers( message );
if ( !hasSubscribers ){
return false;
}
if ( sync === true ){
deliver();
} else {
setTimeout( deliver, 0 );
}
return true;
}
/**
* PubSub.publish( message[, data] ) -> Boolean
* - message (String): The message to publish
* - data: The data to pass to subscribers
* Publishes the the message, passing the data to it's subscribers
**/
PubSub.publish = function( message, data ){
return publish( message, data, false, PubSub.immediateExceptions );
};
/**
* PubSub.publishSync( message[, data] ) -> Boolean
* - message (String): The message to publish
* - data: The data to pass to subscribers
* Publishes the the message synchronously, passing the data to it's subscribers
**/
PubSub.publishSync = function( message, data ){
return publish( message, data, true, PubSub.immediateExceptions );
};
/**
* PubSub.subscribe( message, func ) -> String
* - message (String): The message to subscribe to
* - func (Function): The function to call when a new message is published
* Subscribes the passed function to the passed message. Every returned token is unique and should be stored if
* you need to unsubscribe
**/
PubSub.subscribe = function( message, func ){
if ( typeof func !== 'function'){
return false;
}
// message is not registered yet
if ( !messages.hasOwnProperty( message ) ){
messages[message] = {};
}
// forcing token as String, to allow for future expansions without breaking usage
// and allow for easy use as key names for the 'messages' object
var token = 'uid_' + String(++lastUid);
messages[message][token] = func;
// return token for unsubscribing
return token;
};
/**
* PubSub.unsubscribe( tokenOrFunction ) -> String | Boolean
* - tokenOrFunction (String|Function): The token of the function to unsubscribe or func passed in on subscribe
* Unsubscribes a specific subscriber from a specific message using the unique token
* or if using Function as argument, it will remove all subscriptions with that function
**/
PubSub.unsubscribe = function( tokenOrFunction ){
var isToken = typeof tokenOrFunction === 'string',
result = false,
m, message, t, token;
for ( m in messages ){
if ( messages.hasOwnProperty( m ) ){
message = messages[m];
if ( isToken && message[tokenOrFunction] ){
delete message[tokenOrFunction];
result = tokenOrFunction;
// tokens are unique, so we can just stop here
break;
} else if (!isToken) {
for ( t in message ){
if (message.hasOwnProperty(t) && message[t] === tokenOrFunction){
delete message[t];
result = true;
}
}
}
}
}
return result;
};
return PubSub;
}));
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(83)(module)))
/***/ },
/* 90 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var Promise = __webpack_require__(139).Promise;
var polyfill = __webpack_require__(140).polyfill;
exports.Promise = Promise;
exports.polyfill = polyfill;
/***/ },
/* 91 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function() {
var global = __webpack_require__(107);
var util = __webpack_require__(108);
var async = __webpack_require__(109);
var errors = __webpack_require__(110);
var INTERNAL = function(){};
var APPLY = {};
var NEXT_FILTER = {e: null};
var PromiseArray = __webpack_require__(111)(Promise, INTERNAL);
var CapturedTrace = __webpack_require__(112)();
var CatchFilter = __webpack_require__(113)(NEXT_FILTER);
var PromiseResolver = __webpack_require__(114);
var isArray = util.isArray;
var errorObj = util.errorObj;
var tryCatch1 = util.tryCatch1;
var tryCatch2 = util.tryCatch2;
var tryCatchApply = util.tryCatchApply;
var RangeError = errors.RangeError;
var TypeError = errors.TypeError;
var CancellationError = errors.CancellationError;
var TimeoutError = errors.TimeoutError;
var RejectionError = errors.RejectionError;
var originatesFromRejection = errors.originatesFromRejection;
var markAsOriginatingFromRejection = errors.markAsOriginatingFromRejection;
var canAttach = errors.canAttach;
var thrower = util.thrower;
var apiRejection = __webpack_require__(115)(Promise);
var makeSelfResolutionError = function Promise$_makeSelfResolutionError() {
return new TypeError("circular promise resolution chain");
};
function isPromise(obj) {
if (obj === void 0) return false;
return obj instanceof Promise;
}
function isPromiseArrayProxy(receiver, promiseSlotValue) {
if (receiver instanceof PromiseArray) {
return promiseSlotValue >= 0;
}
return false;
}
function Promise(resolver) {
if (typeof resolver !== "function") {
throw new TypeError("the promise constructor requires a resolver function");
}
if (this.constructor !== Promise) {
throw new TypeError("the promise constructor cannot be invoked directly");
}
this._bitField = 0;
this._fulfillmentHandler0 = void 0;
this._rejectionHandler0 = void 0;
this._promise0 = void 0;
this._receiver0 = void 0;
this._settledValue = void 0;
this._boundTo = void 0;
if (resolver !== INTERNAL) this._resolveFromResolver(resolver);
}
Promise.prototype.bind = function Promise$bind(thisArg) {
var ret = new Promise(INTERNAL);
ret._setTrace(this);
ret._follow(this);
ret._setBoundTo(thisArg);
if (this._cancellable()) {
ret._setCancellable();
ret._cancellationParent = this;
}
return ret;
};
Promise.prototype.toString = function Promise$toString() {
return "[object Promise]";
};
Promise.prototype.caught = Promise.prototype["catch"] =
function Promise$catch(fn) {
var len = arguments.length;
if (len > 1) {
var catchInstances = new Array(len - 1),
j = 0, i;
for (i = 0; i < len - 1; ++i) {
var item = arguments[i];
if (typeof item === "function") {
catchInstances[j++] = item;
}
else {
var catchFilterTypeError =
new TypeError(
"A catch filter must be an error constructor "
+ "or a filter function");
this._attachExtraTrace(catchFilterTypeError);
async.invoke(this._reject, this, catchFilterTypeError);
return;
}
}
catchInstances.length = j;
fn = arguments[i];
this._resetTrace();
var catchFilter = new CatchFilter(catchInstances, fn, this);
return this._then(void 0, catchFilter.doFilter, void 0,
catchFilter, void 0);
}
return this._then(void 0, fn, void 0, void 0, void 0);
};
Promise.prototype.then =
function Promise$then(didFulfill, didReject, didProgress) {
return this._then(didFulfill, didReject, didProgress,
void 0, void 0);
};
Promise.prototype.done =
function Promise$done(didFulfill, didReject, didProgress) {
var promise = this._then(didFulfill, didReject, didProgress,
void 0, void 0);
promise._setIsFinal();
};
Promise.prototype.spread = function Promise$spread(didFulfill, didReject) {
return this._then(didFulfill, didReject, void 0,
APPLY, void 0);
};
Promise.prototype.isCancellable = function Promise$isCancellable() {
return !this.isResolved() &&
this._cancellable();
};
Promise.prototype.toJSON = function Promise$toJSON() {
var ret = {
isFulfilled: false,
isRejected: false,
fulfillmentValue: void 0,
rejectionReason: void 0
};
if (this.isFulfilled()) {
ret.fulfillmentValue = this._settledValue;
ret.isFulfilled = true;
}
else if (this.isRejected()) {
ret.rejectionReason = this._settledValue;
ret.isRejected = true;
}
return ret;
};
Promise.prototype.all = function Promise$all() {
return Promise$_all(this, true);
};
Promise.is = isPromise;
function Promise$_all(promises, useBound) {
return Promise$_CreatePromiseArray(
promises,
PromiseArray,
useBound === true && promises._isBound()
? promises._boundTo
: void 0
).promise();
}
Promise.all = function Promise$All(promises) {
return Promise$_all(promises, false);
};
Promise.join = function Promise$Join() {
var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];}
return Promise$_CreatePromiseArray(args, PromiseArray, void 0).promise();
};
Promise.resolve = Promise.fulfilled =
function Promise$Resolve(value) {
var ret = new Promise(INTERNAL);
ret._setTrace(void 0);
if (ret._tryFollow(value)) {
return ret;
}
ret._cleanValues();
ret._setFulfilled();
ret._settledValue = value;
return ret;
};
Promise.reject = Promise.rejected = function Promise$Reject(reason) {
var ret = new Promise(INTERNAL);
ret._setTrace(void 0);
markAsOriginatingFromRejection(reason);
ret._cleanValues();
ret._setRejected();
ret._settledValue = reason;
if (!canAttach(reason)) {
var trace = new Error(reason + "");
ret._setCarriedStackTrace(trace);
}
ret._ensurePossibleRejectionHandled();
return ret;
};
Promise.prototype.error = function Promise$_error(fn) {
return this.caught(originatesFromRejection, fn);
};
Promise.prototype._resolveFromSyncValue =
function Promise$_resolveFromSyncValue(value) {
if (value === errorObj) {
this._cleanValues();
this._setRejected();
this._settledValue = value.e;
this._ensurePossibleRejectionHandled();
}
else {
var maybePromise = Promise._cast(value, void 0);
if (maybePromise instanceof Promise) {
this._follow(maybePromise);
}
else {
this._cleanValues();
this._setFulfilled();
this._settledValue = value;
}
}
};
Promise.method = function Promise$_Method(fn) {
if (typeof fn !== "function") {
throw new TypeError("fn must be a function");
}
return function Promise$_method() {
var value;
switch(arguments.length) {
case 0: value = tryCatch1(fn, this, void 0); break;
case 1: value = tryCatch1(fn, this, arguments[0]); break;
case 2: value = tryCatch2(fn, this, arguments[0], arguments[1]); break;
default:
var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];}
value = tryCatchApply(fn, args, this); break;
}
var ret = new Promise(INTERNAL);
ret._setTrace(void 0);
ret._resolveFromSyncValue(value);
return ret;
};
};
Promise.attempt = Promise["try"] = function Promise$_Try(fn, args, ctx) {
if (typeof fn !== "function") {
return apiRejection("fn must be a function");
}
var value = isArray(args)
? tryCatchApply(fn, args, ctx)
: tryCatch1(fn, ctx, args);
var ret = new Promise(INTERNAL);
ret._setTrace(void 0);
ret._resolveFromSyncValue(value);
return ret;
};
Promise.defer = Promise.pending = function Promise$Defer() {
var promise = new Promise(INTERNAL);
promise._setTrace(void 0);
return new PromiseResolver(promise);
};
Promise.bind = function Promise$Bind(thisArg) {
var ret = new Promise(INTERNAL);
ret._setTrace(void 0);
ret._setFulfilled();
ret._setBoundTo(thisArg);
return ret;
};
Promise.cast = function Promise$_Cast(obj) {
var ret = Promise._cast(obj, void 0);
if (!(ret instanceof Promise)) {
return Promise.resolve(ret);
}
return ret;
};
Promise.onPossiblyUnhandledRejection =
function Promise$OnPossiblyUnhandledRejection(fn) {
CapturedTrace.possiblyUnhandledRejection = typeof fn === "function"
? fn : void 0;
};
var unhandledRejectionHandled;
Promise.onUnhandledRejectionHandled =
function Promise$onUnhandledRejectionHandled(fn) {
unhandledRejectionHandled = typeof fn === "function" ? fn : void 0;
};
var debugging = false || !!(
typeof process !== "undefined" &&
typeof process.execPath === "string" &&
typeof process.env === "object" &&
(process.env["BLUEBIRD_DEBUG"] ||
process.env["NODE_ENV"] === "development")
);
Promise.longStackTraces = function Promise$LongStackTraces() {
if (async.haveItemsQueued() &&
debugging === false
) {
throw new Error("cannot enable long stack traces after promises have been created");
}
debugging = CapturedTrace.isSupported();
};
Promise.hasLongStackTraces = function Promise$HasLongStackTraces() {
return debugging && CapturedTrace.isSupported();
};
Promise.prototype._setProxyHandlers =
function Promise$_setProxyHandlers(receiver, promiseSlotValue) {
var index = this._length();
if (index >= 524287 - 5) {
index = 0;
this._setLength(0);
}
if (index === 0) {
this._promise0 = promiseSlotValue;
this._receiver0 = receiver;
}
else {
var i = index - 5;
this[i + 3] = promiseSlotValue;
this[i + 4] = receiver;
this[i + 0] =
this[i + 1] =
this[i + 2] = void 0;
}
this._setLength(index + 5);
};
Promise.prototype._proxyPromiseArray =
function Promise$_proxyPromiseArray(promiseArray, index) {
this._setProxyHandlers(promiseArray, index);
};
Promise.prototype._proxyPromise = function Promise$_proxyPromise(promise) {
promise._setProxied();
this._setProxyHandlers(promise, -1);
};
Promise.prototype._then =
function Promise$_then(
didFulfill,
didReject,
didProgress,
receiver,
internalData
) {
var haveInternalData = internalData !== void 0;
var ret = haveInternalData ? internalData : new Promise(INTERNAL);
if (debugging && !haveInternalData) {
var haveSameContext = this._peekContext() === this._traceParent;
ret._traceParent = haveSameContext ? this._traceParent : this;
ret._setTrace(this);
}
if (!haveInternalData && this._isBound()) {
ret._setBoundTo(this._boundTo);
}
var callbackIndex =
this._addCallbacks(didFulfill, didReject, didProgress, ret, receiver);
if (!haveInternalData && this._cancellable()) {
ret._setCancellable();
ret._cancellationParent = this;
}
if (this.isResolved()) {
async.invoke(this._queueSettleAt, this, callbackIndex);
}
return ret;
};
Promise.prototype._length = function Promise$_length() {
return this._bitField & 524287;
};
Promise.prototype._isFollowingOrFulfilledOrRejected =
function Promise$_isFollowingOrFulfilledOrRejected() {
return (this._bitField & 939524096) > 0;
};
Promise.prototype._isFollowing = function Promise$_isFollowing() {
return (this._bitField & 536870912) === 536870912;
};
Promise.prototype._setLength = function Promise$_setLength(len) {
this._bitField = (this._bitField & -524288) |
(len & 524287);
};
Promise.prototype._setFulfilled = function Promise$_setFulfilled() {
this._bitField = this._bitField | 268435456;
};
Promise.prototype._setRejected = function Promise$_setRejected() {
this._bitField = this._bitField | 134217728;
};
Promise.prototype._setFollowing = function Promise$_setFollowing() {
this._bitField = this._bitField | 536870912;
};
Promise.prototype._setIsFinal = function Promise$_setIsFinal() {
this._bitField = this._bitField | 33554432;
};
Promise.prototype._isFinal = function Promise$_isFinal() {
return (this._bitField & 33554432) > 0;
};
Promise.prototype._cancellable = function Promise$_cancellable() {
return (this._bitField & 67108864) > 0;
};
Promise.prototype._setCancellable = function Promise$_setCancellable() {
this._bitField = this._bitField | 67108864;
};
Promise.prototype._unsetCancellable = function Promise$_unsetCancellable() {
this._bitField = this._bitField & (~67108864);
};
Promise.prototype._setRejectionIsUnhandled =
function Promise$_setRejectionIsUnhandled() {
this._bitField = this._bitField | 2097152;
};
Promise.prototype._unsetRejectionIsUnhandled =
function Promise$_unsetRejectionIsUnhandled() {
this._bitField = this._bitField & (~2097152);
if (this._isUnhandledRejectionNotified()) {
this._unsetUnhandledRejectionIsNotified();
this._notifyUnhandledRejectionIsHandled();
}
};
Promise.prototype._isRejectionUnhandled =
function Promise$_isRejectionUnhandled() {
return (this._bitField & 2097152) > 0;
};
Promise.prototype._setUnhandledRejectionIsNotified =
function Promise$_setUnhandledRejectionIsNotified() {
this._bitField = this._bitField | 524288;
};
Promise.prototype._unsetUnhandledRejectionIsNotified =
function Promise$_unsetUnhandledRejectionIsNotified() {
this._bitField = this._bitField & (~524288);
};
Promise.prototype._isUnhandledRejectionNotified =
function Promise$_isUnhandledRejectionNotified() {
return (this._bitField & 524288) > 0;
};
Promise.prototype._setCarriedStackTrace =
function Promise$_setCarriedStackTrace(capturedTrace) {
this._bitField = this._bitField | 1048576;
this._fulfillmentHandler0 = capturedTrace;
};
Promise.prototype._unsetCarriedStackTrace =
function Promise$_unsetCarriedStackTrace() {
this._bitField = this._bitField & (~1048576);
this._fulfillmentHandler0 = void 0;
};
Promise.prototype._isCarryingStackTrace =
function Promise$_isCarryingStackTrace() {
return (this._bitField & 1048576) > 0;
};
Promise.prototype._getCarriedStackTrace =
function Promise$_getCarriedStackTrace() {
return this._isCarryingStackTrace()
? this._fulfillmentHandler0
: void 0;
};
Promise.prototype._receiverAt = function Promise$_receiverAt(index) {
var ret;
if (index === 0) {
ret = this._receiver0;
}
else {
ret = this[index + 4 - 5];
}
if (this._isBound() && ret === void 0) {
return this._boundTo;
}
return ret;
};
Promise.prototype._promiseAt = function Promise$_promiseAt(index) {
if (index === 0) return this._promise0;
return this[index + 3 - 5];
};
Promise.prototype._fulfillmentHandlerAt =
function Promise$_fulfillmentHandlerAt(index) {
if (index === 0) return this._fulfillmentHandler0;
return this[index + 0 - 5];
};
Promise.prototype._rejectionHandlerAt =
function Promise$_rejectionHandlerAt(index) {
if (index === 0) return this._rejectionHandler0;
return this[index + 1 - 5];
};
Promise.prototype._unsetAt = function Promise$_unsetAt(index) {
if (index === 0) {
this._rejectionHandler0 =
this._progressHandler0 =
this._promise0 =
this._receiver0 = void 0;
if (!this._isCarryingStackTrace()) {
this._fulfillmentHandler0 = void 0;
}
}
else {
this[index - 5 + 0] =
this[index - 5 + 1] =
this[index - 5 + 2] =
this[index - 5 + 3] =
this[index - 5 + 4] = void 0;
}
};
Promise.prototype._resolveFromResolver =
function Promise$_resolveFromResolver(resolver) {
var promise = this;
this._setTrace(void 0);
this._pushContext();
function Promise$_resolver(val) {
if (promise._tryFollow(val)) {
return;
}
promise._fulfill(val);
}
function Promise$_rejecter(val) {
var trace = canAttach(val) ? val : new Error(val + "");
promise._attachExtraTrace(trace);
markAsOriginatingFromRejection(val);
promise._reject(val, trace === val ? void 0 : trace);
}
var r = tryCatch2(resolver, void 0, Promise$_resolver, Promise$_rejecter);
this._popContext();
if (r !== void 0 && r === errorObj) {
var e = r.e;
var trace = canAttach(e) ? e : new Error(e + "");
promise._reject(e, trace);
}
};
Promise.prototype._addCallbacks = function Promise$_addCallbacks(
fulfill,
reject,
progress,
promise,
receiver
) {
var index = this._length();
if (index >= 524287 - 5) {
index = 0;
this._setLength(0);
}
if (index === 0) {
this._promise0 = promise;
if (receiver !== void 0) this._receiver0 = receiver;
if (typeof fulfill === "function" && !this._isCarryingStackTrace())
this._fulfillmentHandler0 = fulfill;
if (typeof reject === "function") this._rejectionHandler0 = reject;
if (typeof progress === "function") this._progressHandler0 = progress;
}
else {
var i = index - 5;
this[i + 3] = promise;
this[i + 4] = receiver;
this[i + 0] = typeof fulfill === "function"
? fulfill : void 0;
this[i + 1] = typeof reject === "function"
? reject : void 0;
this[i + 2] = typeof progress === "function"
? progress : void 0;
}
this._setLength(index + 5);
return index;
};
Promise.prototype._setBoundTo = function Promise$_setBoundTo(obj) {
if (obj !== void 0) {
this._bitField = this._bitField | 8388608;
this._boundTo = obj;
}
else {
this._bitField = this._bitField & (~8388608);
}
};
Promise.prototype._isBound = function Promise$_isBound() {
return (this._bitField & 8388608) === 8388608;
};
Promise.prototype._spreadSlowCase =
function Promise$_spreadSlowCase(targetFn, promise, values, boundTo) {
var promiseForAll =
Promise$_CreatePromiseArray
(values, PromiseArray, boundTo)
.promise()
._then(function() {
return targetFn.apply(boundTo, arguments);
}, void 0, void 0, APPLY, void 0);
promise._follow(promiseForAll);
};
Promise.prototype._callSpread =
function Promise$_callSpread(handler, promise, value, localDebugging) {
var boundTo = this._isBound() ? this._boundTo : void 0;
if (isArray(value)) {
for (var i = 0, len = value.length; i < len; ++i) {
if (isPromise(Promise._cast(value[i], void 0))) {
this._spreadSlowCase(handler, promise, value, boundTo);
return;
}
}
}
if (localDebugging) promise._pushContext();
return tryCatchApply(handler, value, boundTo);
};
Promise.prototype._callHandler =
function Promise$_callHandler(
handler, receiver, promise, value, localDebugging) {
var x;
if (receiver === APPLY && !this.isRejected()) {
x = this._callSpread(handler, promise, value, localDebugging);
}
else {
if (localDebugging) promise._pushContext();
x = tryCatch1(handler, receiver, value);
}
if (localDebugging) promise._popContext();
return x;
};
Promise.prototype._settlePromiseFromHandler =
function Promise$_settlePromiseFromHandler(
handler, receiver, value, promise
) {
if (!isPromise(promise)) {
handler.call(receiver, value, promise);
return;
}
var localDebugging = debugging;
var x = this._callHandler(handler, receiver,
promise, value, localDebugging);
if (promise._isFollowing()) return;
if (x === errorObj || x === promise || x === NEXT_FILTER) {
var err = x === promise
? makeSelfResolutionError()
: x.e;
var trace = canAttach(err) ? err : new Error(err + "");
if (x !== NEXT_FILTER) promise._attachExtraTrace(trace);
promise._rejectUnchecked(err, trace);
}
else {
var castValue = Promise._cast(x, promise);
if (isPromise(castValue)) {
if (castValue.isRejected() &&
!castValue._isCarryingStackTrace() &&
!canAttach(castValue._settledValue)) {
var trace = new Error(castValue._settledValue + "");
promise._attachExtraTrace(trace);
castValue._setCarriedStackTrace(trace);
}
promise._follow(castValue);
if (castValue._cancellable()) {
promise._cancellationParent = castValue;
promise._setCancellable();
}
}
else {
promise._fulfillUnchecked(x);
}
}
};
Promise.prototype._follow =
function Promise$_follow(promise) {
this._setFollowing();
if (promise.isPending()) {
if (promise._cancellable() ) {
this._cancellationParent = promise;
this._setCancellable();
}
promise._proxyPromise(this);
}
else if (promise.isFulfilled()) {
this._fulfillUnchecked(promise._settledValue);
}
else {
this._rejectUnchecked(promise._settledValue,
promise._getCarriedStackTrace());
}
if (promise._isRejectionUnhandled()) promise._unsetRejectionIsUnhandled();
if (debugging &&
promise._traceParent == null) {
promise._traceParent = this;
}
};
Promise.prototype._tryFollow =
function Promise$_tryFollow(value) {
if (this._isFollowingOrFulfilledOrRejected() ||
value === this) {
return false;
}
var maybePromise = Promise._cast(value, void 0);
if (!isPromise(maybePromise)) {
return false;
}
this._follow(maybePromise);
return true;
};
Promise.prototype._resetTrace = function Promise$_resetTrace() {
if (debugging) {
this._trace = new CapturedTrace(this._peekContext() === void 0);
}
};
Promise.prototype._setTrace = function Promise$_setTrace(parent) {
if (debugging) {
var context = this._peekContext();
this._traceParent = context;
var isTopLevel = context === void 0;
if (parent !== void 0 &&
parent._traceParent === context) {
this._trace = parent._trace;
}
else {
this._trace = new CapturedTrace(isTopLevel);
}
}
return this;
};
Promise.prototype._attachExtraTrace =
function Promise$_attachExtraTrace(error) {
if (debugging) {
var promise = this;
var stack = error.stack;
stack = typeof stack === "string"
? stack.split("\n") : [];
var headerLineCount = 1;
while(promise != null &&
promise._trace != null) {
stack = CapturedTrace.combine(
stack,
promise._trace.stack.split("\n")
);
promise = promise._traceParent;
}
var max = Error.stackTraceLimit + headerLineCount;
var len = stack.length;
if (len > max) {
stack.length = max;
}
if (stack.length <= headerLineCount) {
error.stack = "(No stack trace)";
}
else {
error.stack = stack.join("\n");
}
}
};
Promise.prototype._cleanValues = function Promise$_cleanValues() {
if (this._cancellable()) {
this._cancellationParent = void 0;
}
};
Promise.prototype._fulfill = function Promise$_fulfill(value) {
if (this._isFollowingOrFulfilledOrRejected()) return;
this._fulfillUnchecked(value);
};
Promise.prototype._reject =
function Promise$_reject(reason, carriedStackTrace) {
if (this._isFollowingOrFulfilledOrRejected()) return;
this._rejectUnchecked(reason, carriedStackTrace);
};
Promise.prototype._settlePromiseAt = function Promise$_settlePromiseAt(index) {
var handler = this.isFulfilled()
? this._fulfillmentHandlerAt(index)
: this._rejectionHandlerAt(index);
var value = this._settledValue;
var receiver = this._receiverAt(index);
var promise = this._promiseAt(index);
if (typeof handler === "function") {
this._settlePromiseFromHandler(handler, receiver, value, promise);
}
else {
var done = false;
var isFulfilled = this.isFulfilled();
if (receiver !== void 0) {
if (receiver instanceof Promise &&
receiver._isProxied()) {
receiver._unsetProxied();
if (isFulfilled) receiver._fulfillUnchecked(value);
else receiver._rejectUnchecked(value,
this._getCarriedStackTrace());
done = true;
}
else if (isPromiseArrayProxy(receiver, promise)) {
if (isFulfilled) receiver._promiseFulfilled(value, promise);
else receiver._promiseRejected(value, promise);
done = true;
}
}
if (!done) {
if (isFulfilled) promise._fulfill(value);
else promise._reject(value, this._getCarriedStackTrace());
}
}
if (index >= 256) {
this._queueGC();
}
};
Promise.prototype._isProxied = function Promise$_isProxied() {
return (this._bitField & 4194304) === 4194304;
};
Promise.prototype._setProxied = function Promise$_setProxied() {
this._bitField = this._bitField | 4194304;
};
Promise.prototype._unsetProxied = function Promise$_unsetProxied() {
this._bitField = this._bitField & (~4194304);
};
Promise.prototype._isGcQueued = function Promise$_isGcQueued() {
return (this._bitField & -1073741824) === -1073741824;
};
Promise.prototype._setGcQueued = function Promise$_setGcQueued() {
this._bitField = this._bitField | -1073741824;
};
Promise.prototype._unsetGcQueued = function Promise$_unsetGcQueued() {
this._bitField = this._bitField & (~-1073741824);
};
Promise.prototype._queueGC = function Promise$_queueGC() {
if (this._isGcQueued()) return;
this._setGcQueued();
async.invokeLater(this._gc, this, void 0);
};
Promise.prototype._gc = function Promise$gc() {
var len = this._length();
this._unsetAt(0);
for (var i = 0; i < len; i++) {
delete this[i];
}
this._setLength(0);
this._unsetGcQueued();
};
Promise.prototype._queueSettleAt = function Promise$_queueSettleAt(index) {
if (this._isRejectionUnhandled()) this._unsetRejectionIsUnhandled();
async.invoke(this._settlePromiseAt, this, index);
};
Promise.prototype._fulfillUnchecked =
function Promise$_fulfillUnchecked(value) {
if (!this.isPending()) return;
if (value === this) {
var err = makeSelfResolutionError();
this._attachExtraTrace(err);
return this._rejectUnchecked(err, void 0);
}
this._cleanValues();
this._setFulfilled();
this._settledValue = value;
var len = this._length();
if (len > 0) {
async.invoke(this._settlePromises, this, len);
}
};
Promise.prototype._rejectUncheckedCheckError =
function Promise$_rejectUncheckedCheckError(reason) {
var trace = canAttach(reason) ? reason : new Error(reason + "");
this._rejectUnchecked(reason, trace === reason ? void 0 : trace);
};
Promise.prototype._rejectUnchecked =
function Promise$_rejectUnchecked(reason, trace) {
if (!this.isPending()) return;
if (reason === this) {
var err = makeSelfResolutionError();
this._attachExtraTrace(err);
return this._rejectUnchecked(err);
}
this._cleanValues();
this._setRejected();
this._settledValue = reason;
if (this._isFinal()) {
async.invokeLater(thrower, void 0, trace === void 0 ? reason : trace);
return;
}
var len = this._length();
if (trace !== void 0) this._setCarriedStackTrace(trace);
if (len > 0) {
async.invoke(this._rejectPromises, this, null);
}
else {
this._ensurePossibleRejectionHandled();
}
};
Promise.prototype._rejectPromises = function Promise$_rejectPromises() {
this._settlePromises();
this._unsetCarriedStackTrace();
};
Promise.prototype._settlePromises = function Promise$_settlePromises() {
var len = this._length();
for (var i = 0; i < len; i+= 5) {
this._settlePromiseAt(i);
}
};
Promise.prototype._ensurePossibleRejectionHandled =
function Promise$_ensurePossibleRejectionHandled() {
this._setRejectionIsUnhandled();
if (CapturedTrace.possiblyUnhandledRejection !== void 0) {
async.invokeLater(this._notifyUnhandledRejection, this, void 0);
}
};
Promise.prototype._notifyUnhandledRejectionIsHandled =
function Promise$_notifyUnhandledRejectionIsHandled() {
if (typeof unhandledRejectionHandled === "function") {
async.invokeLater(unhandledRejectionHandled, void 0, this);
}
};
Promise.prototype._notifyUnhandledRejection =
function Promise$_notifyUnhandledRejection() {
if (this._isRejectionUnhandled()) {
var reason = this._settledValue;
var trace = this._getCarriedStackTrace();
this._setUnhandledRejectionIsNotified();
if (trace !== void 0) {
this._unsetCarriedStackTrace();
reason = trace;
}
if (typeof CapturedTrace.possiblyUnhandledRejection === "function") {
CapturedTrace.possiblyUnhandledRejection(reason, this);
}
}
};
var contextStack = [];
Promise.prototype._peekContext = function Promise$_peekContext() {
var lastIndex = contextStack.length - 1;
if (lastIndex >= 0) {
return contextStack[lastIndex];
}
return void 0;
};
Promise.prototype._pushContext = function Promise$_pushContext() {
if (!debugging) return;
contextStack.push(this);
};
Promise.prototype._popContext = function Promise$_popContext() {
if (!debugging) return;
contextStack.pop();
};
function Promise$_CreatePromiseArray(
promises, PromiseArrayConstructor, boundTo) {
var list = null;
if (isArray(promises)) {
list = promises;
}
else {
list = Promise._cast(promises, void 0);
if (list !== promises) {
list._setBoundTo(boundTo);
}
else if (!isPromise(list)) {
list = null;
}
}
if (list !== null) {
return new PromiseArrayConstructor(list, boundTo);
}
return {
promise: function() {return apiRejection("expecting an array, a promise or a thenable");}
};
}
var old = global.Promise;
Promise.noConflict = function() {
if (global.Promise === Promise) {
global.Promise = old;
}
return Promise;
};
if (!CapturedTrace.isSupported()) {
Promise.longStackTraces = function(){};
debugging = false;
}
Promise._makeSelfResolutionError = makeSelfResolutionError;
__webpack_require__(116)(Promise, NEXT_FILTER);
__webpack_require__(117)(Promise);
__webpack_require__(118)(Promise, INTERNAL);
__webpack_require__(119)(Promise);
Promise.RangeError = RangeError;
Promise.CancellationError = CancellationError;
Promise.TimeoutError = TimeoutError;
Promise.TypeError = TypeError;
Promise.RejectionError = RejectionError;
util.toFastProperties(Promise);
util.toFastProperties(Promise.prototype);
__webpack_require__(120)(Promise,INTERNAL);
__webpack_require__(121)(Promise,Promise$_CreatePromiseArray,PromiseArray);
__webpack_require__(122)(Promise,INTERNAL);
__webpack_require__(123)(Promise);
__webpack_require__(124)(Promise,Promise$_CreatePromiseArray,PromiseArray,apiRejection);
__webpack_require__(125)(Promise,apiRejection,INTERNAL);
__webpack_require__(126)(Promise,PromiseArray,INTERNAL,apiRejection);
__webpack_require__(127)(Promise);
__webpack_require__(128)(Promise,INTERNAL);
__webpack_require__(129)(Promise,PromiseArray);
__webpack_require__(130)(Promise,Promise$_CreatePromiseArray,PromiseArray,apiRejection,INTERNAL);
__webpack_require__(131)(Promise,Promise$_CreatePromiseArray,PromiseArray);
__webpack_require__(132)(Promise,Promise$_CreatePromiseArray,PromiseArray,apiRejection);
__webpack_require__(133)(Promise,isPromiseArrayProxy);
__webpack_require__(134)(Promise,INTERNAL);
Promise.prototype = Promise.prototype;
return Promise;
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(99)))
/***/ },
/* 92 */
/***/ function(module, exports, __webpack_require__) {
var exports = module.exports = function (alg) {
var Alg = exports[alg]
if(!Alg) throw new Error(alg + ' is not supported (we accept pull requests)')
return new Alg()
}
var Buffer = __webpack_require__(47).Buffer
var Hash = __webpack_require__(135)(Buffer)
exports.sha1 = __webpack_require__(136)(Buffer, Hash)
exports.sha256 = __webpack_require__(137)(Buffer, Hash)
exports.sha512 = __webpack_require__(138)(Buffer, Hash)
/***/ },
/* 93 */
/***/ function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(143);
exports.Stream = __webpack_require__(64);
exports.Readable = exports;
exports.Writable = __webpack_require__(141);
exports.Duplex = __webpack_require__(142);
exports.Transform = __webpack_require__(144);
exports.PassThrough = __webpack_require__(145);
/***/ },
/* 94 */
/***/ function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(141)
/***/ },
/* 95 */
/***/ function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(142)
/***/ },
/* 96 */
/***/ function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(144)
/***/ },
/* 97 */
/***/ function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(145)
/***/ },
/* 98 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {var intSize = 4;
var zeroBuffer = new Buffer(intSize); zeroBuffer.fill(0);
var chrsz = 8;
function toArray(buf, bigEndian) {
if ((buf.length % intSize) !== 0) {
var len = buf.length + (intSize - (buf.length % intSize));
buf = Buffer.concat([buf, zeroBuffer], len);
}
var arr = [];
var fn = bigEndian ? buf.readInt32BE : buf.readInt32LE;
for (var i = 0; i < buf.length; i += intSize) {
arr.push(fn.call(buf, i));
}
return arr;
}
function toBuffer(arr, size, bigEndian) {
var buf = new Buffer(size);
var fn = bigEndian ? buf.writeInt32BE : buf.writeInt32LE;
for (var i = 0; i < arr.length; i++) {
fn.call(buf, arr[i], i * 4, true);
}
return buf;
}
function hash(buf, fn, hashSize, bigEndian) {
if (!Buffer.isBuffer(buf)) buf = new Buffer(buf);
var arr = fn(toArray(buf, bigEndian), buf.length * chrsz);
return toBuffer(arr, hashSize, bigEndian);
}
module.exports = { hash: hash };
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 99 */
/***/ function(module, exports, __webpack_require__) {
// shim for using process in browser
var process = module.exports = {};
process.nextTick = (function () {
var canSetImmediate = typeof window !== 'undefined'
&& window.setImmediate;
var canMutationObserver = typeof window !== 'undefined'
&& window.MutationObserver;
var canPost = typeof window !== 'undefined'
&& window.postMessage && window.addEventListener
;
if (canSetImmediate) {
return function (f) { return window.setImmediate(f) };
}
var queue = [];
if (canMutationObserver) {
var hiddenDiv = document.createElement("div");
var observer = new MutationObserver(function () {
var queueList = queue.slice();
queue.length = 0;
queueList.forEach(function (fn) {
fn();
});
});
observer.observe(hiddenDiv, { attributes: true });
return function nextTick(fn) {
if (!queue.length) {
hiddenDiv.setAttribute('yes', 'no');
}
queue.push(fn);
};
}
if (canPost) {
window.addEventListener('message', function (ev) {
var source = ev.source;
if ((source === window || source === null) && ev.data === 'process-tick') {
ev.stopPropagation();
if (queue.length > 0) {
var fn = queue.shift();
fn();
}
}
}, true);
return function nextTick(fn) {
queue.push(fn);
window.postMessage('process-tick', '*');
};
}
return function nextTick(fn) {
setTimeout(fn, 0);
};
})();
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
function noop() {}
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.binding = function (name) {
throw new Error('process.binding is not supported');
};
// TODO(shtylman)
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
/***/ },
/* 100 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {module.exports = function(crypto) {
function pbkdf2(password, salt, iterations, keylen, digest, callback) {
if ('function' === typeof digest) {
callback = digest
digest = undefined
}
if ('function' !== typeof callback)
throw new Error('No callback provided to pbkdf2')
setTimeout(function() {
var result
try {
result = pbkdf2Sync(password, salt, iterations, keylen, digest)
} catch (e) {
return callback(e)
}
callback(undefined, result)
})
}
function pbkdf2Sync(password, salt, iterations, keylen, digest) {
if ('number' !== typeof iterations)
throw new TypeError('Iterations not a number')
if (iterations < 0)
throw new TypeError('Bad iterations')
if ('number' !== typeof keylen)
throw new TypeError('Key length not a number')
if (keylen < 0)
throw new TypeError('Bad key length')
digest = digest || 'sha1'
if (!Buffer.isBuffer(password)) password = new Buffer(password)
if (!Buffer.isBuffer(salt)) salt = new Buffer(salt)
var hLen, l = 1, r, T
var DK = new Buffer(keylen)
var block1 = new Buffer(salt.length + 4)
salt.copy(block1, 0, 0, salt.length)
for (var i = 1; i <= l; i++) {
block1.writeUInt32BE(i, salt.length)
var U = crypto.createHmac(digest, password).update(block1).digest()
if (!hLen) {
hLen = U.length
T = new Buffer(hLen)
l = Math.ceil(keylen / hLen)
r = keylen - (l - 1) * hLen
if (keylen > (Math.pow(2, 32) - 1) * hLen)
throw new TypeError('keylen exceeds maximum length')
}
U.copy(T, 0, 0, hLen)
for (var j = 1; j < iterations; j++) {
U = crypto.createHmac(digest, password).update(U).digest()
for (var k = 0; k < hLen; k++) {
T[k] ^= U[k]
}
}
var destPos = (i - 1) * hLen
var len = (i == l ? r : hLen)
T.copy(DK, destPos, 0, len)
}
return DK
}
return {
pbkdf2: pbkdf2,
pbkdf2Sync: pbkdf2Sync
}
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 101 */
/***/ function(module, exports, __webpack_require__) {
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
};
} else {
// old school shim for old browsers
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
TempCtor.prototype = superCtor.prototype
ctor.prototype = new TempCtor()
ctor.prototype.constructor = ctor
}
}
/***/ },
/* 102 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {
module.exports = ripemd160
/*
CryptoJS v3.1.2
code.google.com/p/crypto-js
(c) 2009-2013 by Jeff Mott. All rights reserved.
code.google.com/p/crypto-js/wiki/License
*/
/** @preserve
(c) 2012 by Cédric Mesnil. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// Constants table
var zl = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13];
var zr = [
5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11];
var sl = [
11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 ];
var sr = [
8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 ];
var hl = [ 0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E];
var hr = [ 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000];
var bytesToWords = function (bytes) {
var words = [];
for (var i = 0, b = 0; i < bytes.length; i++, b += 8) {
words[b >>> 5] |= bytes[i] << (24 - b % 32);
}
return words;
};
var wordsToBytes = function (words) {
var bytes = [];
for (var b = 0; b < words.length * 32; b += 8) {
bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);
}
return bytes;
};
var processBlock = function (H, M, offset) {
// Swap endian
for (var i = 0; i < 16; i++) {
var offset_i = offset + i;
var M_offset_i = M[offset_i];
// Swap
M[offset_i] = (
(((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |
(((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)
);
}
// Working variables
var al, bl, cl, dl, el;
var ar, br, cr, dr, er;
ar = al = H[0];
br = bl = H[1];
cr = cl = H[2];
dr = dl = H[3];
er = el = H[4];
// Computation
var t;
for (var i = 0; i < 80; i += 1) {
t = (al + M[offset+zl[i]])|0;
if (i<16){
t += f1(bl,cl,dl) + hl[0];
} else if (i<32) {
t += f2(bl,cl,dl) + hl[1];
} else if (i<48) {
t += f3(bl,cl,dl) + hl[2];
} else if (i<64) {
t += f4(bl,cl,dl) + hl[3];
} else {// if (i<80) {
t += f5(bl,cl,dl) + hl[4];
}
t = t|0;
t = rotl(t,sl[i]);
t = (t+el)|0;
al = el;
el = dl;
dl = rotl(cl, 10);
cl = bl;
bl = t;
t = (ar + M[offset+zr[i]])|0;
if (i<16){
t += f5(br,cr,dr) + hr[0];
} else if (i<32) {
t += f4(br,cr,dr) + hr[1];
} else if (i<48) {
t += f3(br,cr,dr) + hr[2];
} else if (i<64) {
t += f2(br,cr,dr) + hr[3];
} else {// if (i<80) {
t += f1(br,cr,dr) + hr[4];
}
t = t|0;
t = rotl(t,sr[i]) ;
t = (t+er)|0;
ar = er;
er = dr;
dr = rotl(cr, 10);
cr = br;
br = t;
}
// Intermediate hash value
t = (H[1] + cl + dr)|0;
H[1] = (H[2] + dl + er)|0;
H[2] = (H[3] + el + ar)|0;
H[3] = (H[4] + al + br)|0;
H[4] = (H[0] + bl + cr)|0;
H[0] = t;
};
function f1(x, y, z) {
return ((x) ^ (y) ^ (z));
}
function f2(x, y, z) {
return (((x)&(y)) | ((~x)&(z)));
}
function f3(x, y, z) {
return (((x) | (~(y))) ^ (z));
}
function f4(x, y, z) {
return (((x) & (z)) | ((y)&(~(z))));
}
function f5(x, y, z) {
return ((x) ^ ((y) |(~(z))));
}
function rotl(x,n) {
return (x<<n) | (x>>>(32-n));
}
function ripemd160(message) {
var H = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0];
if (typeof message == 'string')
message = new Buffer(message, 'utf8');
var m = bytesToWords(message);
var nBitsLeft = message.length * 8;
var nBitsTotal = message.length * 8;
// Add padding
m[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
m[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
(((nBitsTotal << 8) | (nBitsTotal >>> 24)) & 0x00ff00ff) |
(((nBitsTotal << 24) | (nBitsTotal >>> 8)) & 0xff00ff00)
);
for (var i=0 ; i<m.length; i += 16) {
processBlock(H, m, i);
}
// Swap endian
for (var i = 0; i < 5; i++) {
// Shortcut
var H_i = H[i];
// Swap
H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |
(((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);
}
var digestbytes = wordsToBytes(H);
return new Buffer(digestbytes);
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 103 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {var aes = __webpack_require__(147);
var Transform = __webpack_require__(148);
var inherits = __webpack_require__(173);
var modes = __webpack_require__(105);
var ebtk = __webpack_require__(149);
var StreamCipher = __webpack_require__(150);
inherits(Cipher, Transform);
function Cipher(mode, key, iv) {
if (!(this instanceof Cipher)) {
return new Cipher(mode, key, iv);
}
Transform.call(this);
this._cache = new Splitter();
this._cipher = new aes.AES(key);
this._prev = new Buffer(iv.length);
iv.copy(this._prev);
this._mode = mode;
}
Cipher.prototype._transform = function (data, _, next) {
this._cache.add(data);
var chunk;
var thing;
while ((chunk = this._cache.get())) {
thing = this._mode.encrypt(this, chunk);
this.push(thing);
}
next();
};
Cipher.prototype._flush = function (next) {
var chunk = this._cache.flush();
this.push(this._mode.encrypt(this, chunk));
this._cipher.scrub();
next();
};
function Splitter() {
if (!(this instanceof Splitter)) {
return new Splitter();
}
this.cache = new Buffer('');
}
Splitter.prototype.add = function (data) {
this.cache = Buffer.concat([this.cache, data]);
};
Splitter.prototype.get = function () {
if (this.cache.length > 15) {
var out = this.cache.slice(0, 16);
this.cache = this.cache.slice(16);
return out;
}
return null;
};
Splitter.prototype.flush = function () {
var len = 16 - this.cache.length;
var padBuff = new Buffer(len);
var i = -1;
while (++i < len) {
padBuff.writeUInt8(len, i);
}
var out = Buffer.concat([this.cache, padBuff]);
return out;
};
var modelist = {
ECB: __webpack_require__(151),
CBC: __webpack_require__(152),
CFB: __webpack_require__(153),
OFB: __webpack_require__(154),
CTR: __webpack_require__(155)
};
module.exports = function (crypto) {
function createCipheriv(suite, password, iv) {
var config = modes[suite];
if (!config) {
throw new TypeError('invalid suite type');
}
if (typeof iv === 'string') {
iv = new Buffer(iv);
}
if (typeof password === 'string') {
password = new Buffer(password);
}
if (password.length !== config.key/8) {
throw new TypeError('invalid key length ' + password.length);
}
if (iv.length !== config.iv) {
throw new TypeError('invalid iv length ' + iv.length);
}
if (config.type === 'stream') {
return new StreamCipher(modelist[config.mode], password, iv);
}
return new Cipher(modelist[config.mode], password, iv);
}
function createCipher (suite, password) {
var config = modes[suite];
if (!config) {
throw new TypeError('invalid suite type');
}
var keys = ebtk(crypto, password, config.key, config.iv);
return createCipheriv(suite, keys.key, keys.iv);
}
return {
createCipher: createCipher,
createCipheriv: createCipheriv
};
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 104 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {var aes = __webpack_require__(147);
var Transform = __webpack_require__(148);
var inherits = __webpack_require__(173);
var modes = __webpack_require__(105);
var StreamCipher = __webpack_require__(150);
var ebtk = __webpack_require__(149);
inherits(Decipher, Transform);
function Decipher(mode, key, iv) {
if (!(this instanceof Decipher)) {
return new Decipher(mode, key, iv);
}
Transform.call(this);
this._cache = new Splitter();
this._last = void 0;
this._cipher = new aes.AES(key);
this._prev = new Buffer(iv.length);
iv.copy(this._prev);
this._mode = mode;
}
Decipher.prototype._transform = function (data, _, next) {
this._cache.add(data);
var chunk;
var thing;
while ((chunk = this._cache.get())) {
thing = this._mode.decrypt(this, chunk);
this.push(thing);
}
next();
};
Decipher.prototype._flush = function (next) {
var chunk = this._cache.flush();
if (!chunk) {
return next;
}
this.push(unpad(this._mode.decrypt(this, chunk)));
next();
};
function Splitter() {
if (!(this instanceof Splitter)) {
return new Splitter();
}
this.cache = new Buffer('');
}
Splitter.prototype.add = function (data) {
this.cache = Buffer.concat([this.cache, data]);
};
Splitter.prototype.get = function () {
if (this.cache.length > 16) {
var out = this.cache.slice(0, 16);
this.cache = this.cache.slice(16);
return out;
}
return null;
};
Splitter.prototype.flush = function () {
if (this.cache.length) {
return this.cache;
}
};
function unpad(last) {
var padded = last[15];
if (padded === 16) {
return;
}
return last.slice(0, 16 - padded);
}
var modelist = {
ECB: __webpack_require__(151),
CBC: __webpack_require__(152),
CFB: __webpack_require__(153),
OFB: __webpack_require__(154),
CTR: __webpack_require__(155)
};
module.exports = function (crypto) {
function createDecipheriv(suite, password, iv) {
var config = modes[suite];
if (!config) {
throw new TypeError('invalid suite type');
}
if (typeof iv === 'string') {
iv = new Buffer(iv);
}
if (typeof password === 'string') {
password = new Buffer(password);
}
if (password.length !== config.key/8) {
throw new TypeError('invalid key length ' + password.length);
}
if (iv.length !== config.iv) {
throw new TypeError('invalid iv length ' + iv.length);
}
if (config.type === 'stream') {
return new StreamCipher(modelist[config.mode], password, iv, true);
}
return new Decipher(modelist[config.mode], password, iv);
}
function createDecipher (suite, password) {
var config = modes[suite];
if (!config) {
throw new TypeError('invalid suite type');
}
var keys = ebtk(crypto, password, config.key, config.iv);
return createDecipheriv(suite, keys.key, keys.iv);
}
return {
createDecipher: createDecipher,
createDecipheriv: createDecipheriv
};
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 105 */
/***/ function(module, exports, __webpack_require__) {
exports['aes-128-ecb'] = {
cipher: 'AES',
key: 128,
iv: 0,
mode: 'ECB',
type: 'block'
};
exports['aes-192-ecb'] = {
cipher: 'AES',
key: 192,
iv: 0,
mode: 'ECB',
type: 'block'
};
exports['aes-256-ecb'] = {
cipher: 'AES',
key: 256,
iv: 0,
mode: 'ECB',
type: 'block'
};
exports['aes-128-cbc'] = {
cipher: 'AES',
key: 128,
iv: 16,
mode: 'CBC',
type: 'block'
};
exports['aes-192-cbc'] = {
cipher: 'AES',
key: 192,
iv: 16,
mode: 'CBC',
type: 'block'
};
exports['aes-256-cbc'] = {
cipher: 'AES',
key: 256,
iv: 16,
mode: 'CBC',
type: 'block'
};
exports['aes128'] = exports['aes-128-cbc'];
exports['aes192'] = exports['aes-192-cbc'];
exports['aes256'] = exports['aes-256-cbc'];
exports['aes-128-cfb'] = {
cipher: 'AES',
key: 128,
iv: 16,
mode: 'CFB',
type: 'stream'
};
exports['aes-192-cfb'] = {
cipher: 'AES',
key: 192,
iv: 16,
mode: 'CFB',
type: 'stream'
};
exports['aes-256-cfb'] = {
cipher: 'AES',
key: 256,
iv: 16,
mode: 'CFB',
type: 'stream'
};
exports['aes-128-ofb'] = {
cipher: 'AES',
key: 128,
iv: 16,
mode: 'OFB',
type: 'stream'
};
exports['aes-192-ofb'] = {
cipher: 'AES',
key: 192,
iv: 16,
mode: 'OFB',
type: 'stream'
};
exports['aes-256-ofb'] = {
cipher: 'AES',
key: 256,
iv: 16,
mode: 'OFB',
type: 'stream'
};
exports['aes-128-ctr'] = {
cipher: 'AES',
key: 128,
iv: 16,
mode: 'CTR',
type: 'stream'
};
exports['aes-192-ctr'] = {
cipher: 'AES',
key: 192,
iv: 16,
mode: 'CTR',
type: 'stream'
};
exports['aes-256-ctr'] = {
cipher: 'AES',
key: 256,
iv: 16,
mode: 'CTR',
type: 'stream'
};
/***/ },
/* 106 */
/***/ function(module, exports, __webpack_require__) {
module.exports = function isBuffer(arg) {
return arg && typeof arg === 'object'
&& typeof arg.copy === 'function'
&& typeof arg.fill === 'function'
&& typeof arg.readUInt8 === 'function';
}
/***/ },
/* 107 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(global) {/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
module.exports = (function() {
if (this !== void 0) return this;
try {return global;}
catch(e) {}
try {return window;}
catch(e) {}
try {return self;}
catch(e) {}
})();
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
/***/ },
/* 108 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
var global = __webpack_require__(107);
var es5 = __webpack_require__(157);
var haveGetters = (function(){
try {
var o = {};
es5.defineProperty(o, "f", {
get: function () {
return 3;
}
});
return o.f === 3;
}
catch (e) {
return false;
}
})();
var canEvaluate = (function() {
if (typeof window !== "undefined" && window !== null &&
typeof window.document !== "undefined" &&
typeof navigator !== "undefined" && navigator !== null &&
typeof navigator.appName === "string" &&
window === global) {
return false;
}
return true;
})();
function deprecated(msg) {
if (typeof console !== "undefined" && console !== null &&
typeof console.warn === "function") {
console.warn("Bluebird: " + msg);
}
}
var errorObj = {e: {}};
function tryCatch1(fn, receiver, arg) {
try {
return fn.call(receiver, arg);
}
catch (e) {
errorObj.e = e;
return errorObj;
}
}
function tryCatch2(fn, receiver, arg, arg2) {
try {
return fn.call(receiver, arg, arg2);
}
catch (e) {
errorObj.e = e;
return errorObj;
}
}
function tryCatchApply(fn, args, receiver) {
try {
return fn.apply(receiver, args);
}
catch (e) {
errorObj.e = e;
return errorObj;
}
}
var inherits = function(Child, Parent) {
var hasProp = {}.hasOwnProperty;
function T() {
this.constructor = Child;
this.constructor$ = Parent;
for (var propertyName in Parent.prototype) {
if (hasProp.call(Parent.prototype, propertyName) &&
propertyName.charAt(propertyName.length-1) !== "$"
) {
this[propertyName + "$"] = Parent.prototype[propertyName];
}
}
}
T.prototype = Parent.prototype;
Child.prototype = new T();
return Child.prototype;
};
function asString(val) {
return typeof val === "string" ? val : ("" + val);
}
function isPrimitive(val) {
return val == null || val === true || val === false ||
typeof val === "string" || typeof val === "number";
}
function isObject(value) {
return !isPrimitive(value);
}
function maybeWrapAsError(maybeError) {
if (!isPrimitive(maybeError)) return maybeError;
return new Error(asString(maybeError));
}
function withAppended(target, appendee) {
var len = target.length;
var ret = new Array(len + 1);
var i;
for (i = 0; i < len; ++i) {
ret[i] = target[i];
}
ret[i] = appendee;
return ret;
}
function notEnumerableProp(obj, name, value) {
if (isPrimitive(obj)) return obj;
var descriptor = {
value: value,
configurable: true,
enumerable: false,
writable: true
};
es5.defineProperty(obj, name, descriptor);
return obj;
}
var wrapsPrimitiveReceiver = (function() {
return this !== "string";
}).call("string");
function thrower(r) {
throw r;
}
function toFastProperties(obj) {
/*jshint -W027*/
function f() {}
f.prototype = obj;
return f;
eval(obj);
}
var ret = {
thrower: thrower,
isArray: es5.isArray,
haveGetters: haveGetters,
notEnumerableProp: notEnumerableProp,
isPrimitive: isPrimitive,
isObject: isObject,
canEvaluate: canEvaluate,
deprecated: deprecated,
errorObj: errorObj,
tryCatch1: tryCatch1,
tryCatch2: tryCatch2,
tryCatchApply: tryCatchApply,
inherits: inherits,
withAppended: withAppended,
asString: asString,
maybeWrapAsError: maybeWrapAsError,
wrapsPrimitiveReceiver: wrapsPrimitiveReceiver,
toFastProperties: toFastProperties
};
module.exports = ret;
/***/ },
/* 109 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
var schedule = __webpack_require__(158);
var Queue = __webpack_require__(159);
var errorObj = __webpack_require__(108).errorObj;
var tryCatch1 = __webpack_require__(108).tryCatch1;
var process = __webpack_require__(107).process;
function Async() {
this._isTickUsed = false;
this._length = 0;
this._lateBuffer = new Queue();
this._functionBuffer = new Queue(25000 * 3);
var self = this;
this.consumeFunctionBuffer = function Async$consumeFunctionBuffer() {
self._consumeFunctionBuffer();
};
}
Async.prototype.haveItemsQueued = function Async$haveItemsQueued() {
return this._length > 0;
};
Async.prototype.invokeLater = function Async$invokeLater(fn, receiver, arg) {
if (process !== void 0 &&
process.domain != null &&
!fn.domain) {
fn = process.domain.bind(fn);
}
this._lateBuffer.push(fn, receiver, arg);
this._queueTick();
};
Async.prototype.invoke = function Async$invoke(fn, receiver, arg) {
if (process !== void 0 &&
process.domain != null &&
!fn.domain) {
fn = process.domain.bind(fn);
}
var functionBuffer = this._functionBuffer;
functionBuffer.push(fn, receiver, arg);
this._length = functionBuffer.length();
this._queueTick();
};
Async.prototype._consumeFunctionBuffer =
function Async$_consumeFunctionBuffer() {
var functionBuffer = this._functionBuffer;
while(functionBuffer.length() > 0) {
var fn = functionBuffer.shift();
var receiver = functionBuffer.shift();
var arg = functionBuffer.shift();
fn.call(receiver, arg);
}
this._reset();
this._consumeLateBuffer();
};
Async.prototype._consumeLateBuffer = function Async$_consumeLateBuffer() {
var buffer = this._lateBuffer;
while(buffer.length() > 0) {
var fn = buffer.shift();
var receiver = buffer.shift();
var arg = buffer.shift();
var res = tryCatch1(fn, receiver, arg);
if (res === errorObj) {
this._queueTick();
if (fn.domain != null) {
fn.domain.emit("error", res.e);
}
else {
throw res.e;
}
}
}
};
Async.prototype._queueTick = function Async$_queue() {
if (!this._isTickUsed) {
schedule(this.consumeFunctionBuffer);
this._isTickUsed = true;
}
};
Async.prototype._reset = function Async$_reset() {
this._isTickUsed = false;
this._length = 0;
};
module.exports = new Async();
/***/ },
/* 110 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
var global = __webpack_require__(107);
var Objectfreeze = __webpack_require__(157).freeze;
var util = __webpack_require__(108);
var inherits = util.inherits;
var notEnumerableProp = util.notEnumerableProp;
var Error = global.Error;
function markAsOriginatingFromRejection(e) {
try {
notEnumerableProp(e, "isAsync", true);
}
catch(ignore) {}
}
function originatesFromRejection(e) {
if (e == null) return false;
return ((e instanceof RejectionError) ||
e["isAsync"] === true);
}
function isError(obj) {
return obj instanceof Error;
}
function canAttach(obj) {
return isError(obj);
}
function subError(nameProperty, defaultMessage) {
function SubError(message) {
if (!(this instanceof SubError)) return new SubError(message);
this.message = typeof message === "string" ? message : defaultMessage;
this.name = nameProperty;
if (Error.captureStackTrace) {
Error.captureStackTrace(this, this.constructor);
}
}
inherits(SubError, Error);
return SubError;
}
var TypeError = global.TypeError;
if (typeof TypeError !== "function") {
TypeError = subError("TypeError", "type error");
}
var RangeError = global.RangeError;
if (typeof RangeError !== "function") {
RangeError = subError("RangeError", "range error");
}
var CancellationError = subError("CancellationError", "cancellation error");
var TimeoutError = subError("TimeoutError", "timeout error");
function RejectionError(message) {
this.name = "RejectionError";
this.message = message;
this.cause = message;
this.isAsync = true;
if (message instanceof Error) {
this.message = message.message;
this.stack = message.stack;
}
else if (Error.captureStackTrace) {
Error.captureStackTrace(this, this.constructor);
}
}
inherits(RejectionError, Error);
var key = "__BluebirdErrorTypes__";
var errorTypes = global[key];
if (!errorTypes) {
errorTypes = Objectfreeze({
CancellationError: CancellationError,
TimeoutError: TimeoutError,
RejectionError: RejectionError
});
notEnumerableProp(global, key, errorTypes);
}
module.exports = {
Error: Error,
TypeError: TypeError,
RangeError: RangeError,
CancellationError: errorTypes.CancellationError,
RejectionError: errorTypes.RejectionError,
TimeoutError: errorTypes.TimeoutError,
originatesFromRejection: originatesFromRejection,
markAsOriginatingFromRejection: markAsOriginatingFromRejection,
canAttach: canAttach
};
/***/ },
/* 111 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise, INTERNAL) {
var canAttach = __webpack_require__(110).canAttach;
var util = __webpack_require__(108);
var async = __webpack_require__(109);
var hasOwn = {}.hasOwnProperty;
var isArray = util.isArray;
function toResolutionValue(val) {
switch(val) {
case -1: return void 0;
case -2: return [];
case -3: return {};
}
}
function PromiseArray(values, boundTo) {
var promise = this._promise = new Promise(INTERNAL);
var parent = void 0;
if (values instanceof Promise) {
parent = values;
if (values._cancellable()) {
promise._setCancellable();
promise._cancellationParent = values;
}
if (values._isBound()) {
promise._setBoundTo(boundTo);
}
}
promise._setTrace(parent);
this._values = values;
this._length = 0;
this._totalResolved = 0;
this._init(void 0, -2);
}
PromiseArray.PropertiesPromiseArray = function() {};
PromiseArray.prototype.length = function PromiseArray$length() {
return this._length;
};
PromiseArray.prototype.promise = function PromiseArray$promise() {
return this._promise;
};
PromiseArray.prototype._init =
function PromiseArray$_init(_, resolveValueIfEmpty) {
var values = this._values;
if (values instanceof Promise) {
if (values.isFulfilled()) {
values = values._settledValue;
if (!isArray(values)) {
var err = new Promise.TypeError("expecting an array, a promise or a thenable");
this.__hardReject__(err);
return;
}
this._values = values;
}
else if (values.isPending()) {
values._then(
this._init,
this._reject,
void 0,
this,
resolveValueIfEmpty
);
return;
}
else {
values._unsetRejectionIsUnhandled();
this._reject(values._settledValue);
return;
}
}
if (values.length === 0) {
this._resolve(toResolutionValue(resolveValueIfEmpty));
return;
}
var len = values.length;
var newLen = len;
var newValues;
if (this instanceof PromiseArray.PropertiesPromiseArray) {
newValues = this._values;
}
else {
newValues = new Array(len);
}
var isDirectScanNeeded = false;
for (var i = 0; i < len; ++i) {
var promise = values[i];
if (promise === void 0 && !hasOwn.call(values, i)) {
newLen--;
continue;
}
var maybePromise = Promise._cast(promise, void 0);
if (maybePromise instanceof Promise) {
if (maybePromise.isPending()) {
maybePromise._proxyPromiseArray(this, i);
}
else {
maybePromise._unsetRejectionIsUnhandled();
isDirectScanNeeded = true;
}
}
else {
isDirectScanNeeded = true;
}
newValues[i] = maybePromise;
}
if (newLen === 0) {
if (resolveValueIfEmpty === -2) {
this._resolve(newValues);
}
else {
this._resolve(toResolutionValue(resolveValueIfEmpty));
}
return;
}
this._values = newValues;
this._length = newLen;
if (isDirectScanNeeded) {
var scanMethod = newLen === len
? this._scanDirectValues
: this._scanDirectValuesHoled;
async.invoke(scanMethod, this, len);
}
};
PromiseArray.prototype._settlePromiseAt =
function PromiseArray$_settlePromiseAt(index) {
var value = this._values[index];
if (!(value instanceof Promise)) {
this._promiseFulfilled(value, index);
}
else if (value.isFulfilled()) {
this._promiseFulfilled(value._settledValue, index);
}
else if (value.isRejected()) {
this._promiseRejected(value._settledValue, index);
}
};
PromiseArray.prototype._scanDirectValuesHoled =
function PromiseArray$_scanDirectValuesHoled(len) {
for (var i = 0; i < len; ++i) {
if (this._isResolved()) {
break;
}
if (hasOwn.call(this._values, i)) {
this._settlePromiseAt(i);
}
}
};
PromiseArray.prototype._scanDirectValues =
function PromiseArray$_scanDirectValues(len) {
for (var i = 0; i < len; ++i) {
if (this._isResolved()) {
break;
}
this._settlePromiseAt(i);
}
};
PromiseArray.prototype._isResolved = function PromiseArray$_isResolved() {
return this._values === null;
};
PromiseArray.prototype._resolve = function PromiseArray$_resolve(value) {
this._values = null;
this._promise._fulfill(value);
};
PromiseArray.prototype.__hardReject__ =
PromiseArray.prototype._reject = function PromiseArray$_reject(reason) {
this._values = null;
var trace = canAttach(reason) ? reason : new Error(reason + "");
this._promise._attachExtraTrace(trace);
this._promise._reject(reason, trace);
};
PromiseArray.prototype._promiseProgressed =
function PromiseArray$_promiseProgressed(progressValue, index) {
if (this._isResolved()) return;
this._promise._progress({
index: index,
value: progressValue
});
};
PromiseArray.prototype._promiseFulfilled =
function PromiseArray$_promiseFulfilled(value, index) {
if (this._isResolved()) return;
this._values[index] = value;
var totalResolved = ++this._totalResolved;
if (totalResolved >= this._length) {
this._resolve(this._values);
}
};
PromiseArray.prototype._promiseRejected =
function PromiseArray$_promiseRejected(reason, index) {
if (this._isResolved()) return;
this._totalResolved++;
this._reject(reason);
};
return PromiseArray;
};
/***/ },
/* 112 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function() {
var inherits = __webpack_require__(108).inherits;
var defineProperty = __webpack_require__(157).defineProperty;
var rignore = new RegExp(
"\\b(?:[a-zA-Z0-9.]+\\$_\\w+|" +
"tryCatch(?:1|2|Apply)|new \\w*PromiseArray|" +
"\\w*PromiseArray\\.\\w*PromiseArray|" +
"setTimeout|CatchFilter\\$_\\w+|makeNodePromisified|processImmediate|" +
"process._tickCallback|nextTick|Async\\$\\w+)\\b"
);
var rtraceline = null;
var formatStack = null;
function formatNonError(obj) {
var str;
if (typeof obj === "function") {
str = "[function " +
(obj.name || "anonymous") +
"]";
}
else {
str = obj.toString();
var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
if (ruselessToString.test(str)) {
try {
var newStr = JSON.stringify(obj);
str = newStr;
}
catch(e) {
}
}
if (str.length === 0) {
str = "(empty array)";
}
}
return ("(<" + snip(str) + ">, no stack trace)");
}
function snip(str) {
var maxChars = 41;
if (str.length < maxChars) {
return str;
}
return str.substr(0, maxChars - 3) + "...";
}
function CapturedTrace(ignoreUntil, isTopLevel) {
this.captureStackTrace(CapturedTrace, isTopLevel);
}
inherits(CapturedTrace, Error);
CapturedTrace.prototype.captureStackTrace =
function CapturedTrace$captureStackTrace(ignoreUntil, isTopLevel) {
captureStackTrace(this, ignoreUntil, isTopLevel);
};
CapturedTrace.possiblyUnhandledRejection =
function CapturedTrace$PossiblyUnhandledRejection(reason) {
if (typeof console === "object") {
var message;
if (typeof reason === "object" || typeof reason === "function") {
var stack = reason.stack;
message = "Possibly unhandled " + formatStack(stack, reason);
}
else {
message = "Possibly unhandled " + String(reason);
}
if (typeof console.error === "function" ||
typeof console.error === "object") {
console.error(message);
}
else if (typeof console.log === "function" ||
typeof console.log === "object") {
console.log(message);
}
}
};
CapturedTrace.combine = function CapturedTrace$Combine(current, prev) {
var curLast = current.length - 1;
for (var i = prev.length - 1; i >= 0; --i) {
var line = prev[i];
if (current[curLast] === line) {
current.pop();
curLast--;
}
else {
break;
}
}
current.push("From previous event:");
var lines = current.concat(prev);
var ret = [];
for (var i = 0, len = lines.length; i < len; ++i) {
if ((rignore.test(lines[i]) ||
(i > 0 && !rtraceline.test(lines[i])) &&
lines[i] !== "From previous event:")
) {
continue;
}
ret.push(lines[i]);
}
return ret;
};
CapturedTrace.isSupported = function CapturedTrace$IsSupported() {
return typeof captureStackTrace === "function";
};
var captureStackTrace = (function stackDetection() {
if (typeof Error.stackTraceLimit === "number" &&
typeof Error.captureStackTrace === "function") {
rtraceline = /^\s*at\s*/;
formatStack = function(stack, error) {
if (typeof stack === "string") return stack;
if (error.name !== void 0 &&
error.message !== void 0) {
return error.name + ". " + error.message;
}
return formatNonError(error);
};
var captureStackTrace = Error.captureStackTrace;
return function CapturedTrace$_captureStackTrace(
receiver, ignoreUntil) {
captureStackTrace(receiver, ignoreUntil);
};
}
var err = new Error();
if (typeof err.stack === "string" &&
typeof "".startsWith === "function" &&
(err.stack.startsWith("stackDetection@")) &&
stackDetection.name === "stackDetection") {
defineProperty(Error, "stackTraceLimit", {
writable: true,
enumerable: false,
configurable: false,
value: 25
});
rtraceline = /@/;
var rline = /[@\n]/;
formatStack = function(stack, error) {
if (typeof stack === "string") {
return (error.name + ". " + error.message + "\n" + stack);
}
if (error.name !== void 0 &&
error.message !== void 0) {
return error.name + ". " + error.message;
}
return formatNonError(error);
};
return function captureStackTrace(o) {
var stack = new Error().stack;
var split = stack.split(rline);
var len = split.length;
var ret = "";
for (var i = 0; i < len; i += 2) {
ret += split[i];
ret += "@";
ret += split[i + 1];
ret += "\n";
}
o.stack = ret;
};
}
else {
formatStack = function(stack, error) {
if (typeof stack === "string") return stack;
if ((typeof error === "object" ||
typeof error === "function") &&
error.name !== void 0 &&
error.message !== void 0) {
return error.name + ". " + error.message;
}
return formatNonError(error);
};
return null;
}
})();
return CapturedTrace;
};
/***/ },
/* 113 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(NEXT_FILTER) {
var util = __webpack_require__(108);
var errors = __webpack_require__(110);
var tryCatch1 = util.tryCatch1;
var errorObj = util.errorObj;
var keys = __webpack_require__(157).keys;
var TypeError = errors.TypeError;
function CatchFilter(instances, callback, promise) {
this._instances = instances;
this._callback = callback;
this._promise = promise;
}
function CatchFilter$_safePredicate(predicate, e) {
var safeObject = {};
var retfilter = tryCatch1(predicate, safeObject, e);
if (retfilter === errorObj) return retfilter;
var safeKeys = keys(safeObject);
if (safeKeys.length) {
errorObj.e = new TypeError(
"Catch filter must inherit from Error "
+ "or be a simple predicate function");
return errorObj;
}
return retfilter;
}
CatchFilter.prototype.doFilter = function CatchFilter$_doFilter(e) {
var cb = this._callback;
var promise = this._promise;
var boundTo = promise._isBound() ? promise._boundTo : void 0;
for (var i = 0, len = this._instances.length; i < len; ++i) {
var item = this._instances[i];
var itemIsErrorType = item === Error ||
(item != null && item.prototype instanceof Error);
if (itemIsErrorType && e instanceof item) {
var ret = tryCatch1(cb, boundTo, e);
if (ret === errorObj) {
NEXT_FILTER.e = ret.e;
return NEXT_FILTER;
}
return ret;
} else if (typeof item === "function" && !itemIsErrorType) {
var shouldHandle = CatchFilter$_safePredicate(item, e);
if (shouldHandle === errorObj) {
var trace = errors.canAttach(errorObj.e)
? errorObj.e
: new Error(errorObj.e + "");
this._promise._attachExtraTrace(trace);
e = errorObj.e;
break;
} else if (shouldHandle) {
var ret = tryCatch1(cb, boundTo, e);
if (ret === errorObj) {
NEXT_FILTER.e = ret.e;
return NEXT_FILTER;
}
return ret;
}
}
}
NEXT_FILTER.e = e;
return NEXT_FILTER;
};
return CatchFilter;
};
/***/ },
/* 114 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
var util = __webpack_require__(108);
var maybeWrapAsError = util.maybeWrapAsError;
var errors = __webpack_require__(110);
var TimeoutError = errors.TimeoutError;
var RejectionError = errors.RejectionError;
var async = __webpack_require__(109);
var haveGetters = util.haveGetters;
var es5 = __webpack_require__(157);
function isUntypedError(obj) {
return obj instanceof Error &&
es5.getPrototypeOf(obj) === Error.prototype;
}
function wrapAsRejectionError(obj) {
var ret;
if (isUntypedError(obj)) {
ret = new RejectionError(obj);
}
else {
ret = obj;
}
errors.markAsOriginatingFromRejection(ret);
return ret;
}
function nodebackForPromise(promise) {
function PromiseResolver$_callback(err, value) {
if (promise === null) return;
if (err) {
var wrapped = wrapAsRejectionError(maybeWrapAsError(err));
promise._attachExtraTrace(wrapped);
promise._reject(wrapped);
}
else {
if (arguments.length > 2) {
var $_len = arguments.length;var args = new Array($_len - 1); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];}
promise._fulfill(args);
}
else {
promise._fulfill(value);
}
}
promise = null;
}
return PromiseResolver$_callback;
}
var PromiseResolver;
if (!haveGetters) {
PromiseResolver = function PromiseResolver(promise) {
this.promise = promise;
this.asCallback = nodebackForPromise(promise);
this.callback = this.asCallback;
};
}
else {
PromiseResolver = function PromiseResolver(promise) {
this.promise = promise;
};
}
if (haveGetters) {
var prop = {
get: function() {
return nodebackForPromise(this.promise);
}
};
es5.defineProperty(PromiseResolver.prototype, "asCallback", prop);
es5.defineProperty(PromiseResolver.prototype, "callback", prop);
}
PromiseResolver._nodebackForPromise = nodebackForPromise;
PromiseResolver.prototype.toString = function PromiseResolver$toString() {
return "[object PromiseResolver]";
};
PromiseResolver.prototype.resolve =
PromiseResolver.prototype.fulfill = function PromiseResolver$resolve(value) {
var promise = this.promise;
if ((promise === void 0) || (promise._tryFollow === void 0)) {
throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.");
}
if (promise._tryFollow(value)) {
return;
}
async.invoke(promise._fulfill, promise, value);
};
PromiseResolver.prototype.reject = function PromiseResolver$reject(reason) {
var promise = this.promise;
if ((promise === void 0) || (promise._attachExtraTrace === void 0)) {
throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.");
}
errors.markAsOriginatingFromRejection(reason);
var trace = errors.canAttach(reason) ? reason : new Error(reason + "");
promise._attachExtraTrace(trace);
async.invoke(promise._reject, promise, reason);
if (trace !== reason) {
async.invoke(this._setCarriedStackTrace, this, trace);
}
};
PromiseResolver.prototype.progress =
function PromiseResolver$progress(value) {
async.invoke(this.promise._progress, this.promise, value);
};
PromiseResolver.prototype.cancel = function PromiseResolver$cancel() {
async.invoke(this.promise.cancel, this.promise, void 0);
};
PromiseResolver.prototype.timeout = function PromiseResolver$timeout() {
this.reject(new TimeoutError("timeout"));
};
PromiseResolver.prototype.isResolved = function PromiseResolver$isResolved() {
return this.promise.isResolved();
};
PromiseResolver.prototype.toJSON = function PromiseResolver$toJSON() {
return this.promise.toJSON();
};
PromiseResolver.prototype._setCarriedStackTrace =
function PromiseResolver$_setCarriedStackTrace(trace) {
if (this.promise.isRejected()) {
this.promise._setCarriedStackTrace(trace);
}
};
module.exports = PromiseResolver;
/***/ },
/* 115 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise) {
var TypeError = __webpack_require__(110).TypeError;
function apiRejection(msg) {
var error = new TypeError(msg);
var ret = Promise.rejected(error);
var parent = ret._peekContext();
if (parent != null) {
parent._attachExtraTrace(error);
}
return ret;
}
return apiRejection;
};
/***/ },
/* 116 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise, NEXT_FILTER) {
var util = __webpack_require__(108);
var wrapsPrimitiveReceiver = util.wrapsPrimitiveReceiver;
var isPrimitive = util.isPrimitive;
var thrower = util.thrower;
function returnThis() {
return this;
}
function throwThis() {
throw this;
}
function return$(r) {
return function Promise$_returner() {
return r;
};
}
function throw$(r) {
return function Promise$_thrower() {
throw r;
};
}
function promisedFinally(ret, reasonOrValue, isFulfilled) {
var then;
if (wrapsPrimitiveReceiver && isPrimitive(reasonOrValue)) {
then = isFulfilled ? return$(reasonOrValue) : throw$(reasonOrValue);
}
else {
then = isFulfilled ? returnThis : throwThis;
}
return ret._then(then, thrower, void 0, reasonOrValue, void 0);
}
function finallyHandler(reasonOrValue) {
var promise = this.promise;
var handler = this.handler;
var ret = promise._isBound()
? handler.call(promise._boundTo)
: handler();
if (ret !== void 0) {
var maybePromise = Promise._cast(ret, void 0);
if (maybePromise instanceof Promise) {
return promisedFinally(maybePromise, reasonOrValue,
promise.isFulfilled());
}
}
if (promise.isRejected()) {
NEXT_FILTER.e = reasonOrValue;
return NEXT_FILTER;
}
else {
return reasonOrValue;
}
}
function tapHandler(value) {
var promise = this.promise;
var handler = this.handler;
var ret = promise._isBound()
? handler.call(promise._boundTo, value)
: handler(value);
if (ret !== void 0) {
var maybePromise = Promise._cast(ret, void 0);
if (maybePromise instanceof Promise) {
return promisedFinally(maybePromise, value, true);
}
}
return value;
}
Promise.prototype._passThroughHandler =
function Promise$_passThroughHandler(handler, isFinally) {
if (typeof handler !== "function") return this.then();
var promiseAndHandler = {
promise: this,
handler: handler
};
return this._then(
isFinally ? finallyHandler : tapHandler,
isFinally ? finallyHandler : void 0, void 0,
promiseAndHandler, void 0);
};
Promise.prototype.lastly =
Promise.prototype["finally"] = function Promise$finally(handler) {
return this._passThroughHandler(handler, true);
};
Promise.prototype.tap = function Promise$tap(handler) {
return this._passThroughHandler(handler, false);
};
};
/***/ },
/* 117 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
var util = __webpack_require__(108);
var isPrimitive = util.isPrimitive;
var wrapsPrimitiveReceiver = util.wrapsPrimitiveReceiver;
module.exports = function(Promise) {
var returner = function Promise$_returner() {
return this;
};
var thrower = function Promise$_thrower() {
throw this;
};
var wrapper = function Promise$_wrapper(value, action) {
if (action === 1) {
return function Promise$_thrower() {
throw value;
};
}
else if (action === 2) {
return function Promise$_returner() {
return value;
};
}
};
Promise.prototype["return"] =
Promise.prototype.thenReturn =
function Promise$thenReturn(value) {
if (wrapsPrimitiveReceiver && isPrimitive(value)) {
return this._then(
wrapper(value, 2),
void 0,
void 0,
void 0,
void 0
);
}
return this._then(returner, void 0, void 0, value, void 0);
};
Promise.prototype["throw"] =
Promise.prototype.thenThrow =
function Promise$thenThrow(reason) {
if (wrapsPrimitiveReceiver && isPrimitive(reason)) {
return this._then(
wrapper(reason, 1),
void 0,
void 0,
void 0,
void 0
);
}
return this._then(thrower, void 0, void 0, reason, void 0);
};
};
/***/ },
/* 118 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise, INTERNAL) {
var util = __webpack_require__(108);
var canAttach = __webpack_require__(110).canAttach;
var errorObj = util.errorObj;
var isObject = util.isObject;
function getThen(obj) {
try {
return obj.then;
}
catch(e) {
errorObj.e = e;
return errorObj;
}
}
function Promise$_Cast(obj, originalPromise) {
if (isObject(obj)) {
if (obj instanceof Promise) {
return obj;
}
else if (isAnyBluebirdPromise(obj)) {
var ret = new Promise(INTERNAL);
ret._setTrace(void 0);
obj._then(
ret._fulfillUnchecked,
ret._rejectUncheckedCheckError,
ret._progressUnchecked,
ret,
null
);
ret._setFollowing();
return ret;
}
var then = getThen(obj);
if (then === errorObj) {
if (originalPromise !== void 0 && canAttach(then.e)) {
originalPromise._attachExtraTrace(then.e);
}
return Promise.reject(then.e);
}
else if (typeof then === "function") {
return Promise$_doThenable(obj, then, originalPromise);
}
}
return obj;
}
var hasProp = {}.hasOwnProperty;
function isAnyBluebirdPromise(obj) {
return hasProp.call(obj, "_promise0");
}
function Promise$_doThenable(x, then, originalPromise) {
var resolver = Promise.defer();
var called = false;
try {
then.call(
x,
Promise$_resolveFromThenable,
Promise$_rejectFromThenable,
Promise$_progressFromThenable
);
}
catch(e) {
if (!called) {
called = true;
var trace = canAttach(e) ? e : new Error(e + "");
if (originalPromise !== void 0) {
originalPromise._attachExtraTrace(trace);
}
resolver.promise._reject(e, trace);
}
}
return resolver.promise;
function Promise$_resolveFromThenable(y) {
if (called) return;
called = true;
if (x === y) {
var e = Promise._makeSelfResolutionError();
if (originalPromise !== void 0) {
originalPromise._attachExtraTrace(e);
}
resolver.promise._reject(e, void 0);
return;
}
resolver.resolve(y);
}
function Promise$_rejectFromThenable(r) {
if (called) return;
called = true;
var trace = canAttach(r) ? r : new Error(r + "");
if (originalPromise !== void 0) {
originalPromise._attachExtraTrace(trace);
}
resolver.promise._reject(r, trace);
}
function Promise$_progressFromThenable(v) {
if (called) return;
var promise = resolver.promise;
if (typeof promise._progress === "function") {
promise._progress(v);
}
}
}
Promise._cast = Promise$_Cast;
};
/***/ },
/* 119 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise) {
function PromiseInspection(promise) {
if (promise !== void 0) {
this._bitField = promise._bitField;
this._settledValue = promise.isResolved()
? promise._settledValue
: void 0;
}
else {
this._bitField = 0;
this._settledValue = void 0;
}
}
PromiseInspection.prototype.isFulfilled =
Promise.prototype.isFulfilled = function Promise$isFulfilled() {
return (this._bitField & 268435456) > 0;
};
PromiseInspection.prototype.isRejected =
Promise.prototype.isRejected = function Promise$isRejected() {
return (this._bitField & 134217728) > 0;
};
PromiseInspection.prototype.isPending =
Promise.prototype.isPending = function Promise$isPending() {
return (this._bitField & 402653184) === 0;
};
PromiseInspection.prototype.value =
Promise.prototype.value = function Promise$value() {
if (!this.isFulfilled()) {
throw new TypeError("cannot get fulfillment value of a non-fulfilled promise");
}
return this._settledValue;
};
PromiseInspection.prototype.error =
Promise.prototype.reason = function Promise$reason() {
if (!this.isRejected()) {
throw new TypeError("cannot get rejection reason of a non-rejected promise");
}
return this._settledValue;
};
PromiseInspection.prototype.isResolved =
Promise.prototype.isResolved = function Promise$isResolved() {
return (this._bitField & 402653184) > 0;
};
Promise.prototype.inspect = function Promise$inspect() {
return new PromiseInspection(this);
};
Promise.PromiseInspection = PromiseInspection;
};
/***/ },
/* 120 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
var global = __webpack_require__(107);
var setTimeout = function(fn, ms) {
var $_len = arguments.length;var args = new Array($_len - 2); for(var $_i = 2; $_i < $_len; ++$_i) {args[$_i - 2] = arguments[$_i];}
global.setTimeout(function(){
fn.apply(void 0, args);
}, ms);
};
module.exports = function(Promise, INTERNAL) {
var util = __webpack_require__(108);
var errors = __webpack_require__(110);
var apiRejection = __webpack_require__(115)(Promise);
var TimeoutError = Promise.TimeoutError;
var afterTimeout = function Promise$_afterTimeout(promise, message, ms) {
if (!promise.isPending()) return;
if (typeof message !== "string") {
message = "operation timed out after" + " " + ms + " ms"
}
var err = new TimeoutError(message);
errors.markAsOriginatingFromRejection(err);
promise._attachExtraTrace(err);
promise._rejectUnchecked(err);
};
var afterDelay = function Promise$_afterDelay(value, promise) {
promise._fulfill(value);
};
var delay = Promise.delay = function Promise$Delay(value, ms) {
if (ms === void 0) {
ms = value;
value = void 0;
}
ms = +ms;
var maybePromise = Promise._cast(value, void 0);
var promise = new Promise(INTERNAL);
if (maybePromise instanceof Promise) {
if (maybePromise._isBound()) {
promise._setBoundTo(maybePromise._boundTo);
}
if (maybePromise._cancellable()) {
promise._setCancellable();
promise._cancellationParent = maybePromise;
}
promise._setTrace(maybePromise);
promise._follow(maybePromise);
return promise.then(function(value) {
return Promise.delay(value, ms);
});
}
else {
promise._setTrace(void 0);
setTimeout(afterDelay, ms, value, promise);
}
return promise;
};
Promise.prototype.delay = function Promise$delay(ms) {
return delay(this, ms);
};
Promise.prototype.timeout = function Promise$timeout(ms, message) {
ms = +ms;
var ret = new Promise(INTERNAL);
ret._setTrace(this);
if (this._isBound()) ret._setBoundTo(this._boundTo);
if (this._cancellable()) {
ret._setCancellable();
ret._cancellationParent = this;
}
ret._follow(this);
setTimeout(afterTimeout, ms, ret, message, ms);
return ret;
};
};
/***/ },
/* 121 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise, Promise$_CreatePromiseArray, PromiseArray) {
var SomePromiseArray = __webpack_require__(160)(PromiseArray);
function Promise$_Any(promises, useBound) {
var ret = Promise$_CreatePromiseArray(
promises,
SomePromiseArray,
useBound === true && promises._isBound()
? promises._boundTo
: void 0
);
var promise = ret.promise();
if (promise.isRejected()) {
return promise;
}
ret.setHowMany(1);
ret.setUnwrap();
ret.init();
return promise;
}
Promise.any = function Promise$Any(promises) {
return Promise$_Any(promises, false);
};
Promise.prototype.any = function Promise$any() {
return Promise$_Any(this, true);
};
};
/***/ },
/* 122 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise, INTERNAL) {
var apiRejection = __webpack_require__(115)(Promise);
var isArray = __webpack_require__(108).isArray;
var raceLater = function Promise$_raceLater(promise) {
return promise.then(function(array) {
return Promise$_Race(array, promise);
});
};
var hasOwn = {}.hasOwnProperty;
function Promise$_Race(promises, parent) {
var maybePromise = Promise._cast(promises, void 0);
if (maybePromise instanceof Promise) {
return raceLater(maybePromise);
}
else if (!isArray(promises)) {
return apiRejection("expecting an array, a promise or a thenable");
}
var ret = new Promise(INTERNAL);
ret._setTrace(parent);
if (parent !== void 0) {
if (parent._isBound()) {
ret._setBoundTo(parent._boundTo);
}
if (parent._cancellable()) {
ret._setCancellable();
ret._cancellationParent = parent;
}
}
var fulfill = ret._fulfill;
var reject = ret._reject;
for (var i = 0, len = promises.length; i < len; ++i) {
var val = promises[i];
if (val === void 0 && !(hasOwn.call(promises, i))) {
continue;
}
Promise.cast(val)._then(
fulfill,
reject,
void 0,
ret,
null
);
}
return ret;
}
Promise.race = function Promise$Race(promises) {
return Promise$_Race(promises, void 0);
};
Promise.prototype.race = function Promise$race() {
return Promise$_Race(this, void 0);
};
};
/***/ },
/* 123 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise) {
Promise.prototype.call = function Promise$call(propertyName) {
var $_len = arguments.length;var args = new Array($_len - 1); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];}
return this._then(function(obj) {
return obj[propertyName].apply(obj, args);
},
void 0,
void 0,
void 0,
void 0
);
};
function Promise$getter(obj) {
var prop = typeof this === "string"
? this
: ("" + this);
return obj[prop];
}
Promise.prototype.get = function Promise$get(propertyName) {
return this._then(
Promise$getter,
void 0,
void 0,
propertyName,
void 0
);
};
};
/***/ },
/* 124 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise) {
var isArray = __webpack_require__(108).isArray;
function Promise$_filter(booleans) {
var values = this instanceof Promise ? this._settledValue : this;
var len = values.length;
var ret = new Array(len);
var j = 0;
for (var i = 0; i < len; ++i) {
if (booleans[i]) ret[j++] = values[i];
}
ret.length = j;
return ret;
}
var ref = {ref: null};
Promise.filter = function Promise$Filter(promises, fn) {
return Promise.map(promises, fn, ref)
._then(Promise$_filter, void 0, void 0, ref.ref, void 0);
};
Promise.prototype.filter = function Promise$filter(fn) {
return this.map(fn, ref)
._then(Promise$_filter, void 0, void 0, ref.ref, void 0);
};
};
/***/ },
/* 125 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise, apiRejection, INTERNAL) {
var PromiseSpawn = __webpack_require__(161)(Promise, INTERNAL);
var errors = __webpack_require__(110);
var TypeError = errors.TypeError;
var deprecated = __webpack_require__(108).deprecated;
Promise.coroutine = function Promise$Coroutine(generatorFunction) {
if (typeof generatorFunction !== "function") {
throw new TypeError("generatorFunction must be a function");
}
var PromiseSpawn$ = PromiseSpawn;
return function () {
var generator = generatorFunction.apply(this, arguments);
var spawn = new PromiseSpawn$(void 0, void 0);
spawn._generator = generator;
spawn._next(void 0);
return spawn.promise();
};
};
Promise.coroutine.addYieldHandler = PromiseSpawn.addYieldHandler;
Promise.spawn = function Promise$Spawn(generatorFunction) {
deprecated("Promise.spawn is deprecated. Use Promise.coroutine instead.");
if (typeof generatorFunction !== "function") {
return apiRejection("generatorFunction must be a function");
}
var spawn = new PromiseSpawn(generatorFunction, this);
var ret = spawn.promise();
spawn._run(Promise.spawn);
return ret;
};
};
/***/ },
/* 126 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise, PromiseArray, INTERNAL, apiRejection) {
var all = Promise.all;
var util = __webpack_require__(108);
var canAttach = __webpack_require__(110).canAttach;
var isArray = util.isArray;
var _cast = Promise._cast;
function unpack(values) {
return Promise$_Map(values, this[0], this[1], this[2]);
}
function Promise$_Map(promises, fn, useBound, ref) {
if (typeof fn !== "function") {
return apiRejection("fn must be a function");
}
var receiver = void 0;
if (useBound === true) {
if (promises._isBound()) {
receiver = promises._boundTo;
}
}
else if (useBound !== false) {
receiver = useBound;
}
var shouldUnwrapItems = ref !== void 0;
if (shouldUnwrapItems) ref.ref = promises;
if (promises instanceof Promise) {
var pack = [fn, receiver, ref];
return promises._then(unpack, void 0, void 0, pack, void 0);
}
else if (!isArray(promises)) {
return apiRejection("expecting an array, a promise or a thenable");
}
var promise = new Promise(INTERNAL);
if (receiver !== void 0) promise._setBoundTo(receiver);
promise._setTrace(void 0);
var mapping = new Mapping(promise,
fn,
promises,
receiver,
shouldUnwrapItems);
mapping.init();
return promise;
}
var pending = {};
function Mapping(promise, callback, items, receiver, shouldUnwrapItems) {
this.shouldUnwrapItems = shouldUnwrapItems;
this.index = 0;
this.items = items;
this.callback = callback;
this.receiver = receiver;
this.promise = promise;
this.result = new Array(items.length);
}
util.inherits(Mapping, PromiseArray);
Mapping.prototype.init = function Mapping$init() {
var items = this.items;
var len = items.length;
var result = this.result;
var isRejected = false;
for (var i = 0; i < len; ++i) {
var maybePromise = _cast(items[i], void 0);
if (maybePromise instanceof Promise) {
if (maybePromise.isPending()) {
result[i] = pending;
maybePromise._proxyPromiseArray(this, i);
}
else if (maybePromise.isFulfilled()) {
result[i] = maybePromise.value();
}
else {
maybePromise._unsetRejectionIsUnhandled();
if (!isRejected) {
this.reject(maybePromise.reason());
isRejected = true;
}
}
}
else {
result[i] = maybePromise;
}
}
if (!isRejected) this.iterate();
};
Mapping.prototype.isResolved = function Mapping$isResolved() {
return this.promise === null;
};
Mapping.prototype._promiseProgressed =
function Mapping$_promiseProgressed(value) {
if (this.isResolved()) return;
this.promise._progress(value);
};
Mapping.prototype._promiseFulfilled =
function Mapping$_promiseFulfilled(value, index) {
if (this.isResolved()) return;
this.result[index] = value;
if (this.shouldUnwrapItems) this.items[index] = value;
if (this.index === index) this.iterate();
};
Mapping.prototype._promiseRejected =
function Mapping$_promiseRejected(reason) {
this.reject(reason);
};
Mapping.prototype.reject = function Mapping$reject(reason) {
if (this.isResolved()) return;
var trace = canAttach(reason) ? reason : new Error(reason + "");
this.promise._attachExtraTrace(trace);
this.promise._reject(reason, trace);
};
Mapping.prototype.iterate = function Mapping$iterate() {
var i = this.index;
var items = this.items;
var result = this.result;
var len = items.length;
var result = this.result;
var receiver = this.receiver;
var callback = this.callback;
for (; i < len; ++i) {
var value = result[i];
if (value === pending) {
this.index = i;
return;
}
try { result[i] = callback.call(receiver, value, i, len); }
catch (e) { return this.reject(e); }
}
this.promise._follow(all(result));
this.items = this.result = this.callback = this.promise = null;
};
Promise.prototype.map = function Promise$map(fn, ref) {
return Promise$_Map(this, fn, true, ref);
};
Promise.map = function Promise$Map(promises, fn, ref) {
return Promise$_Map(promises, fn, false, ref);
};
};
/***/ },
/* 127 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise) {
var util = __webpack_require__(108);
var async = __webpack_require__(109);
var tryCatch2 = util.tryCatch2;
var tryCatch1 = util.tryCatch1;
var errorObj = util.errorObj;
function thrower(r) {
throw r;
}
function Promise$_successAdapter(val, receiver) {
var nodeback = this;
var ret = val === void 0
? tryCatch1(nodeback, receiver, null)
: tryCatch2(nodeback, receiver, null, val);
if (ret === errorObj) {
async.invokeLater(thrower, void 0, ret.e);
}
}
function Promise$_errorAdapter(reason, receiver) {
var nodeback = this;
var ret = tryCatch1(nodeback, receiver, reason);
if (ret === errorObj) {
async.invokeLater(thrower, void 0, ret.e);
}
}
Promise.prototype.nodeify = function Promise$nodeify(nodeback) {
if (typeof nodeback == "function") {
this._then(
Promise$_successAdapter,
Promise$_errorAdapter,
void 0,
nodeback,
this._isBound() ? this._boundTo : null
);
}
return this;
};
};
/***/ },
/* 128 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise, INTERNAL) {
var THIS = {};
var util = __webpack_require__(108);
var es5 = __webpack_require__(157);
var nodebackForPromise = __webpack_require__(114)
._nodebackForPromise;
var withAppended = util.withAppended;
var maybeWrapAsError = util.maybeWrapAsError;
var canEvaluate = util.canEvaluate;
var deprecated = util.deprecated;
var TypeError = __webpack_require__(110).TypeError;
var rasyncSuffix = new RegExp("Async" + "$");
function isPromisified(fn) {
return fn.__isPromisified__ === true;
}
function hasPromisified(obj, key) {
var containsKey = ((key + "Async") in obj);
return containsKey ? isPromisified(obj[key + "Async"])
: false;
}
function checkValid(ret) {
for (var i = 0; i < ret.length; i += 2) {
var key = ret[i];
if (rasyncSuffix.test(key)) {
var keyWithoutAsyncSuffix = key.replace(rasyncSuffix, "");
for (var j = 0; j < ret.length; j += 2) {
if (ret[j] === keyWithoutAsyncSuffix) {
throw new TypeError("Cannot promisify an API " +
"that has normal methods with Async-suffix");
}
}
}
}
}
var inheritedMethods = (function() {
if (es5.isES5) {
var create = Object.create;
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
return function(cur) {
var ret = [];
var visitedKeys = create(null);
var original = cur;
while (cur !== null) {
var keys = es5.keys(cur);
for (var i = 0, len = keys.length; i < len; ++i) {
var key = keys[i];
if (visitedKeys[key]) continue;
visitedKeys[key] = true;
var desc = getOwnPropertyDescriptor(cur, key);
if (desc != null &&
typeof desc.value === "function" &&
!isPromisified(desc.value) &&
!hasPromisified(original, key)) {
ret.push(key, desc.value);
}
}
cur = es5.getPrototypeOf(cur);
}
checkValid(ret);
return ret;
};
}
else {
return function(obj) {
var ret = [];
/*jshint forin:false */
for (var key in obj) {
var fn = obj[key];
if (typeof fn === "function" &&
!isPromisified(fn) &&
!hasPromisified(obj, key)) {
ret.push(key, fn);
}
}
checkValid(ret);
return ret;
};
}
})();
function switchCaseArgumentOrder(likelyArgumentCount) {
var ret = [likelyArgumentCount];
var min = Math.max(0, likelyArgumentCount - 1 - 5);
for(var i = likelyArgumentCount - 1; i >= min; --i) {
if (i === likelyArgumentCount) continue;
ret.push(i);
}
for(var i = likelyArgumentCount + 1; i <= 5; ++i) {
ret.push(i);
}
return ret;
}
function parameterDeclaration(parameterCount) {
var ret = new Array(parameterCount);
for(var i = 0; i < ret.length; ++i) {
ret[i] = "_arg" + i;
}
return ret.join(", ");
}
function parameterCount(fn) {
if (typeof fn.length === "number") {
return Math.max(Math.min(fn.length, 1023 + 1), 0);
}
return 0;
}
var rident = /^[a-z$_][a-z$_0-9]*$/i;
function propertyAccess(id) {
if (rident.test(id)) {
return "." + id;
}
else return "['" + id.replace(/(['\\])/g, "\\$1") + "']";
}
function makeNodePromisifiedEval(callback, receiver, originalName, fn) {
var newParameterCount = Math.max(0, parameterCount(fn) - 1);
var argumentOrder = switchCaseArgumentOrder(newParameterCount);
var callbackName = (typeof originalName === "string" ?
originalName + "Async" :
"promisified");
function generateCallForArgumentCount(count) {
var args = new Array(count);
for (var i = 0, len = args.length; i < len; ++i) {
args[i] = "arguments[" + i + "]";
}
var comma = count > 0 ? "," : "";
if (typeof callback === "string" &&
receiver === THIS) {
return "this" + propertyAccess(callback) + "("+args.join(",") +
comma +" fn);"+
"break;";
}
return (receiver === void 0
? "callback("+args.join(",")+ comma +" fn);"
: "callback.call("+(receiver === THIS
? "this"
: "receiver")+", "+args.join(",") + comma + " fn);") +
"break;";
}
if (!rident.test(callbackName)) {
callbackName = "promisified";
}
function generateArgumentSwitchCase() {
var ret = "";
for(var i = 0; i < argumentOrder.length; ++i) {
ret += "case " + argumentOrder[i] +":" +
generateCallForArgumentCount(argumentOrder[i]);
}
ret += "default: var args = new Array(len + 1);" +
"var i = 0;" +
"for (var i = 0; i < len; ++i) { " +
" args[i] = arguments[i];" +
"}" +
"args[i] = fn;" +
(typeof callback === "string"
? "this" + propertyAccess(callback) + ".apply("
: "callback.apply(") +
(receiver === THIS ? "this" : "receiver") +
", args); break;";
return ret;
}
return new Function("Promise", "callback", "receiver",
"withAppended", "maybeWrapAsError", "nodebackForPromise",
"INTERNAL",
"var ret = function " + callbackName +
"(" + parameterDeclaration(newParameterCount) + ") {\"use strict\";" +
"var len = arguments.length;" +
"var promise = new Promise(INTERNAL);"+
"promise._setTrace(void 0);" +
"var fn = nodebackForPromise(promise);"+
"try {" +
"switch(len) {" +
generateArgumentSwitchCase() +
"}" +
"}" +
"catch(e){ " +
"var wrapped = maybeWrapAsError(e);" +
"promise._attachExtraTrace(wrapped);" +
"promise._reject(wrapped);" +
"}" +
"return promise;" +
"" +
"}; ret.__isPromisified__ = true; return ret;"
)(Promise, callback, receiver, withAppended,
maybeWrapAsError, nodebackForPromise, INTERNAL);
}
function makeNodePromisifiedClosure(callback, receiver) {
function promisified() {
var _receiver = receiver;
if (receiver === THIS) _receiver = this;
if (typeof callback === "string") {
callback = _receiver[callback];
}
var promise = new Promise(INTERNAL);
promise._setTrace(void 0);
var fn = nodebackForPromise(promise);
try {
callback.apply(_receiver, withAppended(arguments, fn));
}
catch(e) {
var wrapped = maybeWrapAsError(e);
promise._attachExtraTrace(wrapped);
promise._reject(wrapped);
}
return promise;
}
promisified.__isPromisified__ = true;
return promisified;
}
var makeNodePromisified = canEvaluate
? makeNodePromisifiedEval
: makeNodePromisifiedClosure;
function _promisify(callback, receiver, isAll) {
if (isAll) {
var methods = inheritedMethods(callback);
for (var i = 0, len = methods.length; i < len; i+= 2) {
var key = methods[i];
var fn = methods[i+1];
var promisifiedKey = key + "Async";
callback[promisifiedKey] = makeNodePromisified(key, THIS, key, fn);
}
util.toFastProperties(callback);
return callback;
}
else {
return makeNodePromisified(callback, receiver, void 0, callback);
}
}
Promise.promisify = function Promise$Promisify(fn, receiver) {
if (typeof fn === "object" && fn !== null) {
deprecated("Promise.promisify for promisifying entire objects is deprecated. Use Promise.promisifyAll instead.");
return _promisify(fn, receiver, true);
}
if (typeof fn !== "function") {
throw new TypeError("fn must be a function");
}
if (isPromisified(fn)) {
return fn;
}
return _promisify(
fn,
arguments.length < 2 ? THIS : receiver,
false);
};
Promise.promisifyAll = function Promise$PromisifyAll(target) {
if (typeof target !== "function" && typeof target !== "object") {
throw new TypeError("the target of promisifyAll must be an object or a function");
}
return _promisify(target, void 0, true);
};
};
/***/ },
/* 129 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise, PromiseArray) {
var PropertiesPromiseArray = __webpack_require__(162)(
Promise, PromiseArray);
var util = __webpack_require__(108);
var apiRejection = __webpack_require__(115)(Promise);
var isObject = util.isObject;
function Promise$_Props(promises, useBound) {
var ret;
var castValue = Promise._cast(promises, void 0);
if (!isObject(castValue)) {
return apiRejection("cannot await properties of a non-object");
}
else if (castValue instanceof Promise) {
ret = castValue._then(Promise.props, void 0, void 0,
void 0, void 0);
}
else {
ret = new PropertiesPromiseArray(
castValue,
useBound === true && castValue._isBound()
? castValue._boundTo
: void 0
).promise();
useBound = false;
}
if (useBound === true && castValue._isBound()) {
ret._setBoundTo(castValue._boundTo);
}
return ret;
}
Promise.prototype.props = function Promise$props() {
return Promise$_Props(this, true);
};
Promise.props = function Promise$Props(promises) {
return Promise$_Props(promises, false);
};
};
/***/ },
/* 130 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(
Promise, Promise$_CreatePromiseArray,
PromiseArray, apiRejection, INTERNAL) {
function Reduction(callback, index, accum, items, receiver) {
this.promise = new Promise(INTERNAL);
this.index = index;
this.length = items.length;
this.items = items;
this.callback = callback;
this.receiver = receiver;
this.accum = accum;
}
Reduction.prototype.reject = function Reduction$reject(e) {
this.promise._reject(e);
};
Reduction.prototype.fulfill = function Reduction$fulfill(value, index) {
this.accum = value;
this.index = index + 1;
this.iterate();
};
Reduction.prototype.iterate = function Reduction$iterate() {
var i = this.index;
var len = this.length;
var items = this.items;
var result = this.accum;
var receiver = this.receiver;
var callback = this.callback;
for (; i < len; ++i) {
result = callback.call(receiver, result, items[i], i, len);
result = Promise._cast(result, void 0);
if (result instanceof Promise) {
result._then(
this.fulfill, this.reject, void 0, this, i);
return;
}
}
this.promise._fulfill(result);
};
function Promise$_reducer(fulfilleds, initialValue) {
var fn = this;
var receiver = void 0;
if (typeof fn !== "function") {
receiver = fn.receiver;
fn = fn.fn;
}
var len = fulfilleds.length;
var accum = void 0;
var startIndex = 0;
if (initialValue !== void 0) {
accum = initialValue;
startIndex = 0;
}
else {
startIndex = 1;
if (len > 0) accum = fulfilleds[0];
}
var i = startIndex;
if (i >= len) {
return accum;
}
var reduction = new Reduction(fn, i, accum, fulfilleds, receiver);
reduction.iterate();
return reduction.promise;
}
function Promise$_unpackReducer(fulfilleds) {
var fn = this.fn;
var initialValue = this.initialValue;
return Promise$_reducer.call(fn, fulfilleds, initialValue);
}
function Promise$_slowReduce(
promises, fn, initialValue, useBound) {
return initialValue._then(function(initialValue) {
return Promise$_Reduce(
promises, fn, initialValue, useBound);
}, void 0, void 0, void 0, void 0);
}
function Promise$_Reduce(promises, fn, initialValue, useBound) {
if (typeof fn !== "function") {
return apiRejection("fn must be a function");
}
if (useBound === true && promises._isBound()) {
fn = {
fn: fn,
receiver: promises._boundTo
};
}
if (initialValue !== void 0) {
if (initialValue instanceof Promise) {
if (initialValue.isFulfilled()) {
initialValue = initialValue._settledValue;
}
else {
return Promise$_slowReduce(promises,
fn, initialValue, useBound);
}
}
return Promise$_CreatePromiseArray(promises, PromiseArray,
useBound === true && promises._isBound()
? promises._boundTo
: void 0)
.promise()
._then(Promise$_unpackReducer, void 0, void 0, {
fn: fn,
initialValue: initialValue
}, void 0);
}
return Promise$_CreatePromiseArray(promises, PromiseArray,
useBound === true && promises._isBound()
? promises._boundTo
: void 0).promise()
._then(Promise$_reducer, void 0, void 0, fn, void 0);
}
Promise.reduce = function Promise$Reduce(promises, fn, initialValue) {
return Promise$_Reduce(promises, fn, initialValue, false);
};
Promise.prototype.reduce = function Promise$reduce(fn, initialValue) {
return Promise$_Reduce(this, fn, initialValue, true);
};
};
/***/ },
/* 131 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports =
function(Promise, Promise$_CreatePromiseArray, PromiseArray) {
var SettledPromiseArray = __webpack_require__(163)(
Promise, PromiseArray);
function Promise$_Settle(promises, useBound) {
return Promise$_CreatePromiseArray(
promises,
SettledPromiseArray,
useBound === true && promises._isBound()
? promises._boundTo
: void 0
).promise();
}
Promise.settle = function Promise$Settle(promises) {
return Promise$_Settle(promises, false);
};
Promise.prototype.settle = function Promise$settle() {
return Promise$_Settle(this, true);
};
};
/***/ },
/* 132 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports =
function(Promise, Promise$_CreatePromiseArray, PromiseArray, apiRejection) {
var SomePromiseArray = __webpack_require__(160)(PromiseArray);
function Promise$_Some(promises, howMany, useBound) {
if ((howMany | 0) !== howMany || howMany < 0) {
return apiRejection("expecting a positive integer");
}
var ret = Promise$_CreatePromiseArray(
promises,
SomePromiseArray,
useBound === true && promises._isBound()
? promises._boundTo
: void 0
);
var promise = ret.promise();
if (promise.isRejected()) {
return promise;
}
ret.setHowMany(howMany);
ret.init();
return promise;
}
Promise.some = function Promise$Some(promises, howMany) {
return Promise$_Some(promises, howMany, false);
};
Promise.prototype.some = function Promise$some(count) {
return Promise$_Some(this, count, true);
};
};
/***/ },
/* 133 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise, isPromiseArrayProxy) {
var util = __webpack_require__(108);
var async = __webpack_require__(109);
var errors = __webpack_require__(110);
var tryCatch1 = util.tryCatch1;
var errorObj = util.errorObj;
Promise.prototype.progressed = function Promise$progressed(handler) {
return this._then(void 0, void 0, handler, void 0, void 0);
};
Promise.prototype._progress = function Promise$_progress(progressValue) {
if (this._isFollowingOrFulfilledOrRejected()) return;
this._progressUnchecked(progressValue);
};
Promise.prototype._progressHandlerAt =
function Promise$_progressHandlerAt(index) {
if (index === 0) return this._progressHandler0;
return this[index + 2 - 5];
};
Promise.prototype._doProgressWith =
function Promise$_doProgressWith(progression) {
var progressValue = progression.value;
var handler = progression.handler;
var promise = progression.promise;
var receiver = progression.receiver;
this._pushContext();
var ret = tryCatch1(handler, receiver, progressValue);
this._popContext();
if (ret === errorObj) {
if (ret.e != null &&
ret.e.name !== "StopProgressPropagation") {
var trace = errors.canAttach(ret.e)
? ret.e : new Error(ret.e + "");
promise._attachExtraTrace(trace);
promise._progress(ret.e);
}
}
else if (ret instanceof Promise) {
ret._then(promise._progress, null, null, promise, void 0);
}
else {
promise._progress(ret);
}
};
Promise.prototype._progressUnchecked =
function Promise$_progressUnchecked(progressValue) {
if (!this.isPending()) return;
var len = this._length();
var progress = this._progress;
for (var i = 0; i < len; i += 5) {
var handler = this._progressHandlerAt(i);
var promise = this._promiseAt(i);
if (!(promise instanceof Promise)) {
var receiver = this._receiverAt(i);
if (typeof handler === "function") {
handler.call(receiver, progressValue, promise);
}
else if (receiver instanceof Promise && receiver._isProxied()) {
receiver._progressUnchecked(progressValue);
}
else if (isPromiseArrayProxy(receiver, promise)) {
receiver._promiseProgressed(progressValue, promise);
}
continue;
}
if (typeof handler === "function") {
async.invoke(this._doProgressWith, this, {
handler: handler,
promise: promise,
receiver: this._receiverAt(i),
value: progressValue
});
}
else {
async.invoke(progress, promise, progressValue);
}
}
};
};
/***/ },
/* 134 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise, INTERNAL) {
var errors = __webpack_require__(110);
var async = __webpack_require__(109);
var CancellationError = errors.CancellationError;
Promise.prototype._cancel = function Promise$_cancel() {
if (!this.isCancellable()) return this;
var parent;
var promiseToReject = this;
while ((parent = promiseToReject._cancellationParent) !== void 0 &&
parent.isCancellable()) {
promiseToReject = parent;
}
var err = new CancellationError();
promiseToReject._attachExtraTrace(err);
promiseToReject._rejectUnchecked(err);
};
Promise.prototype.cancel = function Promise$cancel() {
if (!this.isCancellable()) return this;
async.invokeLater(this._cancel, this, void 0);
return this;
};
Promise.prototype.cancellable = function Promise$cancellable() {
if (this._cancellable()) return this;
this._setCancellable();
this._cancellationParent = void 0;
return this;
};
Promise.prototype.uncancellable = function Promise$uncancellable() {
var ret = new Promise(INTERNAL);
ret._setTrace(this);
ret._follow(this);
ret._unsetCancellable();
if (this._isBound()) ret._setBoundTo(this._boundTo);
return ret;
};
Promise.prototype.fork =
function Promise$fork(didFulfill, didReject, didProgress) {
var ret = this._then(didFulfill, didReject, didProgress,
void 0, void 0);
ret._setCancellable();
ret._cancellationParent = void 0;
return ret;
};
};
/***/ },
/* 135 */
/***/ function(module, exports, __webpack_require__) {
module.exports = function (Buffer) {
//prototype class for hash functions
function Hash (blockSize, finalSize) {
this._block = new Buffer(blockSize) //new Uint32Array(blockSize/4)
this._finalSize = finalSize
this._blockSize = blockSize
this._len = 0
this._s = 0
}
Hash.prototype.init = function () {
this._s = 0
this._len = 0
}
Hash.prototype.update = function (data, enc) {
if ("string" === typeof data) {
enc = enc || "utf8"
data = new Buffer(data, enc)
}
var l = this._len += data.length
var s = this._s = (this._s || 0)
var f = 0
var buffer = this._block
while (s < l) {
var t = Math.min(data.length, f + this._blockSize - (s % this._blockSize))
var ch = (t - f)
for (var i = 0; i < ch; i++) {
buffer[(s % this._blockSize) + i] = data[i + f]
}
s += ch
f += ch
if ((s % this._blockSize) === 0) {
this._update(buffer)
}
}
this._s = s
return this
}
Hash.prototype.digest = function (enc) {
// Suppose the length of the message M, in bits, is l
var l = this._len * 8
// Append the bit 1 to the end of the message
this._block[this._len % this._blockSize] = 0x80
// and then k zero bits, where k is the smallest non-negative solution to the equation (l + 1 + k) === finalSize mod blockSize
this._block.fill(0, this._len % this._blockSize + 1)
if (l % (this._blockSize * 8) >= this._finalSize * 8) {
this._update(this._block)
this._block.fill(0)
}
// to this append the block which is equal to the number l written in binary
// TODO: handle case where l is > Math.pow(2, 29)
this._block.writeInt32BE(l, this._blockSize - 4)
var hash = this._update(this._block) || this._hash()
return enc ? hash.toString(enc) : hash
}
Hash.prototype._update = function () {
throw new Error('_update must be implemented by subclass')
}
return Hash
}
/***/ },
/* 136 */
/***/ function(module, exports, __webpack_require__) {
/*
* A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
* in FIPS PUB 180-1
* Version 2.1a Copyright Paul Johnston 2000 - 2002.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* See http://pajhome.org.uk/crypt/md5 for details.
*/
var inherits = __webpack_require__(79).inherits
module.exports = function (Buffer, Hash) {
var A = 0|0
var B = 4|0
var C = 8|0
var D = 12|0
var E = 16|0
var W = new (typeof Int32Array === 'undefined' ? Array : Int32Array)(80)
var POOL = []
function Sha1 () {
if(POOL.length)
return POOL.pop().init()
if(!(this instanceof Sha1)) return new Sha1()
this._w = W
Hash.call(this, 16*4, 14*4)
this._h = null
this.init()
}
inherits(Sha1, Hash)
Sha1.prototype.init = function () {
this._a = 0x67452301
this._b = 0xefcdab89
this._c = 0x98badcfe
this._d = 0x10325476
this._e = 0xc3d2e1f0
Hash.prototype.init.call(this)
return this
}
Sha1.prototype._POOL = POOL
Sha1.prototype._update = function (X) {
var a, b, c, d, e, _a, _b, _c, _d, _e
a = _a = this._a
b = _b = this._b
c = _c = this._c
d = _d = this._d
e = _e = this._e
var w = this._w
for(var j = 0; j < 80; j++) {
var W = w[j] = j < 16 ? X.readInt32BE(j*4)
: rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1)
var t = add(
add(rol(a, 5), sha1_ft(j, b, c, d)),
add(add(e, W), sha1_kt(j))
)
e = d
d = c
c = rol(b, 30)
b = a
a = t
}
this._a = add(a, _a)
this._b = add(b, _b)
this._c = add(c, _c)
this._d = add(d, _d)
this._e = add(e, _e)
}
Sha1.prototype._hash = function () {
if(POOL.length < 100) POOL.push(this)
var H = new Buffer(20)
//console.log(this._a|0, this._b|0, this._c|0, this._d|0, this._e|0)
H.writeInt32BE(this._a|0, A)
H.writeInt32BE(this._b|0, B)
H.writeInt32BE(this._c|0, C)
H.writeInt32BE(this._d|0, D)
H.writeInt32BE(this._e|0, E)
return H
}
/*
* Perform the appropriate triplet combination function for the current
* iteration
*/
function sha1_ft(t, b, c, d) {
if(t < 20) return (b & c) | ((~b) & d);
if(t < 40) return b ^ c ^ d;
if(t < 60) return (b & c) | (b & d) | (c & d);
return b ^ c ^ d;
}
/*
* Determine the appropriate additive constant for the current iteration
*/
function sha1_kt(t) {
return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 :
(t < 60) ? -1894007588 : -899497514;
}
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
* //dominictarr: this is 10 years old, so maybe this can be dropped?)
*
*/
function add(x, y) {
return (x + y ) | 0
//lets see how this goes on testling.
// var lsw = (x & 0xFFFF) + (y & 0xFFFF);
// var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
// return (msw << 16) | (lsw & 0xFFFF);
}
/*
* Bitwise rotate a 32-bit number to the left.
*/
function rol(num, cnt) {
return (num << cnt) | (num >>> (32 - cnt));
}
return Sha1
}
/***/ },
/* 137 */
/***/ function(module, exports, __webpack_require__) {
/**
* A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
* in FIPS 180-2
* Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
*
*/
var inherits = __webpack_require__(79).inherits
module.exports = function (Buffer, Hash) {
var K = [
0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
]
var W = new Array(64)
function Sha256() {
this.init()
this._w = W //new Array(64)
Hash.call(this, 16*4, 14*4)
}
inherits(Sha256, Hash)
Sha256.prototype.init = function () {
this._a = 0x6a09e667|0
this._b = 0xbb67ae85|0
this._c = 0x3c6ef372|0
this._d = 0xa54ff53a|0
this._e = 0x510e527f|0
this._f = 0x9b05688c|0
this._g = 0x1f83d9ab|0
this._h = 0x5be0cd19|0
this._len = this._s = 0
return this
}
function S (X, n) {
return (X >>> n) | (X << (32 - n));
}
function R (X, n) {
return (X >>> n);
}
function Ch (x, y, z) {
return ((x & y) ^ ((~x) & z));
}
function Maj (x, y, z) {
return ((x & y) ^ (x & z) ^ (y & z));
}
function Sigma0256 (x) {
return (S(x, 2) ^ S(x, 13) ^ S(x, 22));
}
function Sigma1256 (x) {
return (S(x, 6) ^ S(x, 11) ^ S(x, 25));
}
function Gamma0256 (x) {
return (S(x, 7) ^ S(x, 18) ^ R(x, 3));
}
function Gamma1256 (x) {
return (S(x, 17) ^ S(x, 19) ^ R(x, 10));
}
Sha256.prototype._update = function(M) {
var W = this._w
var a, b, c, d, e, f, g, h
var T1, T2
a = this._a | 0
b = this._b | 0
c = this._c | 0
d = this._d | 0
e = this._e | 0
f = this._f | 0
g = this._g | 0
h = this._h | 0
for (var j = 0; j < 64; j++) {
var w = W[j] = j < 16
? M.readInt32BE(j * 4)
: Gamma1256(W[j - 2]) + W[j - 7] + Gamma0256(W[j - 15]) + W[j - 16]
T1 = h + Sigma1256(e) + Ch(e, f, g) + K[j] + w
T2 = Sigma0256(a) + Maj(a, b, c);
h = g; g = f; f = e; e = d + T1; d = c; c = b; b = a; a = T1 + T2;
}
this._a = (a + this._a) | 0
this._b = (b + this._b) | 0
this._c = (c + this._c) | 0
this._d = (d + this._d) | 0
this._e = (e + this._e) | 0
this._f = (f + this._f) | 0
this._g = (g + this._g) | 0
this._h = (h + this._h) | 0
};
Sha256.prototype._hash = function () {
var H = new Buffer(32)
H.writeInt32BE(this._a, 0)
H.writeInt32BE(this._b, 4)
H.writeInt32BE(this._c, 8)
H.writeInt32BE(this._d, 12)
H.writeInt32BE(this._e, 16)
H.writeInt32BE(this._f, 20)
H.writeInt32BE(this._g, 24)
H.writeInt32BE(this._h, 28)
return H
}
return Sha256
}
/***/ },
/* 138 */
/***/ function(module, exports, __webpack_require__) {
var inherits = __webpack_require__(79).inherits
module.exports = function (Buffer, Hash) {
var K = [
0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
]
var W = new Array(160)
function Sha512() {
this.init()
this._w = W
Hash.call(this, 128, 112)
}
inherits(Sha512, Hash)
Sha512.prototype.init = function () {
this._a = 0x6a09e667|0
this._b = 0xbb67ae85|0
this._c = 0x3c6ef372|0
this._d = 0xa54ff53a|0
this._e = 0x510e527f|0
this._f = 0x9b05688c|0
this._g = 0x1f83d9ab|0
this._h = 0x5be0cd19|0
this._al = 0xf3bcc908|0
this._bl = 0x84caa73b|0
this._cl = 0xfe94f82b|0
this._dl = 0x5f1d36f1|0
this._el = 0xade682d1|0
this._fl = 0x2b3e6c1f|0
this._gl = 0xfb41bd6b|0
this._hl = 0x137e2179|0
this._len = this._s = 0
return this
}
function S (X, Xl, n) {
return (X >>> n) | (Xl << (32 - n))
}
function Ch (x, y, z) {
return ((x & y) ^ ((~x) & z));
}
function Maj (x, y, z) {
return ((x & y) ^ (x & z) ^ (y & z));
}
Sha512.prototype._update = function(M) {
var W = this._w
var a, b, c, d, e, f, g, h
var al, bl, cl, dl, el, fl, gl, hl
a = this._a | 0
b = this._b | 0
c = this._c | 0
d = this._d | 0
e = this._e | 0
f = this._f | 0
g = this._g | 0
h = this._h | 0
al = this._al | 0
bl = this._bl | 0
cl = this._cl | 0
dl = this._dl | 0
el = this._el | 0
fl = this._fl | 0
gl = this._gl | 0
hl = this._hl | 0
for (var i = 0; i < 80; i++) {
var j = i * 2
var Wi, Wil
if (i < 16) {
Wi = W[j] = M.readInt32BE(j * 4)
Wil = W[j + 1] = M.readInt32BE(j * 4 + 4)
} else {
var x = W[j - 15*2]
var xl = W[j - 15*2 + 1]
var gamma0 = S(x, xl, 1) ^ S(x, xl, 8) ^ (x >>> 7)
var gamma0l = S(xl, x, 1) ^ S(xl, x, 8) ^ S(xl, x, 7)
x = W[j - 2*2]
xl = W[j - 2*2 + 1]
var gamma1 = S(x, xl, 19) ^ S(xl, x, 29) ^ (x >>> 6)
var gamma1l = S(xl, x, 19) ^ S(x, xl, 29) ^ S(xl, x, 6)
// W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
var Wi7 = W[j - 7*2]
var Wi7l = W[j - 7*2 + 1]
var Wi16 = W[j - 16*2]
var Wi16l = W[j - 16*2 + 1]
Wil = gamma0l + Wi7l
Wi = gamma0 + Wi7 + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0)
Wil = Wil + gamma1l
Wi = Wi + gamma1 + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0)
Wil = Wil + Wi16l
Wi = Wi + Wi16 + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0)
W[j] = Wi
W[j + 1] = Wil
}
var maj = Maj(a, b, c)
var majl = Maj(al, bl, cl)
var sigma0h = S(a, al, 28) ^ S(al, a, 2) ^ S(al, a, 7)
var sigma0l = S(al, a, 28) ^ S(a, al, 2) ^ S(a, al, 7)
var sigma1h = S(e, el, 14) ^ S(e, el, 18) ^ S(el, e, 9)
var sigma1l = S(el, e, 14) ^ S(el, e, 18) ^ S(e, el, 9)
// t1 = h + sigma1 + ch + K[i] + W[i]
var Ki = K[j]
var Kil = K[j + 1]
var ch = Ch(e, f, g)
var chl = Ch(el, fl, gl)
var t1l = hl + sigma1l
var t1 = h + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0)
t1l = t1l + chl
t1 = t1 + ch + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0)
t1l = t1l + Kil
t1 = t1 + Ki + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0)
t1l = t1l + Wil
t1 = t1 + Wi + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0)
// t2 = sigma0 + maj
var t2l = sigma0l + majl
var t2 = sigma0h + maj + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0)
h = g
hl = gl
g = f
gl = fl
f = e
fl = el
el = (dl + t1l) | 0
e = (d + t1 + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0
d = c
dl = cl
c = b
cl = bl
b = a
bl = al
al = (t1l + t2l) | 0
a = (t1 + t2 + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0
}
this._al = (this._al + al) | 0
this._bl = (this._bl + bl) | 0
this._cl = (this._cl + cl) | 0
this._dl = (this._dl + dl) | 0
this._el = (this._el + el) | 0
this._fl = (this._fl + fl) | 0
this._gl = (this._gl + gl) | 0
this._hl = (this._hl + hl) | 0
this._a = (this._a + a + ((this._al >>> 0) < (al >>> 0) ? 1 : 0)) | 0
this._b = (this._b + b + ((this._bl >>> 0) < (bl >>> 0) ? 1 : 0)) | 0
this._c = (this._c + c + ((this._cl >>> 0) < (cl >>> 0) ? 1 : 0)) | 0
this._d = (this._d + d + ((this._dl >>> 0) < (dl >>> 0) ? 1 : 0)) | 0
this._e = (this._e + e + ((this._el >>> 0) < (el >>> 0) ? 1 : 0)) | 0
this._f = (this._f + f + ((this._fl >>> 0) < (fl >>> 0) ? 1 : 0)) | 0
this._g = (this._g + g + ((this._gl >>> 0) < (gl >>> 0) ? 1 : 0)) | 0
this._h = (this._h + h + ((this._hl >>> 0) < (hl >>> 0) ? 1 : 0)) | 0
}
Sha512.prototype._hash = function () {
var H = new Buffer(64)
function writeInt64BE(h, l, offset) {
H.writeInt32BE(h, offset)
H.writeInt32BE(l, offset + 4)
}
writeInt64BE(this._a, this._al, 0)
writeInt64BE(this._b, this._bl, 8)
writeInt64BE(this._c, this._cl, 16)
writeInt64BE(this._d, this._dl, 24)
writeInt64BE(this._e, this._el, 32)
writeInt64BE(this._f, this._fl, 40)
writeInt64BE(this._g, this._gl, 48)
writeInt64BE(this._h, this._hl, 56)
return H
}
return Sha512
}
/***/ },
/* 139 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var config = __webpack_require__(164).config;
var configure = __webpack_require__(164).configure;
var objectOrFunction = __webpack_require__(165).objectOrFunction;
var isFunction = __webpack_require__(165).isFunction;
var now = __webpack_require__(165).now;
var all = __webpack_require__(166).all;
var race = __webpack_require__(167).race;
var staticResolve = __webpack_require__(168).resolve;
var staticReject = __webpack_require__(169).reject;
var asap = __webpack_require__(170).asap;
var counter = 0;
config.async = asap; // default async is asap;
function Promise(resolver) {
if (!isFunction(resolver)) {
throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
}
if (!(this instanceof Promise)) {
throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
}
this._subscribers = [];
invokeResolver(resolver, this);
}
function invokeResolver(resolver, promise) {
function resolvePromise(value) {
resolve(promise, value);
}
function rejectPromise(reason) {
reject(promise, reason);
}
try {
resolver(resolvePromise, rejectPromise);
} catch(e) {
rejectPromise(e);
}
}
function invokeCallback(settled, promise, callback, detail) {
var hasCallback = isFunction(callback),
value, error, succeeded, failed;
if (hasCallback) {
try {
value = callback(detail);
succeeded = true;
} catch(e) {
failed = true;
error = e;
}
} else {
value = detail;
succeeded = true;
}
if (handleThenable(promise, value)) {
return;
} else if (hasCallback && succeeded) {
resolve(promise, value);
} else if (failed) {
reject(promise, error);
} else if (settled === FULFILLED) {
resolve(promise, value);
} else if (settled === REJECTED) {
reject(promise, value);
}
}
var PENDING = void 0;
var SEALED = 0;
var FULFILLED = 1;
var REJECTED = 2;
function subscribe(parent, child, onFulfillment, onRejection) {
var subscribers = parent._subscribers;
var length = subscribers.length;
subscribers[length] = child;
subscribers[length + FULFILLED] = onFulfillment;
subscribers[length + REJECTED] = onRejection;
}
function publish(promise, settled) {
var child, callback, subscribers = promise._subscribers, detail = promise._detail;
for (var i = 0; i < subscribers.length; i += 3) {
child = subscribers[i];
callback = subscribers[i + settled];
invokeCallback(settled, child, callback, detail);
}
promise._subscribers = null;
}
Promise.prototype = {
constructor: Promise,
_state: undefined,
_detail: undefined,
_subscribers: undefined,
then: function(onFulfillment, onRejection) {
var promise = this;
var thenPromise = new this.constructor(function() {});
if (this._state) {
var callbacks = arguments;
config.async(function invokePromiseCallback() {
invokeCallback(promise._state, thenPromise, callbacks[promise._state - 1], promise._detail);
});
} else {
subscribe(this, thenPromise, onFulfillment, onRejection);
}
return thenPromise;
},
'catch': function(onRejection) {
return this.then(null, onRejection);
}
};
Promise.all = all;
Promise.race = race;
Promise.resolve = staticResolve;
Promise.reject = staticReject;
function handleThenable(promise, value) {
var then = null,
resolved;
try {
if (promise === value) {
throw new TypeError("A promises callback cannot return that same promise.");
}
if (objectOrFunction(value)) {
then = value.then;
if (isFunction(then)) {
then.call(value, function(val) {
if (resolved) { return true; }
resolved = true;
if (value !== val) {
resolve(promise, val);
} else {
fulfill(promise, val);
}
}, function(val) {
if (resolved) { return true; }
resolved = true;
reject(promise, val);
});
return true;
}
}
} catch (error) {
if (resolved) { return true; }
reject(promise, error);
return true;
}
return false;
}
function resolve(promise, value) {
if (promise === value) {
fulfill(promise, value);
} else if (!handleThenable(promise, value)) {
fulfill(promise, value);
}
}
function fulfill(promise, value) {
if (promise._state !== PENDING) { return; }
promise._state = SEALED;
promise._detail = value;
config.async(publishFulfillment, promise);
}
function reject(promise, reason) {
if (promise._state !== PENDING) { return; }
promise._state = SEALED;
promise._detail = reason;
config.async(publishRejection, promise);
}
function publishFulfillment(promise) {
publish(promise, promise._state = FULFILLED);
}
function publishRejection(promise) {
publish(promise, promise._state = REJECTED);
}
exports.Promise = Promise;
/***/ },
/* 140 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(global) {"use strict";
/*global self*/
var RSVPPromise = __webpack_require__(139).Promise;
var isFunction = __webpack_require__(165).isFunction;
function polyfill() {
var local;
if (typeof global !== 'undefined') {
local = global;
} else if (typeof window !== 'undefined' && window.document) {
local = window;
} else {
local = self;
}
var es6PromiseSupport =
"Promise" in local &&
// Some of these methods are missing from
// Firefox/Chrome experimental implementations
"resolve" in local.Promise &&
"reject" in local.Promise &&
"all" in local.Promise &&
"race" in local.Promise &&
// Older version of the spec had a resolver object
// as the arg rather than a function
(function() {
var resolve;
new local.Promise(function(r) { resolve = r; });
return isFunction(resolve);
}());
if (!es6PromiseSupport) {
local.Promise = RSVPPromise;
}
}
exports.polyfill = polyfill;
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
/***/ },
/* 141 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// A bit simpler than readable streams.
// Implement an async ._write(chunk, cb), and it'll handle all
// the drain event emission and buffering.
module.exports = Writable;
/*<replacement>*/
var Buffer = __webpack_require__(47).Buffer;
/*</replacement>*/
Writable.WritableState = WritableState;
/*<replacement>*/
var util = __webpack_require__(178);
util.inherits = __webpack_require__(177);
/*</replacement>*/
var Stream = __webpack_require__(64);
util.inherits(Writable, Stream);
function WriteReq(chunk, encoding, cb) {
this.chunk = chunk;
this.encoding = encoding;
this.callback = cb;
}
function WritableState(options, stream) {
var Duplex = __webpack_require__(142);
options = options || {};
// the point at which write() starts returning false
// Note: 0 is a valid value, means that we always return false if
// the entire buffer is not flushed immediately on write()
var hwm = options.highWaterMark;
var defaultHwm = options.objectMode ? 16 : 16 * 1024;
this.highWaterMark = (hwm || hwm === 0) ? hwm : defaultHwm;
// object stream flag to indicate whether or not this stream
// contains buffers or objects.
this.objectMode = !!options.objectMode;
if (stream instanceof Duplex)
this.objectMode = this.objectMode || !!options.writableObjectMode;
// cast to ints.
this.highWaterMark = ~~this.highWaterMark;
this.needDrain = false;
// at the start of calling end()
this.ending = false;
// when end() has been called, and returned
this.ended = false;
// when 'finish' is emitted
this.finished = false;
// should we decode strings into buffers before passing to _write?
// this is here so that some node-core streams can optimize string
// handling at a lower level.
var noDecode = options.decodeStrings === false;
this.decodeStrings = !noDecode;
// Crypto is kind of old and crusty. Historically, its default string
// encoding is 'binary' so we have to make this configurable.
// Everything else in the universe uses 'utf8', though.
this.defaultEncoding = options.defaultEncoding || 'utf8';
// not an actual buffer we keep track of, but a measurement
// of how much we're waiting to get pushed to some underlying
// socket or file.
this.length = 0;
// a flag to see when we're in the middle of a write.
this.writing = false;
// when true all writes will be buffered until .uncork() call
this.corked = 0;
// a flag to be able to tell if the onwrite cb is called immediately,
// or on a later tick. We set this to true at first, because any
// actions that shouldn't happen until "later" should generally also
// not happen before the first write call.
this.sync = true;
// a flag to know if we're processing previously buffered items, which
// may call the _write() callback in the same tick, so that we don't
// end up in an overlapped onwrite situation.
this.bufferProcessing = false;
// the callback that's passed to _write(chunk,cb)
this.onwrite = function(er) {
onwrite(stream, er);
};
// the callback that the user supplies to write(chunk,encoding,cb)
this.writecb = null;
// the amount that is being written when _write is called.
this.writelen = 0;
this.buffer = [];
// number of pending user-supplied write callbacks
// this must be 0 before 'finish' can be emitted
this.pendingcb = 0;
// emit prefinish if the only thing we're waiting for is _write cbs
// This is relevant for synchronous Transform streams
this.prefinished = false;
// True if the error was already emitted and should not be thrown again
this.errorEmitted = false;
}
function Writable(options) {
var Duplex = __webpack_require__(142);
// Writable ctor is applied to Duplexes, though they're not
// instanceof Writable, they're instanceof Readable.
if (!(this instanceof Writable) && !(this instanceof Duplex))
return new Writable(options);
this._writableState = new WritableState(options, this);
// legacy.
this.writable = true;
Stream.call(this);
}
// Otherwise people can pipe Writable streams, which is just wrong.
Writable.prototype.pipe = function() {
this.emit('error', new Error('Cannot pipe. Not readable.'));
};
function writeAfterEnd(stream, state, cb) {
var er = new Error('write after end');
// TODO: defer error events consistently everywhere, not just the cb
stream.emit('error', er);
process.nextTick(function() {
cb(er);
});
}
// If we get something that is not a buffer, string, null, or undefined,
// and we're not in objectMode, then that's an error.
// Otherwise stream chunks are all considered to be of length=1, and the
// watermarks determine how many objects to keep in the buffer, rather than
// how many bytes or characters.
function validChunk(stream, state, chunk, cb) {
var valid = true;
if (!util.isBuffer(chunk) &&
!util.isString(chunk) &&
!util.isNullOrUndefined(chunk) &&
!state.objectMode) {
var er = new TypeError('Invalid non-string/buffer chunk');
stream.emit('error', er);
process.nextTick(function() {
cb(er);
});
valid = false;
}
return valid;
}
Writable.prototype.write = function(chunk, encoding, cb) {
var state = this._writableState;
var ret = false;
if (util.isFunction(encoding)) {
cb = encoding;
encoding = null;
}
if (util.isBuffer(chunk))
encoding = 'buffer';
else if (!encoding)
encoding = state.defaultEncoding;
if (!util.isFunction(cb))
cb = function() {};
if (state.ended)
writeAfterEnd(this, state, cb);
else if (validChunk(this, state, chunk, cb)) {
state.pendingcb++;
ret = writeOrBuffer(this, state, chunk, encoding, cb);
}
return ret;
};
Writable.prototype.cork = function() {
var state = this._writableState;
state.corked++;
};
Writable.prototype.uncork = function() {
var state = this._writableState;
if (state.corked) {
state.corked--;
if (!state.writing &&
!state.corked &&
!state.finished &&
!state.bufferProcessing &&
state.buffer.length)
clearBuffer(this, state);
}
};
function decodeChunk(state, chunk, encoding) {
if (!state.objectMode &&
state.decodeStrings !== false &&
util.isString(chunk)) {
chunk = new Buffer(chunk, encoding);
}
return chunk;
}
// if we're already writing something, then just put this
// in the queue, and wait our turn. Otherwise, call _write
// If we return false, then we need a drain event, so set that flag.
function writeOrBuffer(stream, state, chunk, encoding, cb) {
chunk = decodeChunk(state, chunk, encoding);
if (util.isBuffer(chunk))
encoding = 'buffer';
var len = state.objectMode ? 1 : chunk.length;
state.length += len;
var ret = state.length < state.highWaterMark;
// we must ensure that previous needDrain will not be reset to false.
if (!ret)
state.needDrain = true;
if (state.writing || state.corked)
state.buffer.push(new WriteReq(chunk, encoding, cb));
else
doWrite(stream, state, false, len, chunk, encoding, cb);
return ret;
}
function doWrite(stream, state, writev, len, chunk, encoding, cb) {
state.writelen = len;
state.writecb = cb;
state.writing = true;
state.sync = true;
if (writev)
stream._writev(chunk, state.onwrite);
else
stream._write(chunk, encoding, state.onwrite);
state.sync = false;
}
function onwriteError(stream, state, sync, er, cb) {
if (sync)
process.nextTick(function() {
state.pendingcb--;
cb(er);
});
else {
state.pendingcb--;
cb(er);
}
stream._writableState.errorEmitted = true;
stream.emit('error', er);
}
function onwriteStateUpdate(state) {
state.writing = false;
state.writecb = null;
state.length -= state.writelen;
state.writelen = 0;
}
function onwrite(stream, er) {
var state = stream._writableState;
var sync = state.sync;
var cb = state.writecb;
onwriteStateUpdate(state);
if (er)
onwriteError(stream, state, sync, er, cb);
else {
// Check if we're actually ready to finish, but don't emit yet
var finished = needFinish(stream, state);
if (!finished &&
!state.corked &&
!state.bufferProcessing &&
state.buffer.length) {
clearBuffer(stream, state);
}
if (sync) {
process.nextTick(function() {
afterWrite(stream, state, finished, cb);
});
} else {
afterWrite(stream, state, finished, cb);
}
}
}
function afterWrite(stream, state, finished, cb) {
if (!finished)
onwriteDrain(stream, state);
state.pendingcb--;
cb();
finishMaybe(stream, state);
}
// Must force callback to be called on nextTick, so that we don't
// emit 'drain' before the write() consumer gets the 'false' return
// value, and has a chance to attach a 'drain' listener.
function onwriteDrain(stream, state) {
if (state.length === 0 && state.needDrain) {
state.needDrain = false;
stream.emit('drain');
}
}
// if there's something in the buffer waiting, then process it
function clearBuffer(stream, state) {
state.bufferProcessing = true;
if (stream._writev && state.buffer.length > 1) {
// Fast case, write everything using _writev()
var cbs = [];
for (var c = 0; c < state.buffer.length; c++)
cbs.push(state.buffer[c].callback);
// count the one we are adding, as well.
// TODO(isaacs) clean this up
state.pendingcb++;
doWrite(stream, state, true, state.length, state.buffer, '', function(err) {
for (var i = 0; i < cbs.length; i++) {
state.pendingcb--;
cbs[i](err);
}
});
// Clear buffer
state.buffer = [];
} else {
// Slow case, write chunks one-by-one
for (var c = 0; c < state.buffer.length; c++) {
var entry = state.buffer[c];
var chunk = entry.chunk;
var encoding = entry.encoding;
var cb = entry.callback;
var len = state.objectMode ? 1 : chunk.length;
doWrite(stream, state, false, len, chunk, encoding, cb);
// if we didn't call the onwrite immediately, then
// it means that we need to wait until it does.
// also, that means that the chunk and cb are currently
// being processed, so move the buffer counter past them.
if (state.writing) {
c++;
break;
}
}
if (c < state.buffer.length)
state.buffer = state.buffer.slice(c);
else
state.buffer.length = 0;
}
state.bufferProcessing = false;
}
Writable.prototype._write = function(chunk, encoding, cb) {
cb(new Error('not implemented'));
};
Writable.prototype._writev = null;
Writable.prototype.end = function(chunk, encoding, cb) {
var state = this._writableState;
if (util.isFunction(chunk)) {
cb = chunk;
chunk = null;
encoding = null;
} else if (util.isFunction(encoding)) {
cb = encoding;
encoding = null;
}
if (!util.isNullOrUndefined(chunk))
this.write(chunk, encoding);
// .end() fully uncorks
if (state.corked) {
state.corked = 1;
this.uncork();
}
// ignore unnecessary end() calls.
if (!state.ending && !state.finished)
endWritable(this, state, cb);
};
function needFinish(stream, state) {
return (state.ending &&
state.length === 0 &&
!state.finished &&
!state.writing);
}
function prefinish(stream, state) {
if (!state.prefinished) {
state.prefinished = true;
stream.emit('prefinish');
}
}
function finishMaybe(stream, state) {
var need = needFinish(stream, state);
if (need) {
if (state.pendingcb === 0) {
prefinish(stream, state);
state.finished = true;
stream.emit('finish');
} else
prefinish(stream, state);
}
return need;
}
function endWritable(stream, state, cb) {
state.ending = true;
finishMaybe(stream, state);
if (cb) {
if (state.finished)
process.nextTick(cb);
else
stream.once('finish', cb);
}
state.ended = true;
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(99)))
/***/ },
/* 142 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// a duplex stream is just a stream that is both readable and writable.
// Since JS doesn't have multiple prototypal inheritance, this class
// prototypally inherits from Readable, and then parasitically from
// Writable.
module.exports = Duplex;
/*<replacement>*/
var objectKeys = Object.keys || function (obj) {
var keys = [];
for (var key in obj) keys.push(key);
return keys;
}
/*</replacement>*/
/*<replacement>*/
var util = __webpack_require__(178);
util.inherits = __webpack_require__(177);
/*</replacement>*/
var Readable = __webpack_require__(143);
var Writable = __webpack_require__(141);
util.inherits(Duplex, Readable);
forEach(objectKeys(Writable.prototype), function(method) {
if (!Duplex.prototype[method])
Duplex.prototype[method] = Writable.prototype[method];
});
function Duplex(options) {
if (!(this instanceof Duplex))
return new Duplex(options);
Readable.call(this, options);
Writable.call(this, options);
if (options && options.readable === false)
this.readable = false;
if (options && options.writable === false)
this.writable = false;
this.allowHalfOpen = true;
if (options && options.allowHalfOpen === false)
this.allowHalfOpen = false;
this.once('end', onend);
}
// the no-half-open enforcer
function onend() {
// if we allow half-open state, or if the writable side ended,
// then we're ok.
if (this.allowHalfOpen || this._writableState.ended)
return;
// no more data can be written.
// But allow more writes to happen in this tick.
process.nextTick(this.end.bind(this));
}
function forEach (xs, f) {
for (var i = 0, l = xs.length; i < l; i++) {
f(xs[i], i);
}
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(99)))
/***/ },
/* 143 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
module.exports = Readable;
/*<replacement>*/
var isArray = __webpack_require__(175);
/*</replacement>*/
/*<replacement>*/
var Buffer = __webpack_require__(47).Buffer;
/*</replacement>*/
Readable.ReadableState = ReadableState;
var EE = __webpack_require__(44).EventEmitter;
/*<replacement>*/
if (!EE.listenerCount) EE.listenerCount = function(emitter, type) {
return emitter.listeners(type).length;
};
/*</replacement>*/
var Stream = __webpack_require__(64);
/*<replacement>*/
var util = __webpack_require__(178);
util.inherits = __webpack_require__(177);
/*</replacement>*/
var StringDecoder;
/*<replacement>*/
var debug = __webpack_require__(171);
if (debug && debug.debuglog) {
debug = debug.debuglog('stream');
} else {
debug = function () {};
}
/*</replacement>*/
util.inherits(Readable, Stream);
function ReadableState(options, stream) {
var Duplex = __webpack_require__(142);
options = options || {};
// the point at which it stops calling _read() to fill the buffer
// Note: 0 is a valid value, means "don't call _read preemptively ever"
var hwm = options.highWaterMark;
var defaultHwm = options.objectMode ? 16 : 16 * 1024;
this.highWaterMark = (hwm || hwm === 0) ? hwm : defaultHwm;
// cast to ints.
this.highWaterMark = ~~this.highWaterMark;
this.buffer = [];
this.length = 0;
this.pipes = null;
this.pipesCount = 0;
this.flowing = null;
this.ended = false;
this.endEmitted = false;
this.reading = false;
// a flag to be able to tell if the onwrite cb is called immediately,
// or on a later tick. We set this to true at first, because any
// actions that shouldn't happen until "later" should generally also
// not happen before the first write call.
this.sync = true;
// whenever we return null, then we set a flag to say
// that we're awaiting a 'readable' event emission.
this.needReadable = false;
this.emittedReadable = false;
this.readableListening = false;
// object stream flag. Used to make read(n) ignore n and to
// make all the buffer merging and length checks go away
this.objectMode = !!options.objectMode;
if (stream instanceof Duplex)
this.objectMode = this.objectMode || !!options.readableObjectMode;
// Crypto is kind of old and crusty. Historically, its default string
// encoding is 'binary' so we have to make this configurable.
// Everything else in the universe uses 'utf8', though.
this.defaultEncoding = options.defaultEncoding || 'utf8';
// when piping, we only care about 'readable' events that happen
// after read()ing all the bytes and not getting any pushback.
this.ranOut = false;
// the number of writers that are awaiting a drain event in .pipe()s
this.awaitDrain = 0;
// if true, a maybeReadMore has been scheduled
this.readingMore = false;
this.decoder = null;
this.encoding = null;
if (options.encoding) {
if (!StringDecoder)
StringDecoder = __webpack_require__(176).StringDecoder;
this.decoder = new StringDecoder(options.encoding);
this.encoding = options.encoding;
}
}
function Readable(options) {
var Duplex = __webpack_require__(142);
if (!(this instanceof Readable))
return new Readable(options);
this._readableState = new ReadableState(options, this);
// legacy
this.readable = true;
Stream.call(this);
}
// Manually shove something into the read() buffer.
// This returns true if the highWaterMark has not been hit yet,
// similar to how Writable.write() returns true if you should
// write() some more.
Readable.prototype.push = function(chunk, encoding) {
var state = this._readableState;
if (util.isString(chunk) && !state.objectMode) {
encoding = encoding || state.defaultEncoding;
if (encoding !== state.encoding) {
chunk = new Buffer(chunk, encoding);
encoding = '';
}
}
return readableAddChunk(this, state, chunk, encoding, false);
};
// Unshift should *always* be something directly out of read()
Readable.prototype.unshift = function(chunk) {
var state = this._readableState;
return readableAddChunk(this, state, chunk, '', true);
};
function readableAddChunk(stream, state, chunk, encoding, addToFront) {
var er = chunkInvalid(state, chunk);
if (er) {
stream.emit('error', er);
} else if (util.isNullOrUndefined(chunk)) {
state.reading = false;
if (!state.ended)
onEofChunk(stream, state);
} else if (state.objectMode || chunk && chunk.length > 0) {
if (state.ended && !addToFront) {
var e = new Error('stream.push() after EOF');
stream.emit('error', e);
} else if (state.endEmitted && addToFront) {
var e = new Error('stream.unshift() after end event');
stream.emit('error', e);
} else {
if (state.decoder && !addToFront && !encoding)
chunk = state.decoder.write(chunk);
if (!addToFront)
state.reading = false;
// if we want the data now, just emit it.
if (state.flowing && state.length === 0 && !state.sync) {
stream.emit('data', chunk);
stream.read(0);
} else {
// update the buffer info.
state.length += state.objectMode ? 1 : chunk.length;
if (addToFront)
state.buffer.unshift(chunk);
else
state.buffer.push(chunk);
if (state.needReadable)
emitReadable(stream);
}
maybeReadMore(stream, state);
}
} else if (!addToFront) {
state.reading = false;
}
return needMoreData(state);
}
// if it's past the high water mark, we can push in some more.
// Also, if we have no data yet, we can stand some
// more bytes. This is to work around cases where hwm=0,
// such as the repl. Also, if the push() triggered a
// readable event, and the user called read(largeNumber) such that
// needReadable was set, then we ought to push more, so that another
// 'readable' event will be triggered.
function needMoreData(state) {
return !state.ended &&
(state.needReadable ||
state.length < state.highWaterMark ||
state.length === 0);
}
// backwards compatibility.
Readable.prototype.setEncoding = function(enc) {
if (!StringDecoder)
StringDecoder = __webpack_require__(176).StringDecoder;
this._readableState.decoder = new StringDecoder(enc);
this._readableState.encoding = enc;
return this;
};
// Don't raise the hwm > 128MB
var MAX_HWM = 0x800000;
function roundUpToNextPowerOf2(n) {
if (n >= MAX_HWM) {
n = MAX_HWM;
} else {
// Get the next highest power of 2
n--;
for (var p = 1; p < 32; p <<= 1) n |= n >> p;
n++;
}
return n;
}
function howMuchToRead(n, state) {
if (state.length === 0 && state.ended)
return 0;
if (state.objectMode)
return n === 0 ? 0 : 1;
if (isNaN(n) || util.isNull(n)) {
// only flow one buffer at a time
if (state.flowing && state.buffer.length)
return state.buffer[0].length;
else
return state.length;
}
if (n <= 0)
return 0;
// If we're asking for more than the target buffer level,
// then raise the water mark. Bump up to the next highest
// power of 2, to prevent increasing it excessively in tiny
// amounts.
if (n > state.highWaterMark)
state.highWaterMark = roundUpToNextPowerOf2(n);
// don't have that much. return null, unless we've ended.
if (n > state.length) {
if (!state.ended) {
state.needReadable = true;
return 0;
} else
return state.length;
}
return n;
}
// you can override either this method, or the async _read(n) below.
Readable.prototype.read = function(n) {
debug('read', n);
var state = this._readableState;
var nOrig = n;
if (!util.isNumber(n) || n > 0)
state.emittedReadable = false;
// if we're doing read(0) to trigger a readable event, but we
// already have a bunch of data in the buffer, then just trigger
// the 'readable' event and move on.
if (n === 0 &&
state.needReadable &&
(state.length >= state.highWaterMark || state.ended)) {
debug('read: emitReadable', state.length, state.ended);
if (state.length === 0 && state.ended)
endReadable(this);
else
emitReadable(this);
return null;
}
n = howMuchToRead(n, state);
// if we've ended, and we're now clear, then finish it up.
if (n === 0 && state.ended) {
if (state.length === 0)
endReadable(this);
return null;
}
// All the actual chunk generation logic needs to be
// *below* the call to _read. The reason is that in certain
// synthetic stream cases, such as passthrough streams, _read
// may be a completely synchronous operation which may change
// the state of the read buffer, providing enough data when
// before there was *not* enough.
//
// So, the steps are:
// 1. Figure out what the state of things will be after we do
// a read from the buffer.
//
// 2. If that resulting state will trigger a _read, then call _read.
// Note that this may be asynchronous, or synchronous. Yes, it is
// deeply ugly to write APIs this way, but that still doesn't mean
// that the Readable class should behave improperly, as streams are
// designed to be sync/async agnostic.
// Take note if the _read call is sync or async (ie, if the read call
// has returned yet), so that we know whether or not it's safe to emit
// 'readable' etc.
//
// 3. Actually pull the requested chunks out of the buffer and return.
// if we need a readable event, then we need to do some reading.
var doRead = state.needReadable;
debug('need readable', doRead);
// if we currently have less than the highWaterMark, then also read some
if (state.length === 0 || state.length - n < state.highWaterMark) {
doRead = true;
debug('length less than watermark', doRead);
}
// however, if we've ended, then there's no point, and if we're already
// reading, then it's unnecessary.
if (state.ended || state.reading) {
doRead = false;
debug('reading or ended', doRead);
}
if (doRead) {
debug('do read');
state.reading = true;
state.sync = true;
// if the length is currently zero, then we *need* a readable event.
if (state.length === 0)
state.needReadable = true;
// call internal read method
this._read(state.highWaterMark);
state.sync = false;
}
// If _read pushed data synchronously, then `reading` will be false,
// and we need to re-evaluate how much data we can return to the user.
if (doRead && !state.reading)
n = howMuchToRead(nOrig, state);
var ret;
if (n > 0)
ret = fromList(n, state);
else
ret = null;
if (util.isNull(ret)) {
state.needReadable = true;
n = 0;
}
state.length -= n;
// If we have nothing in the buffer, then we want to know
// as soon as we *do* get something into the buffer.
if (state.length === 0 && !state.ended)
state.needReadable = true;
// If we tried to read() past the EOF, then emit end on the next tick.
if (nOrig !== n && state.ended && state.length === 0)
endReadable(this);
if (!util.isNull(ret))
this.emit('data', ret);
return ret;
};
function chunkInvalid(state, chunk) {
var er = null;
if (!util.isBuffer(chunk) &&
!util.isString(chunk) &&
!util.isNullOrUndefined(chunk) &&
!state.objectMode) {
er = new TypeError('Invalid non-string/buffer chunk');
}
return er;
}
function onEofChunk(stream, state) {
if (state.decoder && !state.ended) {
var chunk = state.decoder.end();
if (chunk && chunk.length) {
state.buffer.push(chunk);
state.length += state.objectMode ? 1 : chunk.length;
}
}
state.ended = true;
// emit 'readable' now to make sure it gets picked up.
emitReadable(stream);
}
// Don't emit readable right away in sync mode, because this can trigger
// another read() call => stack overflow. This way, it might trigger
// a nextTick recursion warning, but that's not so bad.
function emitReadable(stream) {
var state = stream._readableState;
state.needReadable = false;
if (!state.emittedReadable) {
debug('emitReadable', state.flowing);
state.emittedReadable = true;
if (state.sync)
process.nextTick(function() {
emitReadable_(stream);
});
else
emitReadable_(stream);
}
}
function emitReadable_(stream) {
debug('emit readable');
stream.emit('readable');
flow(stream);
}
// at this point, the user has presumably seen the 'readable' event,
// and called read() to consume some data. that may have triggered
// in turn another _read(n) call, in which case reading = true if
// it's in progress.
// However, if we're not ended, or reading, and the length < hwm,
// then go ahead and try to read some more preemptively.
function maybeReadMore(stream, state) {
if (!state.readingMore) {
state.readingMore = true;
process.nextTick(function() {
maybeReadMore_(stream, state);
});
}
}
function maybeReadMore_(stream, state) {
var len = state.length;
while (!state.reading && !state.flowing && !state.ended &&
state.length < state.highWaterMark) {
debug('maybeReadMore read 0');
stream.read(0);
if (len === state.length)
// didn't get any data, stop spinning.
break;
else
len = state.length;
}
state.readingMore = false;
}
// abstract method. to be overridden in specific implementation classes.
// call cb(er, data) where data is <= n in length.
// for virtual (non-string, non-buffer) streams, "length" is somewhat
// arbitrary, and perhaps not very meaningful.
Readable.prototype._read = function(n) {
this.emit('error', new Error('not implemented'));
};
Readable.prototype.pipe = function(dest, pipeOpts) {
var src = this;
var state = this._readableState;
switch (state.pipesCount) {
case 0:
state.pipes = dest;
break;
case 1:
state.pipes = [state.pipes, dest];
break;
default:
state.pipes.push(dest);
break;
}
state.pipesCount += 1;
debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
var doEnd = (!pipeOpts || pipeOpts.end !== false) &&
dest !== process.stdout &&
dest !== process.stderr;
var endFn = doEnd ? onend : cleanup;
if (state.endEmitted)
process.nextTick(endFn);
else
src.once('end', endFn);
dest.on('unpipe', onunpipe);
function onunpipe(readable) {
debug('onunpipe');
if (readable === src) {
cleanup();
}
}
function onend() {
debug('onend');
dest.end();
}
// when the dest drains, it reduces the awaitDrain counter
// on the source. This would be more elegant with a .once()
// handler in flow(), but adding and removing repeatedly is
// too slow.
var ondrain = pipeOnDrain(src);
dest.on('drain', ondrain);
function cleanup() {
debug('cleanup');
// cleanup event handlers once the pipe is broken
dest.removeListener('close', onclose);
dest.removeListener('finish', onfinish);
dest.removeListener('drain', ondrain);
dest.removeListener('error', onerror);
dest.removeListener('unpipe', onunpipe);
src.removeListener('end', onend);
src.removeListener('end', cleanup);
src.removeListener('data', ondata);
// if the reader is waiting for a drain event from this
// specific writer, then it would cause it to never start
// flowing again.
// So, if this is awaiting a drain, then we just call it now.
// If we don't know, then assume that we are waiting for one.
if (state.awaitDrain &&
(!dest._writableState || dest._writableState.needDrain))
ondrain();
}
src.on('data', ondata);
function ondata(chunk) {
debug('ondata');
var ret = dest.write(chunk);
if (false === ret) {
debug('false write response, pause',
src._readableState.awaitDrain);
src._readableState.awaitDrain++;
src.pause();
}
}
// if the dest has an error, then stop piping into it.
// however, don't suppress the throwing behavior for this.
function onerror(er) {
debug('onerror', er);
unpipe();
dest.removeListener('error', onerror);
if (EE.listenerCount(dest, 'error') === 0)
dest.emit('error', er);
}
// This is a brutally ugly hack to make sure that our error handler
// is attached before any userland ones. NEVER DO THIS.
if (!dest._events || !dest._events.error)
dest.on('error', onerror);
else if (isArray(dest._events.error))
dest._events.error.unshift(onerror);
else
dest._events.error = [onerror, dest._events.error];
// Both close and finish should trigger unpipe, but only once.
function onclose() {
dest.removeListener('finish', onfinish);
unpipe();
}
dest.once('close', onclose);
function onfinish() {
debug('onfinish');
dest.removeListener('close', onclose);
unpipe();
}
dest.once('finish', onfinish);
function unpipe() {
debug('unpipe');
src.unpipe(dest);
}
// tell the dest that it's being piped to
dest.emit('pipe', src);
// start the flow if it hasn't been started already.
if (!state.flowing) {
debug('pipe resume');
src.resume();
}
return dest;
};
function pipeOnDrain(src) {
return function() {
var state = src._readableState;
debug('pipeOnDrain', state.awaitDrain);
if (state.awaitDrain)
state.awaitDrain--;
if (state.awaitDrain === 0 && EE.listenerCount(src, 'data')) {
state.flowing = true;
flow(src);
}
};
}
Readable.prototype.unpipe = function(dest) {
var state = this._readableState;
// if we're not piping anywhere, then do nothing.
if (state.pipesCount === 0)
return this;
// just one destination. most common case.
if (state.pipesCount === 1) {
// passed in one, but it's not the right one.
if (dest && dest !== state.pipes)
return this;
if (!dest)
dest = state.pipes;
// got a match.
state.pipes = null;
state.pipesCount = 0;
state.flowing = false;
if (dest)
dest.emit('unpipe', this);
return this;
}
// slow case. multiple pipe destinations.
if (!dest) {
// remove all.
var dests = state.pipes;
var len = state.pipesCount;
state.pipes = null;
state.pipesCount = 0;
state.flowing = false;
for (var i = 0; i < len; i++)
dests[i].emit('unpipe', this);
return this;
}
// try to find the right one.
var i = indexOf(state.pipes, dest);
if (i === -1)
return this;
state.pipes.splice(i, 1);
state.pipesCount -= 1;
if (state.pipesCount === 1)
state.pipes = state.pipes[0];
dest.emit('unpipe', this);
return this;
};
// set up data events if they are asked for
// Ensure readable listeners eventually get something
Readable.prototype.on = function(ev, fn) {
var res = Stream.prototype.on.call(this, ev, fn);
// If listening to data, and it has not explicitly been paused,
// then call resume to start the flow of data on the next tick.
if (ev === 'data' && false !== this._readableState.flowing) {
this.resume();
}
if (ev === 'readable' && this.readable) {
var state = this._readableState;
if (!state.readableListening) {
state.readableListening = true;
state.emittedReadable = false;
state.needReadable = true;
if (!state.reading) {
var self = this;
process.nextTick(function() {
debug('readable nexttick read 0');
self.read(0);
});
} else if (state.length) {
emitReadable(this, state);
}
}
}
return res;
};
Readable.prototype.addListener = Readable.prototype.on;
// pause() and resume() are remnants of the legacy readable stream API
// If the user uses them, then switch into old mode.
Readable.prototype.resume = function() {
var state = this._readableState;
if (!state.flowing) {
debug('resume');
state.flowing = true;
if (!state.reading) {
debug('resume read 0');
this.read(0);
}
resume(this, state);
}
return this;
};
function resume(stream, state) {
if (!state.resumeScheduled) {
state.resumeScheduled = true;
process.nextTick(function() {
resume_(stream, state);
});
}
}
function resume_(stream, state) {
state.resumeScheduled = false;
stream.emit('resume');
flow(stream);
if (state.flowing && !state.reading)
stream.read(0);
}
Readable.prototype.pause = function() {
debug('call pause flowing=%j', this._readableState.flowing);
if (false !== this._readableState.flowing) {
debug('pause');
this._readableState.flowing = false;
this.emit('pause');
}
return this;
};
function flow(stream) {
var state = stream._readableState;
debug('flow', state.flowing);
if (state.flowing) {
do {
var chunk = stream.read();
} while (null !== chunk && state.flowing);
}
}
// wrap an old-style stream as the async data source.
// This is *not* part of the readable stream interface.
// It is an ugly unfortunate mess of history.
Readable.prototype.wrap = function(stream) {
var state = this._readableState;
var paused = false;
var self = this;
stream.on('end', function() {
debug('wrapped end');
if (state.decoder && !state.ended) {
var chunk = state.decoder.end();
if (chunk && chunk.length)
self.push(chunk);
}
self.push(null);
});
stream.on('data', function(chunk) {
debug('wrapped data');
if (state.decoder)
chunk = state.decoder.write(chunk);
if (!chunk || !state.objectMode && !chunk.length)
return;
var ret = self.push(chunk);
if (!ret) {
paused = true;
stream.pause();
}
});
// proxy all the other methods.
// important when wrapping filters and duplexes.
for (var i in stream) {
if (util.isFunction(stream[i]) && util.isUndefined(this[i])) {
this[i] = function(method) { return function() {
return stream[method].apply(stream, arguments);
}}(i);
}
}
// proxy certain important events.
var events = ['error', 'close', 'destroy', 'pause', 'resume'];
forEach(events, function(ev) {
stream.on(ev, self.emit.bind(self, ev));
});
// when we try to consume some more bytes, simply unpause the
// underlying stream.
self._read = function(n) {
debug('wrapped _read', n);
if (paused) {
paused = false;
stream.resume();
}
};
return self;
};
// exposed for testing purposes only.
Readable._fromList = fromList;
// Pluck off n bytes from an array of buffers.
// Length is the combined lengths of all the buffers in the list.
function fromList(n, state) {
var list = state.buffer;
var length = state.length;
var stringMode = !!state.decoder;
var objectMode = !!state.objectMode;
var ret;
// nothing in the list, definitely empty.
if (list.length === 0)
return null;
if (length === 0)
ret = null;
else if (objectMode)
ret = list.shift();
else if (!n || n >= length) {
// read it all, truncate the array.
if (stringMode)
ret = list.join('');
else
ret = Buffer.concat(list, length);
list.length = 0;
} else {
// read just some of it.
if (n < list[0].length) {
// just take a part of the first list item.
// slice is the same for buffers and strings.
var buf = list[0];
ret = buf.slice(0, n);
list[0] = buf.slice(n);
} else if (n === list[0].length) {
// first list is a perfect match
ret = list.shift();
} else {
// complex case.
// we have enough to cover it, but it spans past the first buffer.
if (stringMode)
ret = '';
else
ret = new Buffer(n);
var c = 0;
for (var i = 0, l = list.length; i < l && c < n; i++) {
var buf = list[0];
var cpy = Math.min(n - c, buf.length);
if (stringMode)
ret += buf.slice(0, cpy);
else
buf.copy(ret, c, 0, cpy);
if (cpy < buf.length)
list[0] = buf.slice(cpy);
else
list.shift();
c += cpy;
}
}
}
return ret;
}
function endReadable(stream) {
var state = stream._readableState;
// If we get here before consuming all the bytes, then that is a
// bug in node. Should never happen.
if (state.length > 0)
throw new Error('endReadable called on non-empty stream');
if (!state.endEmitted) {
state.ended = true;
process.nextTick(function() {
// Check that we didn't get one last unshift.
if (!state.endEmitted && state.length === 0) {
state.endEmitted = true;
stream.readable = false;
stream.emit('end');
}
});
}
}
function forEach (xs, f) {
for (var i = 0, l = xs.length; i < l; i++) {
f(xs[i], i);
}
}
function indexOf (xs, x) {
for (var i = 0, l = xs.length; i < l; i++) {
if (xs[i] === x) return i;
}
return -1;
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(99)))
/***/ },
/* 144 */
/***/ function(module, exports, __webpack_require__) {
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// a transform stream is a readable/writable stream where you do
// something with the data. Sometimes it's called a "filter",
// but that's not a great name for it, since that implies a thing where
// some bits pass through, and others are simply ignored. (That would
// be a valid example of a transform, of course.)
//
// While the output is causally related to the input, it's not a
// necessarily symmetric or synchronous transformation. For example,
// a zlib stream might take multiple plain-text writes(), and then
// emit a single compressed chunk some time in the future.
//
// Here's how this works:
//
// The Transform stream has all the aspects of the readable and writable
// stream classes. When you write(chunk), that calls _write(chunk,cb)
// internally, and returns false if there's a lot of pending writes
// buffered up. When you call read(), that calls _read(n) until
// there's enough pending readable data buffered up.
//
// In a transform stream, the written data is placed in a buffer. When
// _read(n) is called, it transforms the queued up data, calling the
// buffered _write cb's as it consumes chunks. If consuming a single
// written chunk would result in multiple output chunks, then the first
// outputted bit calls the readcb, and subsequent chunks just go into
// the read buffer, and will cause it to emit 'readable' if necessary.
//
// This way, back-pressure is actually determined by the reading side,
// since _read has to be called to start processing a new chunk. However,
// a pathological inflate type of transform can cause excessive buffering
// here. For example, imagine a stream where every byte of input is
// interpreted as an integer from 0-255, and then results in that many
// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
// 1kb of data being output. In this case, you could write a very small
// amount of input, and end up with a very large amount of output. In
// such a pathological inflating mechanism, there'd be no way to tell
// the system to stop doing the transform. A single 4MB write could
// cause the system to run out of memory.
//
// However, even in such a pathological case, only a single written chunk
// would be consumed, and then the rest would wait (un-transformed) until
// the results of the previous transformed chunk were consumed.
module.exports = Transform;
var Duplex = __webpack_require__(142);
/*<replacement>*/
var util = __webpack_require__(178);
util.inherits = __webpack_require__(177);
/*</replacement>*/
util.inherits(Transform, Duplex);
function TransformState(options, stream) {
this.afterTransform = function(er, data) {
return afterTransform(stream, er, data);
};
this.needTransform = false;
this.transforming = false;
this.writecb = null;
this.writechunk = null;
}
function afterTransform(stream, er, data) {
var ts = stream._transformState;
ts.transforming = false;
var cb = ts.writecb;
if (!cb)
return stream.emit('error', new Error('no writecb in Transform class'));
ts.writechunk = null;
ts.writecb = null;
if (!util.isNullOrUndefined(data))
stream.push(data);
if (cb)
cb(er);
var rs = stream._readableState;
rs.reading = false;
if (rs.needReadable || rs.length < rs.highWaterMark) {
stream._read(rs.highWaterMark);
}
}
function Transform(options) {
if (!(this instanceof Transform))
return new Transform(options);
Duplex.call(this, options);
this._transformState = new TransformState(options, this);
// when the writable side finishes, then flush out anything remaining.
var stream = this;
// start out asking for a readable event once data is transformed.
this._readableState.needReadable = true;
// we have implemented the _read method, and done the other things
// that Readable wants before the first _read call, so unset the
// sync guard flag.
this._readableState.sync = false;
this.once('prefinish', function() {
if (util.isFunction(this._flush))
this._flush(function(er) {
done(stream, er);
});
else
done(stream);
});
}
Transform.prototype.push = function(chunk, encoding) {
this._transformState.needTransform = false;
return Duplex.prototype.push.call(this, chunk, encoding);
};
// This is the part where you do stuff!
// override this function in implementation classes.
// 'chunk' is an input chunk.
//
// Call `push(newChunk)` to pass along transformed output
// to the readable side. You may call 'push' zero or more times.
//
// Call `cb(err)` when you are done with this chunk. If you pass
// an error, then that'll put the hurt on the whole operation. If you
// never call cb(), then you'll never get another chunk.
Transform.prototype._transform = function(chunk, encoding, cb) {
throw new Error('not implemented');
};
Transform.prototype._write = function(chunk, encoding, cb) {
var ts = this._transformState;
ts.writecb = cb;
ts.writechunk = chunk;
ts.writeencoding = encoding;
if (!ts.transforming) {
var rs = this._readableState;
if (ts.needTransform ||
rs.needReadable ||
rs.length < rs.highWaterMark)
this._read(rs.highWaterMark);
}
};
// Doesn't matter what the args are here.
// _transform does all the work.
// That we got here means that the readable side wants more data.
Transform.prototype._read = function(n) {
var ts = this._transformState;
if (!util.isNull(ts.writechunk) && ts.writecb && !ts.transforming) {
ts.transforming = true;
this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
} else {
// mark that we need a transform, so that any data that comes in
// will get processed, now that we've asked for it.
ts.needTransform = true;
}
};
function done(stream, er) {
if (er)
return stream.emit('error', er);
// if there's nothing in the write buffer, then that means
// that nothing more will ever be provided
var ws = stream._writableState;
var ts = stream._transformState;
if (ws.length)
throw new Error('calling transform done when ws.length != 0');
if (ts.transforming)
throw new Error('calling transform done when still transforming');
return stream.push(null);
}
/***/ },
/* 145 */
/***/ function(module, exports, __webpack_require__) {
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// a passthrough stream.
// basically just the most minimal sort of Transform stream.
// Every written chunk gets output as-is.
module.exports = PassThrough;
var Transform = __webpack_require__(144);
/*<replacement>*/
var util = __webpack_require__(178);
util.inherits = __webpack_require__(177);
/*</replacement>*/
util.inherits(PassThrough, Transform);
function PassThrough(options) {
if (!(this instanceof PassThrough))
return new PassThrough(options);
Transform.call(this, options);
}
PassThrough.prototype._transform = function(chunk, encoding, cb) {
cb(null, chunk);
};
/***/ },
/* 146 */
/***/ function(module, exports, __webpack_require__) {
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
};
} else {
// old school shim for old browsers
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
TempCtor.prototype = superCtor.prototype
ctor.prototype = new TempCtor()
ctor.prototype.constructor = ctor
}
}
/***/ },
/* 147 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {var uint_max = Math.pow(2, 32);
function fixup_uint32(x) {
var ret, x_pos;
ret = x > uint_max || x < 0 ? (x_pos = Math.abs(x) % uint_max, x < 0 ? uint_max - x_pos : x_pos) : x;
return ret;
}
function scrub_vec(v) {
var i, _i, _ref;
for (i = _i = 0, _ref = v.length; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) {
v[i] = 0;
}
return false;
}
function Global() {
var i;
this.SBOX = [];
this.INV_SBOX = [];
this.SUB_MIX = (function() {
var _i, _results;
_results = [];
for (i = _i = 0; _i < 4; i = ++_i) {
_results.push([]);
}
return _results;
})();
this.INV_SUB_MIX = (function() {
var _i, _results;
_results = [];
for (i = _i = 0; _i < 4; i = ++_i) {
_results.push([]);
}
return _results;
})();
this.init();
this.RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
}
Global.prototype.init = function() {
var d, i, sx, t, x, x2, x4, x8, xi, _i;
d = (function() {
var _i, _results;
_results = [];
for (i = _i = 0; _i < 256; i = ++_i) {
if (i < 128) {
_results.push(i << 1);
} else {
_results.push((i << 1) ^ 0x11b);
}
}
return _results;
})();
x = 0;
xi = 0;
for (i = _i = 0; _i < 256; i = ++_i) {
sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);
sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;
this.SBOX[x] = sx;
this.INV_SBOX[sx] = x;
x2 = d[x];
x4 = d[x2];
x8 = d[x4];
t = (d[sx] * 0x101) ^ (sx * 0x1010100);
this.SUB_MIX[0][x] = (t << 24) | (t >>> 8);
this.SUB_MIX[1][x] = (t << 16) | (t >>> 16);
this.SUB_MIX[2][x] = (t << 8) | (t >>> 24);
this.SUB_MIX[3][x] = t;
t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);
this.INV_SUB_MIX[0][sx] = (t << 24) | (t >>> 8);
this.INV_SUB_MIX[1][sx] = (t << 16) | (t >>> 16);
this.INV_SUB_MIX[2][sx] = (t << 8) | (t >>> 24);
this.INV_SUB_MIX[3][sx] = t;
if (x === 0) {
x = xi = 1;
} else {
x = x2 ^ d[d[d[x8 ^ x2]]];
xi ^= d[d[xi]];
}
}
return true;
};
var G = new Global();
AES.blockSize = 4 * 4;
AES.prototype.blockSize = AES.blockSize;
AES.keySize = 256 / 8;
AES.prototype.keySize = AES.keySize;
AES.ivSize = AES.blockSize;
AES.prototype.ivSize = AES.ivSize;
function bufferToArray(buf) {
var len = buf.length/4;
var out = new Array(len);
var i = -1;
while (++i < len) {
out[i] = buf.readUInt32BE(i * 4);
}
return out;
}
function AES(key) {
this._key = bufferToArray(key);
this._doReset();
}
AES.prototype._doReset = function() {
var invKsRow, keySize, keyWords, ksRow, ksRows, t, _i, _j;
keyWords = this._key;
keySize = keyWords.length;
this._nRounds = keySize + 6;
ksRows = (this._nRounds + 1) * 4;
this._keySchedule = [];
for (ksRow = _i = 0; 0 <= ksRows ? _i < ksRows : _i > ksRows; ksRow = 0 <= ksRows ? ++_i : --_i) {
this._keySchedule[ksRow] = ksRow < keySize ? keyWords[ksRow] : (t = this._keySchedule[ksRow - 1], (ksRow % keySize) === 0 ? (t = (t << 8) | (t >>> 24), t = (G.SBOX[t >>> 24] << 24) | (G.SBOX[(t >>> 16) & 0xff] << 16) | (G.SBOX[(t >>> 8) & 0xff] << 8) | G.SBOX[t & 0xff], t ^= G.RCON[(ksRow / keySize) | 0] << 24) : keySize > 6 && ksRow % keySize === 4 ? t = (G.SBOX[t >>> 24] << 24) | (G.SBOX[(t >>> 16) & 0xff] << 16) | (G.SBOX[(t >>> 8) & 0xff] << 8) | G.SBOX[t & 0xff] : void 0, this._keySchedule[ksRow - keySize] ^ t);
}
this._invKeySchedule = [];
for (invKsRow = _j = 0; 0 <= ksRows ? _j < ksRows : _j > ksRows; invKsRow = 0 <= ksRows ? ++_j : --_j) {
ksRow = ksRows - invKsRow;
t = this._keySchedule[ksRow - (invKsRow % 4 ? 0 : 4)];
this._invKeySchedule[invKsRow] = invKsRow < 4 || ksRow <= 4 ? t : G.INV_SUB_MIX[0][G.SBOX[t >>> 24]] ^ G.INV_SUB_MIX[1][G.SBOX[(t >>> 16) & 0xff]] ^ G.INV_SUB_MIX[2][G.SBOX[(t >>> 8) & 0xff]] ^ G.INV_SUB_MIX[3][G.SBOX[t & 0xff]];
}
return true;
};
AES.prototype.encryptBlock = function(M) {
M = bufferToArray(new Buffer(M));
var out = this._doCryptBlock(M, this._keySchedule, G.SUB_MIX, G.SBOX);
var buf = new Buffer(16);
buf.writeUInt32BE(out[0], 0);
buf.writeUInt32BE(out[1], 4);
buf.writeUInt32BE(out[2], 8);
buf.writeUInt32BE(out[3], 12);
return buf;
};
AES.prototype.decryptBlock = function(M) {
M = bufferToArray(new Buffer(M));
var temp = [M[3], M[1]];
M[1] = temp[0];
M[3] = temp[1];
var out = this._doCryptBlock(M, this._invKeySchedule, G.INV_SUB_MIX, G.INV_SBOX);
var buf = new Buffer(16);
buf.writeUInt32BE(out[0], 0);
buf.writeUInt32BE(out[3], 4);
buf.writeUInt32BE(out[2], 8);
buf.writeUInt32BE(out[1], 12);
return buf;
};
AES.prototype.scrub = function() {
scrub_vec(this._keySchedule);
scrub_vec(this._invKeySchedule);
scrub_vec(this._key);
};
AES.prototype._doCryptBlock = function(M, keySchedule, SUB_MIX, SBOX) {
var ksRow, round, s0, s1, s2, s3, t0, t1, t2, t3, _i, _ref;
s0 = M[0] ^ keySchedule[0];
s1 = M[1] ^ keySchedule[1];
s2 = M[2] ^ keySchedule[2];
s3 = M[3] ^ keySchedule[3];
ksRow = 4;
for (round = _i = 1, _ref = this._nRounds; 1 <= _ref ? _i < _ref : _i > _ref; round = 1 <= _ref ? ++_i : --_i) {
t0 = SUB_MIX[0][s0 >>> 24] ^ SUB_MIX[1][(s1 >>> 16) & 0xff] ^ SUB_MIX[2][(s2 >>> 8) & 0xff] ^ SUB_MIX[3][s3 & 0xff] ^ keySchedule[ksRow++];
t1 = SUB_MIX[0][s1 >>> 24] ^ SUB_MIX[1][(s2 >>> 16) & 0xff] ^ SUB_MIX[2][(s3 >>> 8) & 0xff] ^ SUB_MIX[3][s0 & 0xff] ^ keySchedule[ksRow++];
t2 = SUB_MIX[0][s2 >>> 24] ^ SUB_MIX[1][(s3 >>> 16) & 0xff] ^ SUB_MIX[2][(s0 >>> 8) & 0xff] ^ SUB_MIX[3][s1 & 0xff] ^ keySchedule[ksRow++];
t3 = SUB_MIX[0][s3 >>> 24] ^ SUB_MIX[1][(s0 >>> 16) & 0xff] ^ SUB_MIX[2][(s1 >>> 8) & 0xff] ^ SUB_MIX[3][s2 & 0xff] ^ keySchedule[ksRow++];
s0 = t0;
s1 = t1;
s2 = t2;
s3 = t3;
}
t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];
return [
fixup_uint32(t0),
fixup_uint32(t1),
fixup_uint32(t2),
fixup_uint32(t3)
];
};
exports.AES = AES;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 148 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {var Transform = __webpack_require__(64).Transform;
var inherits = __webpack_require__(173);
module.exports = CipherBase;
inherits(CipherBase, Transform);
function CipherBase() {
Transform.call(this);
}
CipherBase.prototype.update = function (data, inputEnd, outputEnc) {
this.write(data, inputEnd);
var outData = new Buffer('');
var chunk;
while ((chunk = this.read())) {
outData = Buffer.concat([outData, chunk]);
}
if (outputEnc) {
outData = outData.toString(outputEnc);
}
return outData;
};
CipherBase.prototype.final = function (outputEnc) {
this.end();
var outData = new Buffer('');
var chunk;
while ((chunk = this.read())) {
outData = Buffer.concat([outData, chunk]);
}
if (outputEnc) {
outData = outData.toString(outputEnc);
}
return outData;
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 149 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {
module.exports = function (crypto, password, keyLen, ivLen) {
keyLen = keyLen/8;
ivLen = ivLen || 0;
var ki = 0;
var ii = 0;
var key = new Buffer(keyLen);
var iv = new Buffer(ivLen);
var addmd = 0;
var md, md_buf;
var i;
while (true) {
md = crypto.createHash('md5');
if(addmd++ > 0) {
md.update(md_buf);
}
md.update(password);
md_buf = md.digest();
i = 0;
if(keyLen > 0) {
while(true) {
if(keyLen === 0) {
break;
}
if(i === md_buf.length) {
break;
}
key[ki++] = md_buf[i];
keyLen--;
i++;
}
}
if(ivLen > 0 && i !== md_buf.length) {
while(true) {
if(ivLen === 0) {
break;
}
if(i === md_buf.length) {
break;
}
iv[ii++] = md_buf[i];
ivLen--;
i++;
}
}
if(keyLen === 0 && ivLen === 0) {
break;
}
}
for(i=0;i<md_buf.length;i++) {
md_buf[i] = 0;
}
return {
key: key,
iv: iv
};
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 150 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {var aes = __webpack_require__(147);
var Transform = __webpack_require__(148);
var inherits = __webpack_require__(173);
inherits(StreamCipher, Transform);
module.exports = StreamCipher;
function StreamCipher(mode, key, iv, decrypt) {
if (!(this instanceof StreamCipher)) {
return new StreamCipher(mode, key, iv);
}
Transform.call(this);
this._cipher = new aes.AES(key);
this._prev = new Buffer(iv.length);
this._cache = new Buffer('');
this._secCache = new Buffer('');
this._decrypt = decrypt;
iv.copy(this._prev);
this._mode = mode;
}
StreamCipher.prototype._transform = function (chunk, _, next) {
next(null, this._mode.encrypt(this, chunk, this._decrypt));
};
StreamCipher.prototype._flush = function (next) {
this._cipher.scrub();
next();
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 151 */
/***/ function(module, exports, __webpack_require__) {
exports.encrypt = function (self, block) {
return self._cipher.encryptBlock(block);
};
exports.decrypt = function (self, block) {
return self._cipher.decryptBlock(block);
};
/***/ },
/* 152 */
/***/ function(module, exports, __webpack_require__) {
var xor = __webpack_require__(172);
exports.encrypt = function (self, block) {
var data = xor(block, self._prev);
self._prev = self._cipher.encryptBlock(data);
return self._prev;
};
exports.decrypt = function (self, block) {
var pad = self._prev;
self._prev = block;
var out = self._cipher.decryptBlock(block);
return xor(out, pad);
};
/***/ },
/* 153 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {var xor = __webpack_require__(172);
exports.encrypt = function (self, data, decrypt) {
var out = new Buffer('');
var len;
while (data.length) {
if (self._cache.length === 0) {
self._cache = self._cipher.encryptBlock(self._prev);
self._prev = new Buffer('');
}
if (self._cache.length <= data.length) {
len = self._cache.length;
out = Buffer.concat([out, encryptStart(self, data.slice(0, len), decrypt)]);
data = data.slice(len);
} else {
out = Buffer.concat([out, encryptStart(self, data, decrypt)]);
break;
}
}
return out;
};
function encryptStart(self, data, decrypt) {
var len = data.length;
var out = xor(data, self._cache);
self._cache = self._cache.slice(len);
self._prev = Buffer.concat([self._prev, decrypt?data:out]);
return out;
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 154 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {var xor = __webpack_require__(172);
function getBlock(self) {
self._prev = self._cipher.encryptBlock(self._prev);
return self._prev;
}
exports.encrypt = function (self, chunk) {
while (self._cache.length < chunk.length) {
self._cache = Buffer.concat([self._cache, getBlock(self)]);
}
var pad = self._cache.slice(0, chunk.length);
self._cache = self._cache.slice(chunk.length);
return xor(chunk, pad);
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 155 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {var xor = __webpack_require__(172);
function getBlock(self) {
var out = self._cipher.encryptBlock(self._prev);
incr32(self._prev);
return out;
}
exports.encrypt = function (self, chunk) {
while (self._cache.length < chunk.length) {
self._cache = Buffer.concat([self._cache, getBlock(self)]);
}
var pad = self._cache.slice(0, chunk.length);
self._cache = self._cache.slice(chunk.length);
return xor(chunk, pad);
};
function incr32(iv) {
var len = iv.length;
var item;
while (len--) {
item = iv.readUInt8(len);
if (item === 255) {
iv.writeUInt8(0, len);
} else {
item++;
iv.writeUInt8(item, len);
break;
}
}
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 156 */
/***/ function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(174);
/***/ },
/* 157 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
var isES5 = (function(){
"use strict";
return this === void 0;
})();
if (isES5) {
module.exports = {
freeze: Object.freeze,
defineProperty: Object.defineProperty,
keys: Object.keys,
getPrototypeOf: Object.getPrototypeOf,
isArray: Array.isArray,
isES5: isES5
};
}
else {
var has = {}.hasOwnProperty;
var str = {}.toString;
var proto = {}.constructor.prototype;
var ObjectKeys = function ObjectKeys(o) {
var ret = [];
for (var key in o) {
if (has.call(o, key)) {
ret.push(key);
}
}
return ret;
}
var ObjectDefineProperty = function ObjectDefineProperty(o, key, desc) {
o[key] = desc.value;
return o;
}
var ObjectFreeze = function ObjectFreeze(obj) {
return obj;
}
var ObjectGetPrototypeOf = function ObjectGetPrototypeOf(obj) {
try {
return Object(obj).constructor.prototype;
}
catch (e) {
return proto;
}
}
var ArrayIsArray = function ArrayIsArray(obj) {
try {
return str.call(obj) === "[object Array]";
}
catch(e) {
return false;
}
}
module.exports = {
isArray: ArrayIsArray,
keys: ObjectKeys,
defineProperty: ObjectDefineProperty,
freeze: ObjectFreeze,
getPrototypeOf: ObjectGetPrototypeOf,
isES5: isES5
};
}
/***/ },
/* 158 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
var global = __webpack_require__(107);
var schedule;
if (typeof process !== "undefined" && process !== null &&
typeof process.cwd === "function" &&
typeof process.nextTick === "function" &&
typeof process.version === "string") {
schedule = function Promise$_Scheduler(fn) {
process.nextTick(fn);
};
}
else if ((typeof global.MutationObserver === "function" ||
typeof global.WebkitMutationObserver === "function" ||
typeof global.WebKitMutationObserver === "function") &&
typeof document !== "undefined" &&
typeof document.createElement === "function") {
schedule = (function(){
var MutationObserver = global.MutationObserver ||
global.WebkitMutationObserver ||
global.WebKitMutationObserver;
var div = document.createElement("div");
var queuedFn = void 0;
var observer = new MutationObserver(
function Promise$_Scheduler() {
var fn = queuedFn;
queuedFn = void 0;
fn();
}
);
observer.observe(div, {
attributes: true
});
return function Promise$_Scheduler(fn) {
queuedFn = fn;
div.setAttribute("class", "foo");
};
})();
}
else if (typeof global.postMessage === "function" &&
typeof global.importScripts !== "function" &&
typeof global.addEventListener === "function" &&
typeof global.removeEventListener === "function") {
var MESSAGE_KEY = "bluebird_message_key_" + Math.random();
schedule = (function(){
var queuedFn = void 0;
function Promise$_Scheduler(e) {
if (e.source === global &&
e.data === MESSAGE_KEY) {
var fn = queuedFn;
queuedFn = void 0;
fn();
}
}
global.addEventListener("message", Promise$_Scheduler, false);
return function Promise$_Scheduler(fn) {
queuedFn = fn;
global.postMessage(
MESSAGE_KEY, "*"
);
};
})();
}
else if (typeof global.MessageChannel === "function") {
schedule = (function(){
var queuedFn = void 0;
var channel = new global.MessageChannel();
channel.port1.onmessage = function Promise$_Scheduler() {
var fn = queuedFn;
queuedFn = void 0;
fn();
};
return function Promise$_Scheduler(fn) {
queuedFn = fn;
channel.port2.postMessage(null);
};
})();
}
else if (global.setTimeout) {
schedule = function Promise$_Scheduler(fn) {
setTimeout(fn, 4);
};
}
else {
schedule = function Promise$_Scheduler(fn) {
fn();
};
}
module.exports = schedule;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(99)))
/***/ },
/* 159 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
function arrayCopy(src, srcIndex, dst, dstIndex, len) {
for (var j = 0; j < len; ++j) {
dst[j + dstIndex] = src[j + srcIndex];
}
}
function pow2AtLeast(n) {
n = n >>> 0;
n = n - 1;
n = n | (n >> 1);
n = n | (n >> 2);
n = n | (n >> 4);
n = n | (n >> 8);
n = n | (n >> 16);
return n + 1;
}
function getCapacity(capacity) {
if (typeof capacity !== "number") return 16;
return pow2AtLeast(
Math.min(
Math.max(16, capacity), 1073741824)
);
}
function Queue(capacity) {
this._capacity = getCapacity(capacity);
this._length = 0;
this._front = 0;
this._makeCapacity();
}
Queue.prototype._willBeOverCapacity =
function Queue$_willBeOverCapacity(size) {
return this._capacity < size;
};
Queue.prototype._pushOne = function Queue$_pushOne(arg) {
var length = this.length();
this._checkCapacity(length + 1);
var i = (this._front + length) & (this._capacity - 1);
this[i] = arg;
this._length = length + 1;
};
Queue.prototype.push = function Queue$push(fn, receiver, arg) {
var length = this.length() + 3;
if (this._willBeOverCapacity(length)) {
this._pushOne(fn);
this._pushOne(receiver);
this._pushOne(arg);
return;
}
var j = this._front + length - 3;
this._checkCapacity(length);
var wrapMask = this._capacity - 1;
this[(j + 0) & wrapMask] = fn;
this[(j + 1) & wrapMask] = receiver;
this[(j + 2) & wrapMask] = arg;
this._length = length;
};
Queue.prototype.shift = function Queue$shift() {
var front = this._front,
ret = this[front];
this[front] = void 0;
this._front = (front + 1) & (this._capacity - 1);
this._length--;
return ret;
};
Queue.prototype.length = function Queue$length() {
return this._length;
};
Queue.prototype._makeCapacity = function Queue$_makeCapacity() {
var len = this._capacity;
for (var i = 0; i < len; ++i) {
this[i] = void 0;
}
};
Queue.prototype._checkCapacity = function Queue$_checkCapacity(size) {
if (this._capacity < size) {
this._resizeTo(this._capacity << 3);
}
};
Queue.prototype._resizeTo = function Queue$_resizeTo(capacity) {
var oldFront = this._front;
var oldCapacity = this._capacity;
var oldQueue = new Array(oldCapacity);
var length = this.length();
arrayCopy(this, 0, oldQueue, 0, oldCapacity);
this._capacity = capacity;
this._makeCapacity();
this._front = 0;
if (oldFront + length <= oldCapacity) {
arrayCopy(oldQueue, oldFront, this, 0, length);
}
else { var lengthBeforeWrapping =
length - ((oldFront + length) & (oldCapacity - 1));
arrayCopy(oldQueue, oldFront, this, 0, lengthBeforeWrapping);
arrayCopy(oldQueue, 0, this, lengthBeforeWrapping,
length - lengthBeforeWrapping);
}
};
module.exports = Queue;
/***/ },
/* 160 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function (PromiseArray) {
var util = __webpack_require__(108);
var RangeError = __webpack_require__(110).RangeError;
var inherits = util.inherits;
var isArray = util.isArray;
function SomePromiseArray(values, boundTo) {
this.constructor$(values, boundTo);
this._howMany = 0;
this._unwrap = false;
this._initialized = false;
}
inherits(SomePromiseArray, PromiseArray);
SomePromiseArray.prototype._init = function SomePromiseArray$_init() {
if (!this._initialized) {
return;
}
if (this._howMany === 0) {
this._resolve([]);
return;
}
this._init$(void 0, -2);
var isArrayResolved = isArray(this._values);
this._holes = isArrayResolved ? this._values.length - this.length() : 0;
if (!this._isResolved() &&
isArrayResolved &&
this._howMany > this._canPossiblyFulfill()) {
var message = "(Promise.some) input array contains less than " +
this._howMany + " promises";
this._reject(new RangeError(message));
}
};
SomePromiseArray.prototype.init = function SomePromiseArray$init() {
this._initialized = true;
this._init();
};
SomePromiseArray.prototype.setUnwrap = function SomePromiseArray$setUnwrap() {
this._unwrap = true;
};
SomePromiseArray.prototype.howMany = function SomePromiseArray$howMany() {
return this._howMany;
};
SomePromiseArray.prototype.setHowMany =
function SomePromiseArray$setHowMany(count) {
if (this._isResolved()) return;
this._howMany = count;
};
SomePromiseArray.prototype._promiseFulfilled =
function SomePromiseArray$_promiseFulfilled(value) {
if (this._isResolved()) return;
this._addFulfilled(value);
if (this._fulfilled() === this.howMany()) {
this._values.length = this.howMany();
if (this.howMany() === 1 && this._unwrap) {
this._resolve(this._values[0]);
}
else {
this._resolve(this._values);
}
}
};
SomePromiseArray.prototype._promiseRejected =
function SomePromiseArray$_promiseRejected(reason) {
if (this._isResolved()) return;
this._addRejected(reason);
if (this.howMany() > this._canPossiblyFulfill()) {
if (this._values.length === this.length()) {
this._reject([]);
}
else {
this._reject(this._values.slice(this.length() + this._holes));
}
}
};
SomePromiseArray.prototype._fulfilled = function SomePromiseArray$_fulfilled() {
return this._totalResolved;
};
SomePromiseArray.prototype._rejected = function SomePromiseArray$_rejected() {
return this._values.length - this.length() - this._holes;
};
SomePromiseArray.prototype._addRejected =
function SomePromiseArray$_addRejected(reason) {
this._values.push(reason);
};
SomePromiseArray.prototype._addFulfilled =
function SomePromiseArray$_addFulfilled(value) {
this._values[this._totalResolved++] = value;
};
SomePromiseArray.prototype._canPossiblyFulfill =
function SomePromiseArray$_canPossiblyFulfill() {
return this.length() - this._rejected();
};
return SomePromiseArray;
};
/***/ },
/* 161 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise, INTERNAL) {
var errors = __webpack_require__(110);
var TypeError = errors.TypeError;
var util = __webpack_require__(108);
var isArray = util.isArray;
var errorObj = util.errorObj;
var tryCatch1 = util.tryCatch1;
var yieldHandlers = [];
function promiseFromYieldHandler(value) {
var _yieldHandlers = yieldHandlers;
var _errorObj = errorObj;
var _Promise = Promise;
var len = _yieldHandlers.length;
for (var i = 0; i < len; ++i) {
var result = tryCatch1(_yieldHandlers[i], void 0, value);
if (result === _errorObj) {
return _Promise.reject(_errorObj.e);
}
var maybePromise = _Promise._cast(result,
promiseFromYieldHandler, void 0);
if (maybePromise instanceof _Promise) return maybePromise;
}
return null;
}
function PromiseSpawn(generatorFunction, receiver) {
var promise = this._promise = new Promise(INTERNAL);
promise._setTrace(void 0);
this._generatorFunction = generatorFunction;
this._receiver = receiver;
this._generator = void 0;
}
PromiseSpawn.prototype.promise = function PromiseSpawn$promise() {
return this._promise;
};
PromiseSpawn.prototype._run = function PromiseSpawn$_run() {
this._generator = this._generatorFunction.call(this._receiver);
this._receiver =
this._generatorFunction = void 0;
this._next(void 0);
};
PromiseSpawn.prototype._continue = function PromiseSpawn$_continue(result) {
if (result === errorObj) {
this._generator = void 0;
var trace = errors.canAttach(result.e)
? result.e : new Error(result.e + "");
this._promise._attachExtraTrace(trace);
this._promise._reject(result.e, trace);
return;
}
var value = result.value;
if (result.done === true) {
this._generator = void 0;
if (!this._promise._tryFollow(value)) {
this._promise._fulfill(value);
}
}
else {
var maybePromise = Promise._cast(value, PromiseSpawn$_continue, void 0);
if (!(maybePromise instanceof Promise)) {
if (isArray(maybePromise)) {
maybePromise = Promise.all(maybePromise);
}
else {
maybePromise = promiseFromYieldHandler(maybePromise);
}
if (maybePromise === null) {
this._throw(new TypeError("A value was yielded that could not be treated as a promise"));
return;
}
}
maybePromise._then(
this._next,
this._throw,
void 0,
this,
null
);
}
};
PromiseSpawn.prototype._throw = function PromiseSpawn$_throw(reason) {
if (errors.canAttach(reason))
this._promise._attachExtraTrace(reason);
this._continue(
tryCatch1(this._generator["throw"], this._generator, reason)
);
};
PromiseSpawn.prototype._next = function PromiseSpawn$_next(value) {
this._continue(
tryCatch1(this._generator.next, this._generator, value)
);
};
PromiseSpawn.addYieldHandler = function PromiseSpawn$AddYieldHandler(fn) {
if (typeof fn !== "function") throw new TypeError("fn must be a function");
yieldHandlers.push(fn);
};
return PromiseSpawn;
};
/***/ },
/* 162 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise, PromiseArray) {
var util = __webpack_require__(108);
var inherits = util.inherits;
var es5 = __webpack_require__(157);
function PropertiesPromiseArray(obj, boundTo) {
var keys = es5.keys(obj);
var values = new Array(keys.length);
for (var i = 0, len = values.length; i < len; ++i) {
values[i] = obj[keys[i]];
}
this.constructor$(values, boundTo);
if (!this._isResolved()) {
for (var i = 0, len = keys.length; i < len; ++i) {
values.push(keys[i]);
}
}
}
inherits(PropertiesPromiseArray, PromiseArray);
PropertiesPromiseArray.prototype._init =
function PropertiesPromiseArray$_init() {
this._init$(void 0, -3) ;
};
PropertiesPromiseArray.prototype._promiseFulfilled =
function PropertiesPromiseArray$_promiseFulfilled(value, index) {
if (this._isResolved()) return;
this._values[index] = value;
var totalResolved = ++this._totalResolved;
if (totalResolved >= this._length) {
var val = {};
var keyOffset = this.length();
for (var i = 0, len = this.length(); i < len; ++i) {
val[this._values[i + keyOffset]] = this._values[i];
}
this._resolve(val);
}
};
PropertiesPromiseArray.prototype._promiseProgressed =
function PropertiesPromiseArray$_promiseProgressed(value, index) {
if (this._isResolved()) return;
this._promise._progress({
key: this._values[index + this.length()],
value: value
});
};
PromiseArray.PropertiesPromiseArray = PropertiesPromiseArray;
return PropertiesPromiseArray;
};
/***/ },
/* 163 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2014 Petka Antonov
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
"use strict";
module.exports = function(Promise, PromiseArray) {
var PromiseInspection = Promise.PromiseInspection;
var util = __webpack_require__(108);
var inherits = util.inherits;
function SettledPromiseArray(values, boundTo) {
this.constructor$(values, boundTo);
}
inherits(SettledPromiseArray, PromiseArray);
SettledPromiseArray.prototype._promiseResolved =
function SettledPromiseArray$_promiseResolved(index, inspection) {
this._values[index] = inspection;
var totalResolved = ++this._totalResolved;
if (totalResolved >= this._length) {
this._resolve(this._values);
}
};
SettledPromiseArray.prototype._promiseFulfilled =
function SettledPromiseArray$_promiseFulfilled(value, index) {
if (this._isResolved()) return;
var ret = new PromiseInspection();
ret._bitField = 268435456;
ret._settledValue = value;
this._promiseResolved(index, ret);
};
SettledPromiseArray.prototype._promiseRejected =
function SettledPromiseArray$_promiseRejected(reason, index) {
if (this._isResolved()) return;
var ret = new PromiseInspection();
ret._bitField = 134217728;
ret._settledValue = reason;
this._promiseResolved(index, ret);
};
return SettledPromiseArray;
};
/***/ },
/* 164 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var config = {
instrument: false
};
function configure(name, value) {
if (arguments.length === 2) {
config[name] = value;
} else {
return config[name];
}
}
exports.config = config;
exports.configure = configure;
/***/ },
/* 165 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
function objectOrFunction(x) {
return isFunction(x) || (typeof x === "object" && x !== null);
}
function isFunction(x) {
return typeof x === "function";
}
function isArray(x) {
return Object.prototype.toString.call(x) === "[object Array]";
}
// Date.now is not available in browsers < IE9
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/now#Compatibility
var now = Date.now || function() { return new Date().getTime(); };
exports.objectOrFunction = objectOrFunction;
exports.isFunction = isFunction;
exports.isArray = isArray;
exports.now = now;
/***/ },
/* 166 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
/* global toString */
var isArray = __webpack_require__(165).isArray;
var isFunction = __webpack_require__(165).isFunction;
/**
Returns a promise that is fulfilled when all the given promises have been
fulfilled, or rejected if any of them become rejected. The return promise
is fulfilled with an array that gives all the values in the order they were
passed in the `promises` array argument.
Example:
```javascript
var promise1 = RSVP.resolve(1);
var promise2 = RSVP.resolve(2);
var promise3 = RSVP.resolve(3);
var promises = [ promise1, promise2, promise3 ];
RSVP.all(promises).then(function(array){
// The array here would be [ 1, 2, 3 ];
});
```
If any of the `promises` given to `RSVP.all` are rejected, the first promise
that is rejected will be given as an argument to the returned promises's
rejection handler. For example:
Example:
```javascript
var promise1 = RSVP.resolve(1);
var promise2 = RSVP.reject(new Error("2"));
var promise3 = RSVP.reject(new Error("3"));
var promises = [ promise1, promise2, promise3 ];
RSVP.all(promises).then(function(array){
// Code here never runs because there are rejected promises!
}, function(error) {
// error.message === "2"
});
```
@method all
@for RSVP
@param {Array} promises
@param {String} label
@return {Promise} promise that is fulfilled when all `promises` have been
fulfilled, or rejected if any of them become rejected.
*/
function all(promises) {
/*jshint validthis:true */
var Promise = this;
if (!isArray(promises)) {
throw new TypeError('You must pass an array to all.');
}
return new Promise(function(resolve, reject) {
var results = [], remaining = promises.length,
promise;
if (remaining === 0) {
resolve([]);
}
function resolver(index) {
return function(value) {
resolveAll(index, value);
};
}
function resolveAll(index, value) {
results[index] = value;
if (--remaining === 0) {
resolve(results);
}
}
for (var i = 0; i < promises.length; i++) {
promise = promises[i];
if (promise && isFunction(promise.then)) {
promise.then(resolver(i), reject);
} else {
resolveAll(i, promise);
}
}
});
}
exports.all = all;
/***/ },
/* 167 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
/* global toString */
var isArray = __webpack_require__(165).isArray;
/**
`RSVP.race` allows you to watch a series of promises and act as soon as the
first promise given to the `promises` argument fulfills or rejects.
Example:
```javascript
var promise1 = new RSVP.Promise(function(resolve, reject){
setTimeout(function(){
resolve("promise 1");
}, 200);
});
var promise2 = new RSVP.Promise(function(resolve, reject){
setTimeout(function(){
resolve("promise 2");
}, 100);
});
RSVP.race([promise1, promise2]).then(function(result){
// result === "promise 2" because it was resolved before promise1
// was resolved.
});
```
`RSVP.race` is deterministic in that only the state of the first completed
promise matters. For example, even if other promises given to the `promises`
array argument are resolved, but the first completed promise has become
rejected before the other promises became fulfilled, the returned promise
will become rejected:
```javascript
var promise1 = new RSVP.Promise(function(resolve, reject){
setTimeout(function(){
resolve("promise 1");
}, 200);
});
var promise2 = new RSVP.Promise(function(resolve, reject){
setTimeout(function(){
reject(new Error("promise 2"));
}, 100);
});
RSVP.race([promise1, promise2]).then(function(result){
// Code here never runs because there are rejected promises!
}, function(reason){
// reason.message === "promise2" because promise 2 became rejected before
// promise 1 became fulfilled
});
```
@method race
@for RSVP
@param {Array} promises array of promises to observe
@param {String} label optional string for describing the promise returned.
Useful for tooling.
@return {Promise} a promise that becomes fulfilled with the value the first
completed promises is resolved with if the first completed promise was
fulfilled, or rejected with the reason that the first completed promise
was rejected with.
*/
function race(promises) {
/*jshint validthis:true */
var Promise = this;
if (!isArray(promises)) {
throw new TypeError('You must pass an array to race.');
}
return new Promise(function(resolve, reject) {
var results = [], promise;
for (var i = 0; i < promises.length; i++) {
promise = promises[i];
if (promise && typeof promise.then === 'function') {
promise.then(resolve, reject);
} else {
resolve(promise);
}
}
});
}
exports.race = race;
/***/ },
/* 168 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
function resolve(value) {
/*jshint validthis:true */
if (value && typeof value === 'object' && value.constructor === this) {
return value;
}
var Promise = this;
return new Promise(function(resolve) {
resolve(value);
});
}
exports.resolve = resolve;
/***/ },
/* 169 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
/**
`RSVP.reject` returns a promise that will become rejected with the passed
`reason`. `RSVP.reject` is essentially shorthand for the following:
```javascript
var promise = new RSVP.Promise(function(resolve, reject){
reject(new Error('WHOOPS'));
});
promise.then(function(value){
// Code here doesn't run because the promise is rejected!
}, function(reason){
// reason.message === 'WHOOPS'
});
```
Instead of writing the above, your code now simply becomes the following:
```javascript
var promise = RSVP.reject(new Error('WHOOPS'));
promise.then(function(value){
// Code here doesn't run because the promise is rejected!
}, function(reason){
// reason.message === 'WHOOPS'
});
```
@method reject
@for RSVP
@param {Any} reason value that the returned promise will be rejected with.
@param {String} label optional string for identifying the returned promise.
Useful for tooling.
@return {Promise} a promise that will become rejected with the given
`reason`.
*/
function reject(reason) {
/*jshint validthis:true */
var Promise = this;
return new Promise(function (resolve, reject) {
reject(reason);
});
}
exports.reject = reject;
/***/ },
/* 170 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(global, process) {"use strict";
var browserGlobal = (typeof window !== 'undefined') ? window : {};
var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
var local = (typeof global !== 'undefined') ? global : (this === undefined? window:this);
// node
function useNextTick() {
return function() {
process.nextTick(flush);
};
}
function useMutationObserver() {
var iterations = 0;
var observer = new BrowserMutationObserver(flush);
var node = document.createTextNode('');
observer.observe(node, { characterData: true });
return function() {
node.data = (iterations = ++iterations % 2);
};
}
function useSetTimeout() {
return function() {
local.setTimeout(flush, 1);
};
}
var queue = [];
function flush() {
for (var i = 0; i < queue.length; i++) {
var tuple = queue[i];
var callback = tuple[0], arg = tuple[1];
callback(arg);
}
queue = [];
}
var scheduleFlush;
// Decide what async method to use to triggering processing of queued callbacks:
if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
scheduleFlush = useNextTick();
} else if (BrowserMutationObserver) {
scheduleFlush = useMutationObserver();
} else {
scheduleFlush = useSetTimeout();
}
function asap(callback, arg) {
var length = queue.push([callback, arg]);
if (length === 1) {
// If length is 1, that means that we need to schedule an async flush.
// If additional callbacks are queued before the queue is flushed, they
// will be processed by this flush that we are scheduling.
scheduleFlush();
}
}
exports.asap = asap;
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(99)))
/***/ },
/* 171 */
/***/ function(module, exports, __webpack_require__) {
/* (ignored) */
/***/ },
/* 172 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {module.exports = xor;
function xor(a, b) {
var len = Math.min(a.length, b.length);
var out = new Buffer(len);
var i = -1;
while (++i < len) {
out.writeUInt8(a[i] ^ b[i], i);
}
return out;
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 173 */
/***/ function(module, exports, __webpack_require__) {
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
};
} else {
// old school shim for old browsers
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
TempCtor.prototype = superCtor.prototype
ctor.prototype = new TempCtor()
ctor.prototype.constructor = ctor
}
}
/***/ },
/* 174 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**!
* agentkeepalive - lib/agent.js
*
* refer:
* * @atimb "Real keep-alive HTTP agent": https://gist.github.com/2963672
* * https://github.com/joyent/node/blob/master/lib/http.js
* * https://github.com/joyent/node/blob/master/lib/_http_agent.js
*
* Copyright(c) 2012 - 2013 fengmk2 <fengmk2@gmail.com>
* MIT Licensed
*/
"use strict";
/**
* Module dependencies.
*/
var http = __webpack_require__(30);
var https = __webpack_require__(46);
var util = __webpack_require__(79);
var debug;
if (process.env.NODE_DEBUG && /agentkeepalive/.test(process.env.NODE_DEBUG)) {
debug = function (x) {
console.error.apply(console, arguments);
};
} else {
debug = function () { };
}
var OriginalAgent = http.Agent;
if (process.version.indexOf('v0.8.') === 0 || process.version.indexOf('v0.10.') === 0) {
OriginalAgent = __webpack_require__(179).Agent;
debug('%s use _http_agent', process.version);
}
function Agent(options) {
options = options || {};
options.keepAlive = options.keepAlive !== false;
options.keepAliveMsecs = options.keepAliveMsecs || options.maxKeepAliveTime;
OriginalAgent.call(this, options);
var self = this;
// max requests per keepalive socket, default is 0, no limit.
self.maxKeepAliveRequests = parseInt(options.maxKeepAliveRequests, 10) || 0;
// max keep alive time, default 60 seconds.
// if set `keepAliveMsecs = 0`, will disable keepalive feature.
self.createSocketCount = 0;
self.timeoutSocketCount = 0;
self.requestFinishedCount = 0;
// override the `free` event listener
self.removeAllListeners('free');
self.on('free', function (socket, options) {
self.requestFinishedCount++;
socket._requestCount++;
var name = self.getName(options);
debug('agent.on(free)', name);
if (!self.isDestroyed(socket) &&
self.requests[name] && self.requests[name].length) {
self.requests[name].shift().onSocket(socket);
if (self.requests[name].length === 0) {
// don't leak
delete self.requests[name];
}
} else {
// If there are no pending requests, then put it in
// the freeSockets pool, but only if we're allowed to do so.
var req = socket._httpMessage;
if (req &&
req.shouldKeepAlive &&
!self.isDestroyed(socket) &&
self.options.keepAlive) {
var freeSockets = self.freeSockets[name];
var freeLen = freeSockets ? freeSockets.length : 0;
var count = freeLen;
if (self.sockets[name])
count += self.sockets[name].length;
if (count >= self.maxSockets || freeLen >= self.maxFreeSockets) {
self.removeSocket(socket, options);
socket.destroy();
} else {
freeSockets = freeSockets || [];
self.freeSockets[name] = freeSockets;
socket.setKeepAlive(true, self.keepAliveMsecs);
socket.unref && socket.unref();
socket._httpMessage = null;
self.removeSocket(socket, options);
freeSockets.push(socket);
// Avoid duplicitive timeout events by removing timeout listeners set on
// socket by previous requests. node does not do this normally because it
// assumes sockets are too short-lived for it to matter. It becomes a
// problem when sockets are being reused. Steps are being taken to fix
// this issue upstream in node v0.10.0.
//
// See https://github.com/joyent/node/commit/451ff1540ab536237e8d751d241d7fc3391a4087
if (self.keepAliveMsecs && socket._events && Array.isArray(socket._events.timeout)) {
socket.removeAllListeners('timeout');
// Restore the socket's setTimeout() that was remove as collateral
// damage.
socket.setTimeout(self.keepAliveMsecs, socket._maxKeepAliveTimeout);
}
}
} else {
self.removeSocket(socket, options);
socket.destroy();
}
}
});
}
util.inherits(Agent, OriginalAgent);
module.exports = Agent;
Agent.prototype.createSocket = function (req, options) {
var self = this;
var socket = OriginalAgent.prototype.createSocket.call(this, req, options);
socket._requestCount = 0;
if (self.keepAliveMsecs) {
socket._maxKeepAliveTimeout = function () {
debug('maxKeepAliveTimeout, socket destroy()');
socket.destroy();
self.timeoutSocketCount++;
};
socket.setTimeout(self.keepAliveMsecs, socket._maxKeepAliveTimeout);
// Disable Nagle's algorithm: http://blog.caustik.com/2012/04/08/scaling-node-js-to-100k-concurrent-connections/
socket.setNoDelay(true);
}
this.createSocketCount++;
return socket;
};
Agent.prototype.removeSocket = function (s, options) {
OriginalAgent.prototype.removeSocket.call(this, s, options);
var name = this.getName(options);
debug('removeSocket', name, 'destroyed:', this.isDestroyed(s));
if (this.isDestroyed(s) && this.freeSockets[name]) {
var index = this.freeSockets[name].indexOf(s);
if (index !== -1) {
this.freeSockets[name].splice(index, 1);
if (this.freeSockets[name].length === 0) {
// don't leak
delete this.freeSockets[name];
}
}
}
};
function HttpsAgent(options) {
Agent.call(this, options);
this.defaultPort = 443;
this.protocol = 'https:';
}
util.inherits(HttpsAgent, Agent);
HttpsAgent.prototype.createConnection = https.globalAgent.createConnection;
HttpsAgent.prototype.getName = function(options) {
var name = Agent.prototype.getName.call(this, options);
name += ':';
if (options.ca)
name += options.ca;
name += ':';
if (options.cert)
name += options.cert;
name += ':';
if (options.ciphers)
name += options.ciphers;
name += ':';
if (options.key)
name += options.key;
name += ':';
if (options.pfx)
name += options.pfx;
name += ':';
if (options.rejectUnauthorized !== undefined)
name += options.rejectUnauthorized;
return name;
};
Agent.HttpsAgent = HttpsAgent;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(99)))
/***/ },
/* 175 */
/***/ function(module, exports, __webpack_require__) {
module.exports = Array.isArray || function (arr) {
return Object.prototype.toString.call(arr) == '[object Array]';
};
/***/ },
/* 176 */
/***/ function(module, exports, __webpack_require__) {
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var Buffer = __webpack_require__(47).Buffer;
var isBufferEncoding = Buffer.isEncoding
|| function(encoding) {
switch (encoding && encoding.toLowerCase()) {
case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
default: return false;
}
}
function assertEncoding(encoding) {
if (encoding && !isBufferEncoding(encoding)) {
throw new Error('Unknown encoding: ' + encoding);
}
}
// StringDecoder provides an interface for efficiently splitting a series of
// buffers into a series of JS strings without breaking apart multi-byte
// characters. CESU-8 is handled as part of the UTF-8 encoding.
//
// @TODO Handling all encodings inside a single object makes it very difficult
// to reason about this code, so it should be split up in the future.
// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
// points as used by CESU-8.
var StringDecoder = exports.StringDecoder = function(encoding) {
this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
assertEncoding(encoding);
switch (this.encoding) {
case 'utf8':
// CESU-8 represents each of Surrogate Pair by 3-bytes
this.surrogateSize = 3;
break;
case 'ucs2':
case 'utf16le':
// UTF-16 represents each of Surrogate Pair by 2-bytes
this.surrogateSize = 2;
this.detectIncompleteChar = utf16DetectIncompleteChar;
break;
case 'base64':
// Base-64 stores 3 bytes in 4 chars, and pads the remainder.
this.surrogateSize = 3;
this.detectIncompleteChar = base64DetectIncompleteChar;
break;
default:
this.write = passThroughWrite;
return;
}
// Enough space to store all bytes of a single character. UTF-8 needs 4
// bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
this.charBuffer = new Buffer(6);
// Number of bytes received for the current incomplete multi-byte character.
this.charReceived = 0;
// Number of bytes expected for the current incomplete multi-byte character.
this.charLength = 0;
};
// write decodes the given buffer and returns it as JS string that is
// guaranteed to not contain any partial multi-byte characters. Any partial
// character found at the end of the buffer is buffered up, and will be
// returned when calling write again with the remaining bytes.
//
// Note: Converting a Buffer containing an orphan surrogate to a String
// currently works, but converting a String to a Buffer (via `new Buffer`, or
// Buffer#write) will replace incomplete surrogates with the unicode
// replacement character. See https://codereview.chromium.org/121173009/ .
StringDecoder.prototype.write = function(buffer) {
var charStr = '';
// if our last write ended with an incomplete multibyte character
while (this.charLength) {
// determine how many remaining bytes this buffer has to offer for this char
var available = (buffer.length >= this.charLength - this.charReceived) ?
this.charLength - this.charReceived :
buffer.length;
// add the new bytes to the char buffer
buffer.copy(this.charBuffer, this.charReceived, 0, available);
this.charReceived += available;
if (this.charReceived < this.charLength) {
// still not enough chars in this buffer? wait for more ...
return '';
}
// remove bytes belonging to the current character from the buffer
buffer = buffer.slice(available, buffer.length);
// get the character that was split
charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
// CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
var charCode = charStr.charCodeAt(charStr.length - 1);
if (charCode >= 0xD800 && charCode <= 0xDBFF) {
this.charLength += this.surrogateSize;
charStr = '';
continue;
}
this.charReceived = this.charLength = 0;
// if there are no more bytes in this buffer, just emit our char
if (buffer.length === 0) {
return charStr;
}
break;
}
// determine and set charLength / charReceived
this.detectIncompleteChar(buffer);
var end = buffer.length;
if (this.charLength) {
// buffer the incomplete character bytes we got
buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
end -= this.charReceived;
}
charStr += buffer.toString(this.encoding, 0, end);
var end = charStr.length - 1;
var charCode = charStr.charCodeAt(end);
// CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
if (charCode >= 0xD800 && charCode <= 0xDBFF) {
var size = this.surrogateSize;
this.charLength += size;
this.charReceived += size;
this.charBuffer.copy(this.charBuffer, size, 0, size);
buffer.copy(this.charBuffer, 0, 0, size);
return charStr.substring(0, end);
}
// or just emit the charStr
return charStr;
};
// detectIncompleteChar determines if there is an incomplete UTF-8 character at
// the end of the given buffer. If so, it sets this.charLength to the byte
// length that character, and sets this.charReceived to the number of bytes
// that are available for this character.
StringDecoder.prototype.detectIncompleteChar = function(buffer) {
// determine how many bytes we have to check at the end of this buffer
var i = (buffer.length >= 3) ? 3 : buffer.length;
// Figure out if one of the last i bytes of our buffer announces an
// incomplete char.
for (; i > 0; i--) {
var c = buffer[buffer.length - i];
// See http://en.wikipedia.org/wiki/UTF-8#Description
// 110XXXXX
if (i == 1 && c >> 5 == 0x06) {
this.charLength = 2;
break;
}
// 1110XXXX
if (i <= 2 && c >> 4 == 0x0E) {
this.charLength = 3;
break;
}
// 11110XXX
if (i <= 3 && c >> 3 == 0x1E) {
this.charLength = 4;
break;
}
}
this.charReceived = i;
};
StringDecoder.prototype.end = function(buffer) {
var res = '';
if (buffer && buffer.length)
res = this.write(buffer);
if (this.charReceived) {
var cr = this.charReceived;
var buf = this.charBuffer;
var enc = this.encoding;
res += buf.slice(0, cr).toString(enc);
}
return res;
};
function passThroughWrite(buffer) {
return buffer.toString(this.encoding);
}
function utf16DetectIncompleteChar(buffer) {
this.charReceived = buffer.length % 2;
this.charLength = this.charReceived ? 2 : 0;
}
function base64DetectIncompleteChar(buffer) {
this.charReceived = buffer.length % 3;
this.charLength = this.charReceived ? 3 : 0;
}
/***/ },
/* 177 */
/***/ function(module, exports, __webpack_require__) {
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
};
} else {
// old school shim for old browsers
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
TempCtor.prototype = superCtor.prototype
ctor.prototype = new TempCtor()
ctor.prototype.constructor = ctor
}
}
/***/ },
/* 178 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// NOTE: These type checking functions intentionally don't use `instanceof`
// because it is fragile and can be easily faked with `Object.create()`.
function isArray(ar) {
return Array.isArray(ar);
}
exports.isArray = isArray;
function isBoolean(arg) {
return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;
function isNull(arg) {
return arg === null;
}
exports.isNull = isNull;
function isNullOrUndefined(arg) {
return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;
function isNumber(arg) {
return typeof arg === 'number';
}
exports.isNumber = isNumber;
function isString(arg) {
return typeof arg === 'string';
}
exports.isString = isString;
function isSymbol(arg) {
return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;
function isUndefined(arg) {
return arg === void 0;
}
exports.isUndefined = isUndefined;
function isRegExp(re) {
return isObject(re) && objectToString(re) === '[object RegExp]';
}
exports.isRegExp = isRegExp;
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;
function isDate(d) {
return isObject(d) && objectToString(d) === '[object Date]';
}
exports.isDate = isDate;
function isError(e) {
return isObject(e) &&
(objectToString(e) === '[object Error]' || e instanceof Error);
}
exports.isError = isError;
function isFunction(arg) {
return typeof arg === 'function';
}
exports.isFunction = isFunction;
function isPrimitive(arg) {
return arg === null ||
typeof arg === 'boolean' ||
typeof arg === 'number' ||
typeof arg === 'string' ||
typeof arg === 'symbol' || // ES6 symbol
typeof arg === 'undefined';
}
exports.isPrimitive = isPrimitive;
function isBuffer(arg) {
return Buffer.isBuffer(arg);
}
exports.isBuffer = isBuffer;
function objectToString(o) {
return Object.prototype.toString.call(o);
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(47).Buffer))
/***/ },
/* 179 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// copy from https://github.com/joyent/node/blob/master/lib/_http_agent.js
var net = __webpack_require__(!(function webpackMissingModule() { var e = new Error("Cannot find module \"net\""); e.code = 'MODULE_NOT_FOUND'; throw e; }()));
var url = __webpack_require__(31);
var util = __webpack_require__(79);
var EventEmitter = __webpack_require__(44).EventEmitter;
// var ClientRequest = require('_http_client').ClientRequest;
// var debug = util.debuglog('http');
var ClientRequest = __webpack_require__(30).ClientRequest;
var debug;
if (process.env.NODE_DEBUG && /agentkeepalive/.test(process.env.NODE_DEBUG)) {
debug = function (x) {
console.error.apply(console, arguments);
};
} else {
debug = function () { };
}
// New Agent code.
// The largest departure from the previous implementation is that
// an Agent instance holds connections for a variable number of host:ports.
// Surprisingly, this is still API compatible as far as third parties are
// concerned. The only code that really notices the difference is the
// request object.
// Another departure is that all code related to HTTP parsing is in
// ClientRequest.onSocket(). The Agent is now *strictly*
// concerned with managing a connection pool.
function Agent(options) {
if (!(this instanceof Agent))
return new Agent(options);
EventEmitter.call(this);
var self = this;
self.defaultPort = 80;
self.protocol = 'http:';
self.options = util._extend({}, options);
// don't confuse net and make it think that we're connecting to a pipe
self.options.path = null;
self.requests = {};
self.sockets = {};
self.freeSockets = {};
self.keepAliveMsecs = self.options.keepAliveMsecs || 1000;
self.keepAlive = self.options.keepAlive || false;
self.maxSockets = self.options.maxSockets || Agent.defaultMaxSockets;
self.maxFreeSockets = self.options.maxFreeSockets || 256;
self.on('free', function(socket, options) {
var name = self.getName(options);
debug('agent.on(free)', name);
if (!self.isDestroyed(socket) &&
self.requests[name] && self.requests[name].length) {
self.requests[name].shift().onSocket(socket);
if (self.requests[name].length === 0) {
// don't leak
delete self.requests[name];
}
} else {
// If there are no pending requests, then put it in
// the freeSockets pool, but only if we're allowed to do so.
var req = socket._httpMessage;
if (req &&
req.shouldKeepAlive &&
!self.isDestroyed(socket) &&
self.options.keepAlive) {
var freeSockets = self.freeSockets[name];
var freeLen = freeSockets ? freeSockets.length : 0;
var count = freeLen;
if (self.sockets[name])
count += self.sockets[name].length;
if (count >= self.maxSockets || freeLen >= self.maxFreeSockets) {
self.removeSocket(socket, options);
socket.destroy();
} else {
freeSockets = freeSockets || [];
self.freeSockets[name] = freeSockets;
socket.setKeepAlive(true, self.keepAliveMsecs);
socket.unref && socket.unref();
socket._httpMessage = null;
self.removeSocket(socket, options);
freeSockets.push(socket);
}
} else {
self.removeSocket(socket, options);
socket.destroy();
}
}
});
}
util.inherits(Agent, EventEmitter);
exports.Agent = Agent;
Agent.defaultMaxSockets = Infinity;
Agent.prototype.createConnection = net.createConnection;
// Get the key for a given set of request options
Agent.prototype.getName = function(options) {
var name = '';
if (options.host)
name += options.host;
else
name += 'localhost';
name += ':';
if (options.port)
name += options.port;
name += ':';
if (options.localAddress)
name += options.localAddress;
name += ':';
return name;
};
Agent.prototype.addRequest = function(req, options) {
// Legacy API: addRequest(req, host, port, path)
if (typeof options === 'string') {
options = {
host: options,
port: arguments[2],
path: arguments[3]
};
}
var name = this.getName(options);
if (!this.sockets[name]) {
this.sockets[name] = [];
}
var freeLen = this.freeSockets[name] ? this.freeSockets[name].length : 0;
var sockLen = freeLen + this.sockets[name].length;
if (freeLen) {
// we have a free socket, so use that.
var socket = this.freeSockets[name].shift();
debug('have free socket');
// don't leak
if (!this.freeSockets[name].length)
delete this.freeSockets[name];
socket.ref && socket.ref();
req.onSocket(socket);
this.sockets[name].push(socket);
} else if (sockLen < this.maxSockets) {
debug('call onSocket', sockLen, freeLen);
// If we are under maxSockets create a new one.
req.onSocket(this.createSocket(req, options));
} else {
debug('wait for socket');
// We are over limit so we'll add it to the queue.
if (!this.requests[name]) {
this.requests[name] = [];
}
this.requests[name].push(req);
}
};
Agent.prototype.createSocket = function(req, options) {
var self = this;
options = util._extend({}, options);
options = util._extend(options, self.options);
options.servername = options.host;
if (req) {
var hostHeader = req.getHeader('host');
if (hostHeader) {
options.servername = hostHeader.replace(/:.*$/, '');
}
}
var name = self.getName(options);
debug('createConnection', name, options);
var s = self.createConnection(options);
if (!self.sockets[name]) {
self.sockets[name] = [];
}
this.sockets[name].push(s);
debug('sockets', name, this.sockets[name].length);
function onFree() {
self.emit('free', s, options);
}
s.on('free', onFree);
function onClose(err) {
debug('CLIENT socket onClose');
// This is the only place where sockets get removed from the Agent.
// If you want to remove a socket from the pool, just close it.
// All socket errors end in a close event anyway.
self.removeSocket(s, options);
}
s.on('close', onClose);
function onRemove() {
// We need this function for cases like HTTP 'upgrade'
// (defined by WebSockets) where we need to remove a socket from the
// pool because it'll be locked up indefinitely
debug('CLIENT socket onRemove');
self.removeSocket(s, options, 'agentRemove');
s.removeListener('close', onClose);
s.removeListener('free', onFree);
s.removeListener('agentRemove', onRemove);
}
s.on('agentRemove', onRemove);
return s;
};
Agent.prototype.removeSocket = function(s, options) {
var name = this.getName(options);
debug('removeSocket', name, 'destroyed:', this.isDestroyed(s));
var sets = [this.sockets];
if (this.isDestroyed(s)) {
// If the socket was destroyed, we need to remove it from the free buffers.
sets.push(this.freeSockets);
}
sets.forEach(function(sockets) {
if (sockets[name]) {
var index = sockets[name].indexOf(s);
if (index !== -1) {
sockets[name].splice(index, 1);
if (sockets[name].length === 0) {
// don't leak
delete sockets[name];
}
}
}
});
if (this.requests[name] && this.requests[name].length) {
debug('removeSocket, have a request, make a socket');
var req = this.requests[name][0];
// If we have pending requests and a socket gets closed make a new one
this.createSocket(req, options).emit('free');
}
};
Agent.prototype.destroy = function() {
var sets = [this.freeSockets, this.sockets];
sets.forEach(function(set) {
Object.keys(set).forEach(function(name) {
set[name].forEach(function(socket) {
socket.destroy();
});
});
});
};
Agent.prototype.request = function(options, cb) {
// if (util.isString(options)) {
// options = url.parse(options);
// }
if (typeof options === 'string') {
options = url.parse(options);
}
// don't try to do dns lookups of foo.com:8080, just foo.com
if (options.hostname) {
options.host = options.hostname;
}
if (options && options.path && / /.test(options.path)) {
// The actual regex is more like /[^A-Za-z0-9\-._~!$&'()*+,;=/:@]/
// with an additional rule for ignoring percentage-escaped characters
// but that's a) hard to capture in a regular expression that performs
// well, and b) possibly too restrictive for real-world usage. That's
// why it only scans for spaces because those are guaranteed to create
// an invalid request.
throw new TypeError('Request path contains unescaped characters.');
} else if (options.protocol && options.protocol !== this.protocol) {
throw new Error('Protocol:' + options.protocol + ' not supported.');
}
options = util._extend({
agent: this,
keepAlive: this.keepAlive
}, options);
// if it's false, then make a new one, just like this one.
if (options.agent === false)
options.agent = new this.constructor();
debug('agent.request', options);
return new ClientRequest(options, cb);
};
Agent.prototype.get = function(options, cb) {
var req = this.request(options, cb);
req.end();
return req;
};
Agent.prototype.isDestroyed = function(socket){
return socket.destroyed || socket._destroyed;
}
exports.globalAgent = new Agent();
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(99)))
/***/ }
/******/ ])
});