new file mode 100644

@@ -0,0 +1,12394 @@

+/**

+ *  Copyright (C) 2021  Double Bastion LLC

+ *

+ *  This file is part of Roundpin, which is licensed under the

+ *  GNU Affero General Public License Version 3.0. The license terms

+ *  are detailed in the "LICENSE.txt" file located in the root directory.

+ *

+ *  The file content from below is identical with that of the

+ *  original file "sip-0.11.6.js". The copyright notice for

+ *  the original content follows:

+

+/*!

+ * 

+ *  SIP version 0.11.6

+ *  Copyright (c) 2014-2018 Junction Networks, Inc <http://www.onsip.com>

+ *  Homepage: https://sipjs.com

+ *  License: https://sipjs.com/license/

+ * 

+ * 

+ *  ~~~SIP.js contains substantial portions of JsSIP under the following license~~~

+ *  Homepage: http://jssip.net

+ *  Copyright (c) 2012-2013 José Luis Millán - Versatica <http://www.versatica.com>

+ * 

+ *  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.

+ * 

+ *  ~~~ end JsSIP license ~~~

+ * 

+ * 

+ * 

+ * 

+ */

+(function webpackUniversalModuleDefinition(root, factory) {

+	if(typeof exports === 'object' && typeof module === 'object')

+		module.exports = factory();

+	else if(typeof define === 'function' && define.amd)

+		define([], factory);

+	else if(typeof exports === 'object')

+		exports["SIP"] = factory();

+	else

+		root["SIP"] = factory();

+})(this, function() {

+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] = {

+/******/ 			i: moduleId,

+/******/ 			l: false,

+/******/ 			exports: {}

+/******/ 		};

+/******/

+/******/ 		// Execute the module function

+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

+/******/

+/******/ 		// Flag the module as loaded

+/******/ 		module.l = 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;

+/******/

+/******/ 	// define getter function for harmony exports

+/******/ 	__webpack_require__.d = function(exports, name, getter) {

+/******/ 		if(!__webpack_require__.o(exports, name)) {

+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });

+/******/ 		}

+/******/ 	};

+/******/

+/******/ 	// define __esModule on exports

+/******/ 	__webpack_require__.r = function(exports) {

+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {

+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

+/******/ 		}

+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });

+/******/ 	};

+/******/

+/******/ 	// create a fake namespace object

+/******/ 	// mode & 1: value is a module id, require it

+/******/ 	// mode & 2: merge all properties of value into the ns

+/******/ 	// mode & 4: return value when already ns object

+/******/ 	// mode & 8|1: behave like require

+/******/ 	__webpack_require__.t = function(value, mode) {

+/******/ 		if(mode & 1) value = __webpack_require__(value);

+/******/ 		if(mode & 8) return value;

+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;

+/******/ 		var ns = Object.create(null);

+/******/ 		__webpack_require__.r(ns);

+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });

+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));

+/******/ 		return ns;

+/******/ 	};

+/******/

+/******/ 	// getDefaultExport function for compatibility with non-harmony modules

+/******/ 	__webpack_require__.n = function(module) {

+/******/ 		var getter = module && module.__esModule ?

+/******/ 			function getDefault() { return module['default']; } :

+/******/ 			function getModuleExports() { return module; };

+/******/ 		__webpack_require__.d(getter, 'a', getter);

+/******/ 		return getter;

+/******/ 	};

+/******/

+/******/ 	// Object.prototype.hasOwnProperty.call

+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };

+/******/

+/******/ 	// __webpack_public_path__

+/******/ 	__webpack_require__.p = "";

+/******/

+/******/

+/******/ 	// Load entry module and return exports

+/******/ 	return __webpack_require__(__webpack_require__.s = 0);

+/******/ })

+/************************************************************************/

