604 lines
18 KiB
JavaScript
604 lines
18 KiB
JavaScript
// Module ID: 631
|
|
// Function ID: 7260
|
|
// Name: EventEmitter
|
|
// Dependencies: []
|
|
|
|
// Module 631 (EventEmitter)
|
|
class EventEmitter {
|
|
constructor() {
|
|
init = EventEmitter.init;
|
|
callResult = init.call(this);
|
|
return;
|
|
}
|
|
}
|
|
function checkListener(listener) {
|
|
if ("function" !== typeof listener) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError("The \"listener\" argument must be of type Function. Received type " + tmp);
|
|
throw typeError;
|
|
}
|
|
}
|
|
function _getMaxListeners(_maxListeners) {
|
|
if (undefined === _maxListeners._maxListeners) {
|
|
_maxListeners = EventEmitter.defaultMaxListeners;
|
|
} else {
|
|
_maxListeners = _maxListeners._maxListeners;
|
|
}
|
|
return _maxListeners;
|
|
}
|
|
function _addListener(_events, type, listener, arg3) {
|
|
checkListener(listener);
|
|
_events = _events._events;
|
|
if (undefined === _events) {
|
|
const _Object = Object;
|
|
const obj = Object.create(null);
|
|
_events._events = obj;
|
|
_events._eventsCount = 0;
|
|
_events = obj;
|
|
} else {
|
|
if (undefined !== _events.newListener) {
|
|
if (listener.listener) {
|
|
listener = listener.listener;
|
|
}
|
|
_events.emit("newListener", type, listener);
|
|
_events = _events._events;
|
|
}
|
|
let arr = _events[type];
|
|
}
|
|
if (undefined === arr) {
|
|
_events[type] = listener;
|
|
_events._eventsCount = _events._eventsCount + 1;
|
|
} else if ("function" === typeof arr) {
|
|
const items = [, ];
|
|
if (arg3) {
|
|
items[0] = listener;
|
|
items[1] = arr;
|
|
let tmp8 = items;
|
|
} else {
|
|
items[0] = arr;
|
|
items[1] = listener;
|
|
tmp8 = items;
|
|
}
|
|
_events[type] = tmp8;
|
|
} else {
|
|
if (arg3) {
|
|
arr = arr.unshift(listener);
|
|
let arr2 = arr;
|
|
} else {
|
|
arr = arr.push(listener);
|
|
arr2 = arr;
|
|
}
|
|
const tmp11 = _getMaxListeners(_events);
|
|
if (tmp11 > 0) {
|
|
if (arr2.length > tmp11) {
|
|
if (!arr2.warned) {
|
|
arr2.warned = true;
|
|
const _Error = Error;
|
|
const _String = String;
|
|
const text = `Possible EventEmitter memory leak detected. ${arr2.length}`;
|
|
const error = new Error(`Possible EventEmitter memory leak detected. ${arr2.length}` + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
|
|
error.name = "MaxListenersExceededWarning";
|
|
error.emitter = _events;
|
|
error.type = type;
|
|
error.count = arr2.length;
|
|
let warn = console;
|
|
if (console) {
|
|
const _console = console;
|
|
warn = console.warn;
|
|
}
|
|
if (warn) {
|
|
const _console2 = console;
|
|
console.warn(error);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return _events;
|
|
}
|
|
function onceWrapper() {
|
|
const self = this;
|
|
if (!this.fired) {
|
|
const target = self.target;
|
|
target.removeListener(self.type, self.wrapFn);
|
|
self.fired = true;
|
|
if (0 === arguments.length) {
|
|
const listener2 = self.listener;
|
|
let callResult = listener2.call(self.target);
|
|
} else {
|
|
const listener = self.listener;
|
|
callResult = listener(...arguments);
|
|
}
|
|
return callResult;
|
|
}
|
|
}
|
|
function _onceWrap(target, type, listener) {
|
|
const obj = { fired: false, wrapFn: undefined, target, type, listener };
|
|
const bindResult = onceWrapper.bind(obj);
|
|
bindResult.listener = listener;
|
|
obj.wrapFn = bindResult;
|
|
return bindResult;
|
|
}
|
|
function _listeners(_events, arg1, arg2) {
|
|
_events = _events._events;
|
|
if (undefined === _events) {
|
|
return [];
|
|
} else {
|
|
let items1 = _events[arg1];
|
|
if (undefined === items1) {
|
|
let items = [];
|
|
} else if ("function" === typeof items1) {
|
|
if (arg2) {
|
|
items1 = [];
|
|
items1[0] = items1.listener || items1;
|
|
let items2 = items1;
|
|
const tmp6 = items1.listener || items1;
|
|
} else {
|
|
items2 = [items1];
|
|
}
|
|
} else if (arg2) {
|
|
const _Array = Array;
|
|
const array = new Array(items1.length);
|
|
let num = 0;
|
|
items = array;
|
|
if (0 < array.length) {
|
|
do {
|
|
array[num] = items1[num].listener || items1[num];
|
|
num = num + 1;
|
|
items = array;
|
|
} while (num < array.length);
|
|
}
|
|
} else {
|
|
items = arrayClone(items1, items1.length);
|
|
}
|
|
return items;
|
|
}
|
|
}
|
|
function listenerCount(arg0) {
|
|
const _events = this._events;
|
|
if (undefined !== _events) {
|
|
if ("function" === typeof _events[arg0]) {
|
|
return 1;
|
|
} else if (undefined !== arr) {
|
|
return arr.length;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
function arrayClone(items1, length) {
|
|
const array = new Array(length);
|
|
for (let num = 0; num < length; num = num + 1) {
|
|
array[num] = items1[num];
|
|
}
|
|
return array;
|
|
}
|
|
function eventTargetAgnosticAddListener(on, arg1, arg2, once) {
|
|
let closure_0 = on;
|
|
let closure_1 = arg1;
|
|
let closure_2 = arg2;
|
|
let closure_3 = once;
|
|
if ("function" === typeof on.on) {
|
|
if (once.once) {
|
|
on.once(arg1, arg2);
|
|
} else {
|
|
on.on(arg1, arg2);
|
|
}
|
|
} else if ("function" !== typeof on.addEventListener) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError("The \"emitter\" argument must be of type EventEmitter. Received type " + typeof on);
|
|
throw typeError;
|
|
} else {
|
|
function wrapListener(arg0) {
|
|
if (once.once) {
|
|
const removed = on.removeEventListener(closure_1, wrapListener);
|
|
}
|
|
callback(arg0);
|
|
}
|
|
const listener = on.addEventListener(arg1, wrapListener);
|
|
}
|
|
}
|
|
let _Reflect = null;
|
|
if ("object" === typeof Reflect) {
|
|
_Reflect = Reflect;
|
|
}
|
|
if (_Reflect) {
|
|
class EventEmitter {
|
|
constructor() {
|
|
init = EventEmitter.init;
|
|
callResult = init.call(this);
|
|
return;
|
|
}
|
|
}
|
|
if (_Reflect) {
|
|
class EventEmitter {
|
|
constructor() {
|
|
init = EventEmitter.init;
|
|
callResult = init.call(this);
|
|
return;
|
|
}
|
|
static init() {
|
|
self = this;
|
|
tmp = undefined !== this._events;
|
|
if (tmp) {
|
|
tmp2 = globalThis;
|
|
_Object = Object;
|
|
tmp = self._events !== Object.getPrototypeOf(self)._events;
|
|
}
|
|
if (!tmp) {
|
|
tmp3 = globalThis;
|
|
_Object2 = Object;
|
|
tmp4 = null;
|
|
self._events = Object.create(null);
|
|
num = 0;
|
|
self._eventsCount = 0;
|
|
}
|
|
self._maxListeners = self._maxListeners || undefined;
|
|
return;
|
|
}
|
|
setMaxListeners(arg0) {
|
|
self = this;
|
|
if ("number" === typeof global) {
|
|
num = 0;
|
|
if (global >= 0) {
|
|
tmp = NumberIsNaN;
|
|
if (!NumberIsNaN(global)) {
|
|
self._maxListeners = global;
|
|
return self;
|
|
}
|
|
}
|
|
}
|
|
rangeError = new RangeError("The value of \"n\" is out of range. It must be a non-negative number. Received " + global + ".");
|
|
throw rangeError;
|
|
}
|
|
getMaxListeners() {
|
|
return _getMaxListeners(this);
|
|
}
|
|
emit(arg0) {
|
|
self = this;
|
|
items = [];
|
|
num = 1;
|
|
if (1 < arguments.length) {
|
|
do {
|
|
arr = items.push(arguments[num]);
|
|
num = num + 1;
|
|
length = arguments.length;
|
|
} while (num < length);
|
|
}
|
|
tmp2 = "error" === global;
|
|
_events = self._events;
|
|
if (undefined !== _events) {
|
|
tmp4 = tmp2;
|
|
if (tmp2) {
|
|
tmp4 = undefined === _events.error;
|
|
}
|
|
tmp3 = tmp4;
|
|
} else {
|
|
tmp3 = tmp2;
|
|
if (!tmp2) {
|
|
flag = false;
|
|
return false;
|
|
}
|
|
}
|
|
if (tmp3) {
|
|
num3 = 0;
|
|
first = undefined;
|
|
if (items.length > 0) {
|
|
first = items[0];
|
|
}
|
|
tmp12 = globalThis;
|
|
_Error = Error;
|
|
if (first instanceof Error) {
|
|
throw first;
|
|
} else {
|
|
_Error2 = Error;
|
|
str2 = "";
|
|
if (first) {
|
|
str3 = " (";
|
|
str4 = ")";
|
|
str2 = `${" (" + tmp11.message})`;
|
|
}
|
|
prototype = _Error2.prototype;
|
|
tmp13 = new.target;
|
|
str5 = "Unhandled error.";
|
|
tmp14 = new.target;
|
|
_Error2 = new _Error2("Unhandled error." + str2);
|
|
tmp16 = _Error2;
|
|
_Error2.context = first;
|
|
throw _Error2;
|
|
}
|
|
} else {
|
|
arr2 = _events[global];
|
|
if (undefined === arr2) {
|
|
flag3 = false;
|
|
return false;
|
|
} else {
|
|
str = "function";
|
|
if ("function" === typeof arr2) {
|
|
tmp9 = apply;
|
|
tmp10 = apply(arr2, self, items);
|
|
} else {
|
|
length2 = arr2.length;
|
|
tmp5 = arrayClone;
|
|
for (let num2 = 0; num2 < length2; num2 = num2 + 1) {
|
|
tmp7 = apply;
|
|
tmp8 = apply(tmp6[num2], self, items);
|
|
}
|
|
}
|
|
flag2 = true;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
addListener(arg0, arg1) {
|
|
tmp = _addListener(this, global, require, false);
|
|
return this;
|
|
}
|
|
prependListener(arg0, arg1) {
|
|
tmp = _addListener(this, global, require, true);
|
|
return this;
|
|
}
|
|
once(arg0, arg1) {
|
|
tmp = checkListener(require);
|
|
onResult = this.on(global, _onceWrap(this, global, require));
|
|
return this;
|
|
}
|
|
prependOnceListener(arg0, arg1) {
|
|
tmp = checkListener(require);
|
|
prependListenerResult = this.prependListener(global, _onceWrap(this, global, require));
|
|
return this;
|
|
}
|
|
removeListener(arg0, arg1) {
|
|
self = this;
|
|
tmp3 = checkListener(require);
|
|
_events = this._events;
|
|
if (undefined === _events) {
|
|
return self;
|
|
} else {
|
|
arr = _events[global];
|
|
if (undefined === arr) {
|
|
return self;
|
|
} else {
|
|
if (arr !== require) {
|
|
if (arr.listener !== require) {
|
|
str3 = "function";
|
|
if ("function" !== typeof arr) {
|
|
num3 = 1;
|
|
diff = arr.length - 1;
|
|
num4 = -1;
|
|
num5 = 0;
|
|
num = -1;
|
|
if (diff >= 0) {
|
|
tmp4 = diff;
|
|
while (arr[diff] !== require) {
|
|
if (arr[diff].listener === require) {
|
|
break;
|
|
} else {
|
|
diff = diff - 1;
|
|
num = -1;
|
|
}
|
|
}
|
|
listener = arr[diff].listener;
|
|
num = diff;
|
|
}
|
|
if (num < 0) {
|
|
return self;
|
|
} else {
|
|
if (0 === num) {
|
|
arr = arr.shift();
|
|
} else {
|
|
if (num + 1 < arr.length) {
|
|
do {
|
|
arr[num] = arr[num + 1];
|
|
num = num + 1;
|
|
sum = num + 1;
|
|
length = arr.length;
|
|
} while (sum < length);
|
|
}
|
|
arr1 = arr.pop();
|
|
}
|
|
if (1 === arr.length) {
|
|
_events[global] = arr[0];
|
|
}
|
|
if (undefined !== _events.removeListener) {
|
|
if (!listener) {
|
|
listener = require;
|
|
}
|
|
str = "removeListener";
|
|
emitResult = self.emit("removeListener", global, listener);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return self;
|
|
}
|
|
diff1 = self._eventsCount - 1;
|
|
self._eventsCount = diff1;
|
|
num2 = 0;
|
|
if (0 == diff1) {
|
|
tmp12 = globalThis;
|
|
_Object = Object;
|
|
tmp13 = null;
|
|
self._events = Object.create(null);
|
|
} else {
|
|
delete tmp[tmp2];
|
|
if (_events.removeListener) {
|
|
listener2 = arr.listener;
|
|
if (!listener2) {
|
|
listener2 = require;
|
|
}
|
|
str2 = "removeListener";
|
|
emitResult1 = self.emit("removeListener", global, listener2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
removeAllListeners(arg0) {
|
|
self = this;
|
|
_events = this._events;
|
|
if (undefined === _events) {
|
|
return self;
|
|
} else if (undefined === _events.removeListener) {
|
|
num3 = 0;
|
|
if (0 === arguments.length) {
|
|
tmp14 = globalThis;
|
|
_Object4 = Object;
|
|
tmp15 = null;
|
|
self._events = Object.create(null);
|
|
self._eventsCount = 0;
|
|
} else if (undefined !== _events[global]) {
|
|
diff = self._eventsCount - 1;
|
|
self._eventsCount = diff;
|
|
if (0 == diff) {
|
|
tmp12 = globalThis;
|
|
_Object3 = Object;
|
|
tmp13 = null;
|
|
self._events = Object.create(null);
|
|
} else {
|
|
delete tmp[tmp2];
|
|
}
|
|
}
|
|
return self;
|
|
} else {
|
|
num4 = 0;
|
|
if (0 === arguments.length) {
|
|
tmp6 = globalThis;
|
|
_Object = Object;
|
|
keys = Object.keys(_events);
|
|
str2 = "removeListener";
|
|
for (let num2 = 0; num2 < keys.length; num2 = num2 + 1) {
|
|
tmp7 = keys[num2];
|
|
if ("removeListener" !== tmp7) {
|
|
removeAllListenersResult = self.removeAllListeners(tmp7);
|
|
}
|
|
}
|
|
removeAllListenersResult1 = self.removeAllListeners("removeListener");
|
|
_Object2 = Object;
|
|
tmp10 = null;
|
|
self._events = Object.create(null);
|
|
self._eventsCount = 0;
|
|
return self;
|
|
} else {
|
|
arr = _events[global];
|
|
str = "function";
|
|
if ("function" === typeof arr) {
|
|
removeListenerResult = self.removeListener(global, arr);
|
|
} else if (undefined !== arr) {
|
|
num = 1;
|
|
diff1 = arr.length - 1;
|
|
if (diff1 >= 0) {
|
|
do {
|
|
removeListenerResult1 = self.removeListener(global, arr[diff1]);
|
|
diff1 = diff1 - 1;
|
|
} while (diff1 >= 0);
|
|
}
|
|
}
|
|
return self;
|
|
}
|
|
}
|
|
}
|
|
listeners(arg0) {
|
|
return _listeners(this, global, true);
|
|
}
|
|
rawListeners(arg0) {
|
|
return _listeners(this, global, false);
|
|
}
|
|
static listenerCount(arg0, arg1) {
|
|
if ("function" === typeof global.listenerCount) {
|
|
listenerCountResult = global.listenerCount(require);
|
|
} else {
|
|
tmp = listenerCount;
|
|
listenerCountResult = listenerCount.call(global, require);
|
|
}
|
|
return listenerCountResult;
|
|
}
|
|
eventNames() {
|
|
if (this._eventsCount > 0) {
|
|
tmp2 = ownKeys;
|
|
items = ownKeys(tmp._events);
|
|
} else {
|
|
items = [];
|
|
}
|
|
return items;
|
|
}
|
|
}
|
|
let closure_0 = tmp2;
|
|
const _Number = Number;
|
|
let closure_2 = Number.isNaN || (function NumberIsNaN(arg0) {
|
|
return arg0 != arg0;
|
|
});
|
|
module.exports = EventEmitter;
|
|
module.exports.once = function once(arg0, arg1) {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
return new Promise((arg0, arg1) => {
|
|
const on = arg0;
|
|
let closure_1 = arg1;
|
|
function errorListener(arg0) {
|
|
lib.removeListener(callback, resolver);
|
|
callback(arg0);
|
|
}
|
|
function resolver() {
|
|
if ("function" === typeof lib.removeListener) {
|
|
lib.removeListener("error", errorListener);
|
|
}
|
|
const slice = [].slice;
|
|
lib(slice.call(arguments));
|
|
}
|
|
let obj = { once: true };
|
|
outer1_13(on, closure_1, resolver, obj);
|
|
if ("error" !== closure_1) {
|
|
obj = { once: true };
|
|
if ("function" === typeof on.on) {
|
|
outer1_13(tmp2, "error", errorListener, obj);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
EventEmitter.EventEmitter = EventEmitter;
|
|
EventEmitter.prototype._events = undefined;
|
|
EventEmitter.prototype._eventsCount = 0;
|
|
EventEmitter.prototype._maxListeners = undefined;
|
|
let c3 = 10;
|
|
let _Object2 = Object;
|
|
let obj = {};
|
|
class ReflectApply {
|
|
constructor(arg0, arg1, arg2) {
|
|
apply = Function.prototype.apply;
|
|
return apply.call(global, require, importDefault);
|
|
}
|
|
}
|
|
obj.get = function get() {
|
|
return c3;
|
|
};
|
|
obj.set = function set(arg0) {
|
|
if ("number" === typeof arg0) {
|
|
if (arg0 >= 0) {
|
|
if (!callback(arg0)) {
|
|
let closure_3 = arg0;
|
|
}
|
|
}
|
|
}
|
|
const rangeError = new RangeError("The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received " + arg0 + ".");
|
|
throw rangeError;
|
|
};
|
|
Object.defineProperty(EventEmitter, "defaultMaxListeners", obj);
|
|
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
|
|
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
|
|
EventEmitter.prototype.listenerCount = listenerCount;
|
|
}
|
|
let _Object = Object;
|
|
tmp2 = Object.getOwnPropertySymbols ? (function ReflectOwnKeys(arr) {
|
|
const ownPropertyNames = Object.getOwnPropertyNames(arr);
|
|
return ownPropertyNames.concat(Object.getOwnPropertySymbols(arr));
|
|
}) : (function ReflectOwnKeys(arr) {
|
|
return Object.getOwnPropertyNames(arr);
|
|
});
|
|
}
|
|
class ReflectApply {
|
|
constructor(arg0, arg1, arg2) {
|
|
apply = Function.prototype.apply;
|
|
return apply.call(global, require, importDefault);
|
|
}
|
|
}
|