+/******/ ([

+/* 0 */

+/***/ (function(module, exports, __webpack_require__) {

+

+"use strict";

+

+module.exports = __webpack_require__(1)(__webpack_require__(40));

+

+

+/***/ }),

+/* 1 */

+/***/ (function(module, exports, __webpack_require__) {

+

+"use strict";

+/**

+ * @name SIP

+ * @namespace

+ */

+

+module.exports = function (environment) {

+    var pkg = __webpack_require__(2), version = pkg.version, title = pkg.title;

+    var SIP = Object.defineProperties({}, {

+        version: {

+            get: function () { return version; }

+        },

+        name: {

+            get: function () { return title; }

+        }

+    });

+    __webpack_require__(3)(SIP, environment);

+    SIP.LoggerFactory = __webpack_require__(4)(environment.console);

+    SIP.EventEmitter = __webpack_require__(5)();

+    SIP.C = __webpack_require__(7)(SIP.name, SIP.version);

+    SIP.Exceptions = __webpack_require__(8);

+    SIP.Timers = __webpack_require__(9)(environment.timers);

+    SIP.Transport = __webpack_require__(10)(SIP);

+    __webpack_require__(11)(SIP);

+    __webpack_require__(12)(SIP);

+    __webpack_require__(13)(SIP);

+    __webpack_require__(14)(SIP);

+    __webpack_require__(15)(SIP);

+    __webpack_require__(16)(SIP);

+    __webpack_require__(18)(SIP);

+    __webpack_require__(19)(SIP);

+    SIP.SessionDescriptionHandler = __webpack_require__(20)(SIP.EventEmitter);

+    __webpack_require__(21)(SIP);

+    __webpack_require__(22)(SIP);

+    __webpack_require__(23)(SIP);

+    __webpack_require__(25)(SIP);

+    __webpack_require__(26)(SIP);

+    __webpack_require__(27)(SIP, environment);

+    __webpack_require__(32)(SIP);

+    SIP.DigestAuthentication = __webpack_require__(33)(SIP.Utils);

+    SIP.Grammar = __webpack_require__(36)(SIP);

+    SIP.Web = {

+        Modifiers: __webpack_require__(38)(SIP),

+        Simple: __webpack_require__(39)(SIP)

+    };

+    return SIP;

+};

+

+

+/***/ }),

+/* 2 */

+/***/ (function(module) {

+

+module.exports = {"name":"sip.js","title":"SIP.js","description":"A simple, intuitive, and powerful JavaScript signaling library","version":"0.11.6","main":"dist/sip.js","browser":{"./src/environment.js":"./src/environment_browser.js"},"homepage":"https://sipjs.com","author":"OnSIP <developer@onsip.com> (https://sipjs.com/aboutus/)","contributors":[{"url":"https://github.com/onsip/SIP.js/blob/master/THANKS.md"}],"repository":{"type":"git","url":"https://github.com/onsip/SIP.js.git"},"keywords":["sip","websocket","webrtc","library","javascript"],"devDependencies":{"awesome-typescript-loader":"^5.2.1","eslint":"^5.4.0","jasmine-core":"^3.2.1","karma":"^3.0.0","karma-chrome-launcher":"^2.2.0","karma-cli":"^1.0.1","karma-jasmine":"^1.1.0","karma-jasmine-html-reporter":"^1.3.1","karma-mocha-reporter":"^2.2.5","karma-webpack":"^3.0.0","pegjs":"^0.10.0","pegjs-loader":"^0.5.4","typescript":"^3.0.3","webpack":"^4.19.0","webpack-cli":"^3.0.8"},"engines":{"node":">=6.0"},"license":"MIT","scripts":{"prebuild":"eslint src/*.js src/**/*.js","build-dev":"webpack --progress --env.buildType dev","build-prod":"webpack --progress --env.buildType prod","copy-dist-files":"cp dist/sip.js dist/sip-$npm_package_version.js && cp dist/sip.min.js  dist/sip-$npm_package_version.min.js","build":"npm run build-dev && npm run build-prod && npm run copy-dist-files","browserTest":"sleep 2 && open http://0.0.0.0:9876/debug.html & karma start --reporters kjhtml --no-single-run","commandLineTest":"karma start --reporters mocha --browsers ChromeHeadless --single-run","buildAndTest":"npm run build && npm run commandLineTest","buildAndBrowserTest":"npm run build && npm run browserTest"},"dependencies":{"crypto-js":"^3.1.9-1"},"optionalDependencies":{"promiscuous":"^0.6.0"}};

+

+/***/ }),

+/* 3 */

+/***/ (function(module, exports, __webpack_require__) {

+

+"use strict";

+

+/**

+ * @fileoverview Utils

+ */

+module.exports = function (SIP, environment) {

+    var Utils;

+    Utils = {

+        Promise: environment.Promise,

+        defer: function defer() {

+            var deferred = {};

+            deferred.promise = new Utils.Promise(function (resolve, reject) {

+                deferred.resolve = resolve;

+                deferred.reject = reject;

+            });

+            return deferred;

+        },

+        reducePromises: function reducePromises(arr, val) {

+            return arr.reduce(function (acc, fn) {

+                acc = acc.then(fn);

+                return acc;

+            }, SIP.Utils.Promise.resolve(val));

+        },

+        augment: function (object, constructor, args, override) {

+            var idx, proto;

+            // Add public properties from constructor's prototype onto object

+            proto = constructor.prototype;

+            for (idx in proto) {

+                if (override || object[idx] === undefined) {

+                    object[idx] = proto[idx];

+                }

+            }

+            // Construct the object as though it were just created by constructor

+            constructor.apply(object, args);

+        },

+        defaultOptions: function (defaultOptions, overridingOptions) {

+            defaultOptions = defaultOptions || {};

+            overridingOptions = overridingOptions || {};

+            return Object.assign({}, defaultOptions, overridingOptions);

+        },

+        optionsOverride: function (options, winner, loser, isDeprecated, logger, defaultValue) {

+            if (isDeprecated && options[loser]) {

+                logger.warn(loser + ' is deprecated, please use ' + winner + ' instead');

+            }

+            if (options[winner] && options[loser]) {

+                logger.warn(winner + ' overriding ' + loser);

+            }

+            options[winner] = options[winner] || options[loser] || defaultValue;

+        },

+        str_utf8_length: function (string) {

+            return encodeURIComponent(string).replace(/%[A-F\d]{2}/g, 'U').length;

+        },

+        generateFakeSDP: function (body) {

+            if (!body) {

+                return;

+            }

+            var start = body.indexOf('o=');

+            var end = body.indexOf('\r\n', start);

+            return 'v=0\r\n' + body.slice(start, end) + '\r\ns=-\r\nt=0 0\r\nc=IN IP4 0.0.0.0';

+        },

+        isFunction: function (fn) {

+            if (fn !== undefined) {

+                return Object.prototype.toString.call(fn) === '[object Function]';

+            }

+            else {

+                return false;

+            }

+        },

+        isDecimal: function (num) {

+            return !isNaN(num) && (parseFloat(num) === parseInt(num, 10));

+        },

+        createRandomToken: function (size, base) {

+            var i, r, token = '';

+            base = base || 32;

+            for (i = 0; i < size; i++) {

+                r = Math.random() * base | 0;

+                token += r.toString(base);

+            }

+            return token;

+        },

+        newTag: function () {

+            return SIP.Utils.createRandomToken(SIP.UA.C.TAG_LENGTH);

+        },

+        // http://stackoverflow.com/users/109538/broofa

+        newUUID: function () {

+            var UUID = '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);

+            });

+            return UUID;

+        },

+        hostType: function (host) {

+            if (!host) {

+                return;

+            }

+            else {

+                host = SIP.Grammar.parse(host, 'host');

+                if (host !== -1) {

+                    return host.host_type;

+                }

+            }

+        },

+        /**

+        * Normalize SIP URI.

+        * NOTE: It does not allow a SIP URI without username.

+        * Accepts 'sip', 'sips' and 'tel' URIs and convert them into 'sip'.

+        * Detects the domain part (if given) and properly hex-escapes the user portion.

+        * If the user portion has only 'tel' number symbols the user portion is clean of 'tel' visual separators.

+        * @private

+        * @param {String} target

+        * @param {String} [domain]

+        */

+        normalizeTarget: function (target, domain) {

+            var uri, target_array, target_user, target_domain;

+            // If no target is given then raise an error.

+            if (!target) {

+                return;

+                // If a SIP.URI instance is given then return it.

+            }

+            else if (target instanceof SIP.URI) {

+                return target;

+                // If a string is given split it by '@':

+                // - Last fragment is the desired domain.

+                // - Otherwise append the given domain argument.

+            }

+            else if (typeof target === 'string') {

+                target_array = target.split('@');

+                switch (target_array.length) {

+                    case 1:

+                        if (!domain) {

+                            return;

+                        }

+                        target_user = target;

+                        target_domain = domain;

+                        break;

+                    case 2:

+                        target_user = target_array[0];

+                        target_domain = target_array[1];

+                        break;

+                    default:

+                        target_user = target_array.slice(0, target_array.length - 1).join('@');

+                        target_domain = target_array[target_array.length - 1];

+                }

+                // Remove the URI scheme (if present).

+                target_user = target_user.replace(/^(sips?|tel):/i, '');

+                // Remove 'tel' visual separators if the user portion just contains 'tel' number symbols.

+                if (/^[\-\.\(\)]*\+?[0-9\-\.\(\)]+$/.test(target_user)) {

+                    target_user = target_user.replace(/[\-\.\(\)]/g, '');

+                }

+                // Build the complete SIP URI.

+                target = SIP.C.SIP + ':' + SIP.Utils.escapeUser(target_user) + '@' + target_domain;

+                // Finally parse the resulting URI.

+                uri = SIP.URI.parse(target);

+                return uri;

+            }

+            else {

+                return;

+            }

+        },

+        /**

+        * Hex-escape a SIP URI user.

+        * @private

+        * @param {String} user

+        */

+        escapeUser: function (user) {

+            // Don't hex-escape ':' (%3A), '+' (%2B), '?' (%3F"), '/' (%2F).

+            return encodeURIComponent(decodeURIComponent(user)).replace(/%3A/ig, ':').replace(/%2B/ig, '+').replace(/%3F/ig, '?').replace(/%2F/ig, '/');

+        },

+        headerize: function (string) {

+            var exceptions = {

+                'Call-Id': 'Call-ID',

+                'Cseq': 'CSeq',

+                'Min-Se': 'Min-SE',

+                'Rack': 'RAck',

+                'Rseq': 'RSeq',

+                'Www-Authenticate': 'WWW-Authenticate'

+            }, name = string.toLowerCase().replace(/_/g, '-').split('-'), hname = '', parts = name.length, part;

+            for (part = 0; part < parts; part++) {

+                if (part !== 0) {

+                    hname += '-';

+                }

+                hname += name[part].charAt(0).toUpperCase() + name[part].substring(1);

+            }

+            if (exceptions[hname]) {

+                hname = exceptions[hname];

+            }

+            return hname;

+        },

+        sipErrorCause: function (status_code) {

+            var cause;

+            for (cause in SIP.C.SIP_ERROR_CAUSES) {

+                if (SIP.C.SIP_ERROR_CAUSES[cause].indexOf(status_code) !== -1) {

+                    return SIP.C.causes[cause];

+                }

+            }

+            return SIP.C.causes.SIP_FAILURE_CODE;

+        },

+        getReasonPhrase: function getReasonPhrase(code, specific) {

+            return specific || SIP.C.REASON_PHRASE[code] || '';

+        },

+        getReasonHeaderValue: function getReasonHeaderValue(code, reason) {

+            reason = SIP.Utils.getReasonPhrase(code, reason);

+            return 'SIP;cause=' + code + ';text="' + reason + '"';

+        },

+        getCancelReason: function getCancelReason(code, reason) {

+            if (code && code < 200 || code > 699) {

+                throw new TypeError('Invalid status_code: ' + code);

+            }

+            else if (code) {

+                return SIP.Utils.getReasonHeaderValue(code, reason);

+            }

+        },

+        buildStatusLine: function buildStatusLine(code, reason) {

+            code = code || null;

+            reason = reason || null;

+            // Validate code and reason values

+            if (!code || (code < 100 || code > 699)) {

+                throw new TypeError('Invalid status_code: ' + code);

+            }

+            else if (reason && typeof reason !== 'string' && !(reason instanceof String)) {

+                throw new TypeError('Invalid reason_phrase: ' + reason);

+            }

+            reason = Utils.getReasonPhrase(code, reason);

+            return 'SIP/2.0 ' + code + ' ' + reason + '\r\n';

+        },

+        /**

+        * Generate a random Test-Net IP (http://tools.ietf.org/html/rfc5735)

+        * @private

+        */

+        getRandomTestNetIP: function () {

+            function getOctet(from, to) {

+                return Math.floor(Math.random() * (to - from + 1) + from);

+            }

+            return '192.0.2.' + getOctet(1, 254);

+        }

+    };

+    SIP.Utils = Utils;

+};

+

+

+/***/ }),

+/* 4 */

+/***/ (function(module, exports, __webpack_require__) {

+

+"use strict";

+

+var levels = {

+    'error': 0,

+    'warn': 1,

+    'log': 2,

+    'debug': 3

+};

+module.exports = function (console) {

+    var LoggerFactory = function () {

+        var logger, level = 2, builtinEnabled = true, connector = null;

+        this.loggers = {};

+        logger = this.getLogger('sip.loggerfactory');

+        Object.defineProperties(this, {

+            builtinEnabled: {

+                get: function () { return builtinEnabled; },

+                set: function (value) {

+                    if (typeof value === 'boolean') {

+                        builtinEnabled = value;

+                    }

+                    else {

+                        logger.error('invalid "builtinEnabled" parameter value: ' + JSON.stringify(value));

+                    }

+                }

+            },

+            level: {

+                get: function () { return level; },

+                set: function (value) {

+                    if (value >= 0 && value <= 3) {

+                        level = value;

+                    }

+                    else if (value > 3) {

+                        level = 3;

+                    }

+                    else if (levels.hasOwnProperty(value)) {

+                        level = levels[value];

+                    }

+                    else {

+                        logger.error('invalid "level" parameter value: ' + JSON.stringify(value));

+                    }

+                }

+            },

+            connector: {

+                get: function () { return connector; },

+                set: function (value) {

+                    if (value === null || value === "" || value === undefined) {

+                        connector = null;

+                    }

+                    else if (typeof value === 'function') {

+                        connector = value;

+                    }

+                    else {

+                        logger.error('invalid "connector" parameter value: ' + JSON.stringify(value));

+                    }

+                }

+            }

+        });

+    };

+    LoggerFactory.prototype.print = function (target, category, label, content) {

+        if (typeof content === 'string') {

+            var prefix = [new Date(), category];

+            if (label) {

+                prefix.push(label);

+            }

+            content = prefix.concat(content).join(' | ');

+        }

+        target.call(console, content);

+    };

+    function Logger(logger, category, label) {

+        this.logger = logger;

+        this.category = category;

+        this.label = label;

+    }

+    Object.keys(levels).forEach(function (targetName) {

+        Logger.prototype[targetName] = function (content) {

+            this.logger[targetName](this.category, this.label, content);

+        };

+        LoggerFactory.prototype[targetName] = function (category, label, content) {

+            if (this.level >= levels[targetName]) {

+                if (this.builtinEnabled) {

+                    this.print(console[targetName], category, label, content);

+                }

+                if (this.connector) {

+                    this.connector(targetName, category, label, content);

+                }

+            }

+        };

+    });

+    LoggerFactory.prototype.getLogger = function (category, label) {

+        var logger;

+        if (label && this.level === 3) {

+            return new Logger(this, category, label);

+        }

+        else if (this.loggers[category]) {

+            return this.loggers[category];

+        }

+        else {

+            logger = new Logger(this, category);

+            this.loggers[category] = logger;

+            return logger;

+        }

+    };

+    return LoggerFactory;

+};

+

+

+/***/ }),

+/* 5 */

+/***/ (function(module, exports, __webpack_require__) {

+

+"use strict";

+

+var NodeEventEmitter = __webpack_require__(6).EventEmitter;

+module.exports = function () {

+    // Don't use `new SIP.EventEmitter()` for inheriting.

+    // Use Object.create(SIP.EventEmitter.prototoype);

+    function EventEmitter() {

+        NodeEventEmitter.call(this);

+    }

+    EventEmitter.prototype = Object.create(NodeEventEmitter.prototype, {

+        constructor: {

+            value: EventEmitter,

+            enumerable: false,

+            writable: true,

+            configurable: true

+        }

+    });

+    return EventEmitter;

+};

+

+

+/***/ }),

+/* 6 */

+/***/ (function(module, exports) {

+

+// 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

+      } else {

+        // At least give some kind of context to the user

+        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');

+        err.context = er;

+        throw err;

+      }

+    }

+  }

+

+  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:

+        args = Array.prototype.slice.call(arguments, 1);

+        handler.apply(this, args);

+    }

+  } else if (isObject(handler)) {

+    args = Array.prototype.slice.call(arguments, 1);

+    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) {

+    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 if (listeners) {

+    // 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.prototype.listenerCount = function(type) {

+  if (this._events) {

+    var evlistener = this._events[type];

+

+    if (isFunction(evlistener))

+      return 1;

+    else if (evlistener)

+      return evlistener.length;

+  }

+  return 0;

+};

+

+EventEmitter.listenerCount = function(emitter, type) {

+  return emitter.listenerCount(type);