693 lines
20 KiB
JavaScript
693 lines
20 KiB
JavaScript
// Module ID: 229
|
|
// Function ID: 3179
|
|
// Name: pd
|
|
// Dependencies: []
|
|
|
|
// Module 229 (pd)
|
|
function pd(arg0) {
|
|
const value = weakMap.get(arg0);
|
|
console.assert(null != value, "'this' is expected an Event object, but got", arg0);
|
|
return value;
|
|
}
|
|
function setCancelFlag(passiveListener) {
|
|
if (null == passiveListener.passiveListener) {
|
|
if (passiveListener.event.cancelable) {
|
|
passiveListener.canceled = true;
|
|
if ("function" === typeof passiveListener.event.preventDefault) {
|
|
const event = passiveListener.event;
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
} else {
|
|
const _console = console;
|
|
let tmp2 = "undefined" !== typeof console;
|
|
if (tmp2) {
|
|
const _console2 = console;
|
|
tmp2 = "function" === typeof console.error;
|
|
}
|
|
if (tmp2) {
|
|
const _console3 = console;
|
|
console.error("Unable to preventDefault inside passive event listener invocation.", passiveListener.passiveListener);
|
|
}
|
|
}
|
|
}
|
|
class Event {
|
|
constructor(arg0, arg1) {
|
|
self = this;
|
|
obj = { eventTarget: null, event: null, eventPhase: 2, currentTarget: null, canceled: false, stopped: false, immediateStopped: false, passiveListener: null };
|
|
obj.eventTarget = global;
|
|
obj.event = require;
|
|
obj.currentTarget = global;
|
|
timeStamp = require.timeStamp;
|
|
tmp = WeakMap;
|
|
if (!timeStamp) {
|
|
tmp2 = globalThis;
|
|
_Date = Date;
|
|
timeStamp = Date.now();
|
|
}
|
|
obj.timeStamp = timeStamp;
|
|
result = WeakMap.set(self, obj);
|
|
definePropertyResult = Object.defineProperty(self, "isTrusted", { value: false, enumerable: true });
|
|
keys = Object.keys(require);
|
|
for (let num = 0; num < keys.length; num = num + 1) {
|
|
tmp5 = keys[num];
|
|
if (!(tmp5 in self)) {
|
|
_Object = Object;
|
|
tmp6 = defineRedirectDescriptor;
|
|
definePropertyResult1 = Object.defineProperty(self, tmp5, defineRedirectDescriptor(tmp5));
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
function defineRedirectDescriptor(arg0) {
|
|
let closure_0 = arg0;
|
|
return {
|
|
get() {
|
|
return outer1_3(this).event[closure_0];
|
|
},
|
|
set(arg0) {
|
|
outer1_3(this).event[closure_0] = arg0;
|
|
},
|
|
configurable: true,
|
|
enumerable: true
|
|
};
|
|
}
|
|
function defineCallDescriptor(arg0) {
|
|
let closure_0 = arg0;
|
|
const obj = {
|
|
value() {
|
|
const event = outer1_3(this).event;
|
|
return event[closure_0](...arguments);
|
|
},
|
|
configurable: true,
|
|
enumerable: true
|
|
};
|
|
return obj;
|
|
}
|
|
function getWrapper(prototypeOf) {
|
|
if (null != prototypeOf) {
|
|
let _Object = Object;
|
|
if (prototypeOf !== Object.prototype) {
|
|
let value = weakMap1.get(prototypeOf);
|
|
if (null == value) {
|
|
const _Object2 = Object;
|
|
const tmp5 = (function defineWrapper(wrapper, prototypeOf) {
|
|
let closure_0 = wrapper;
|
|
class CustomEvent {
|
|
constructor(arg0, arg1) {
|
|
callResult = closure_0.call(this, wrapper, prototypeOf);
|
|
return;
|
|
}
|
|
}
|
|
const keys = Object.keys(prototypeOf);
|
|
if (0 === keys.length) {
|
|
return wrapper;
|
|
} else {
|
|
const _Object = Object;
|
|
let obj = {};
|
|
obj = { value: null, configurable: true, writable: true };
|
|
class CustomEvent {
|
|
constructor(arg0, arg1) {
|
|
callResult = closure_0.call(this, wrapper, prototypeOf);
|
|
return;
|
|
}
|
|
}
|
|
obj.constructor = obj;
|
|
CustomEvent.prototype = Object.create(wrapper.prototype, obj);
|
|
let num = 0;
|
|
if (0 < keys.length) {
|
|
while (keys[num] in wrapper.prototype) {
|
|
num = num + 1;
|
|
}
|
|
class CustomEvent {
|
|
constructor(arg0, arg1) {
|
|
callResult = closure_0.call(this, wrapper, prototypeOf);
|
|
return;
|
|
}
|
|
}
|
|
if ("function" === typeof Object.getOwnPropertyDescriptor(prototypeOf, keys[num]).value) {
|
|
let tmp3 = outer1_7(tmp);
|
|
} else {
|
|
tmp3 = outer1_6(tmp);
|
|
}
|
|
Object.defineProperty(CustomEvent.prototype, keys[num], tmp3);
|
|
}
|
|
return CustomEvent;
|
|
}
|
|
})(getWrapper(Object.getPrototypeOf(prototypeOf)), prototypeOf);
|
|
const result = weakMap1.set(prototypeOf, tmp5);
|
|
value = tmp5;
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
return Event;
|
|
}
|
|
function isStopped(arg0) {
|
|
return pd(arg0).immediateStopped;
|
|
}
|
|
function setPassiveListener(arg0, passiveListener) {
|
|
pd(arg0).passiveListener = passiveListener;
|
|
}
|
|
function isObject(arg0) {
|
|
let tmp = null !== arg0;
|
|
if (tmp) {
|
|
tmp = "object" === typeof arg0;
|
|
}
|
|
return tmp;
|
|
}
|
|
function getListeners(self) {
|
|
const value = weakMap2.get(self);
|
|
if (null == value) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError("'this' is expected an EventTarget object, but got another value.");
|
|
throw typeError;
|
|
} else {
|
|
return value;
|
|
}
|
|
}
|
|
function defineEventAttribute(prototype, abort) {
|
|
const combined = "on" + abort;
|
|
Object.defineProperty(prototype, combined, (function defineEventAttributeDescriptor(abort) {
|
|
let closure_0 = abort;
|
|
return {
|
|
get() {
|
|
let iter = outer2_12(this).get(closure_0);
|
|
if (null != iter) {
|
|
while (3 !== iter.listenerType) {
|
|
iter = iter.next;
|
|
}
|
|
return iter.listener;
|
|
}
|
|
return null;
|
|
},
|
|
set(arg0) {
|
|
let tmp = "function" === typeof arg0;
|
|
if (!tmp) {
|
|
tmp = outer2_11(arg0);
|
|
}
|
|
let tmp3 = arg0;
|
|
if (!tmp) {
|
|
tmp3 = null;
|
|
}
|
|
let obj = outer2_12(this);
|
|
const value = obj.get(closure_0);
|
|
let tmp5 = null;
|
|
let iter = value;
|
|
let tmp6 = null;
|
|
if (null != value) {
|
|
do {
|
|
let tmp7 = iter;
|
|
if (3 === iter.listenerType) {
|
|
if (null !== tmp5) {
|
|
tmp5.next = iter.next;
|
|
tmp7 = tmp5;
|
|
} else if (null !== iter.next) {
|
|
let tmp10 = closure_0;
|
|
let result = obj.set(closure_0, iter.next);
|
|
tmp7 = tmp5;
|
|
} else {
|
|
let tmp8 = closure_0;
|
|
let deleteResult = obj.delete(closure_0);
|
|
tmp7 = tmp5;
|
|
}
|
|
}
|
|
iter = iter.next;
|
|
tmp5 = tmp7;
|
|
tmp6 = tmp7;
|
|
} while (null != iter);
|
|
}
|
|
if (null !== tmp3) {
|
|
obj = { listener: tmp3, listenerType: 3, passive: false, once: false, next: null };
|
|
if (null === tmp6) {
|
|
const result1 = obj.set(closure_0, obj);
|
|
} else {
|
|
tmp6.next = obj;
|
|
}
|
|
}
|
|
},
|
|
configurable: true,
|
|
enumerable: true
|
|
};
|
|
})(abort));
|
|
}
|
|
function defineCustomEventTarget(array) {
|
|
let length;
|
|
class CustomEventTarget {
|
|
constructor() {
|
|
callResult = outer1_15.call(this);
|
|
return;
|
|
}
|
|
}
|
|
const obj = { value: CustomEventTarget, configurable: true, writable: true };
|
|
CustomEventTarget.prototype = Object.create(EventTarget.prototype, { constructor: obj });
|
|
let num = 0;
|
|
if (0 < array.length) {
|
|
do {
|
|
let tmp = defineEventAttribute;
|
|
let tmp2 = defineEventAttribute(CustomEventTarget.prototype, array[num]);
|
|
num = num + 1;
|
|
length = array.length;
|
|
} while (num < length);
|
|
}
|
|
return CustomEventTarget;
|
|
}
|
|
class EventTarget {
|
|
constructor() {
|
|
if (this instanceof EventTarget) {
|
|
tmp15 = WeakMap;
|
|
tmp16 = globalThis;
|
|
_Map = Map;
|
|
prototype3 = Map.prototype;
|
|
tmp17 = new.target;
|
|
tmp18 = new.target;
|
|
map = new Map();
|
|
tmp20 = map;
|
|
result = WeakMap.set(tmp, map);
|
|
return;
|
|
} else {
|
|
num = 1;
|
|
if (1 === arguments.length) {
|
|
tmp2 = globalThis;
|
|
_Array = Array;
|
|
num2 = 0;
|
|
if (Array.isArray(arguments[0])) {
|
|
tmp14 = defineCustomEventTarget;
|
|
return defineCustomEventTarget(arguments[0]);
|
|
}
|
|
}
|
|
num3 = 0;
|
|
if (arguments.length > 0) {
|
|
tmp8 = globalThis;
|
|
_Array2 = Array;
|
|
prototype2 = Array.prototype;
|
|
tmp9 = new.target;
|
|
tmp10 = new.target;
|
|
array = new Array(arguments.length);
|
|
tmp12 = array;
|
|
num4 = 0;
|
|
if (0 < arguments.length) {
|
|
do {
|
|
array[num4] = arguments[num4];
|
|
num4 = num4 + 1;
|
|
length = arguments.length;
|
|
} while (num4 < length);
|
|
}
|
|
tmp13 = defineCustomEventTarget;
|
|
return defineCustomEventTarget(array);
|
|
} else {
|
|
tmp3 = globalThis;
|
|
_TypeError = TypeError;
|
|
prototype = TypeError.prototype;
|
|
tmp4 = new.target;
|
|
str = "Cannot call a class as a function";
|
|
tmp5 = new.target;
|
|
typeError = new TypeError("Cannot call a class as a function");
|
|
tmp7 = typeError;
|
|
throw typeError;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const weakMap = new WeakMap();
|
|
const weakMap1 = new WeakMap();
|
|
let obj = {};
|
|
Object.defineProperty(obj, "type", {
|
|
get: function() {
|
|
return pd(this).event.type;
|
|
},
|
|
set: undefined
|
|
});
|
|
Object.defineProperty(obj, "target", {
|
|
get: function() {
|
|
return pd(this).eventTarget;
|
|
},
|
|
set: undefined
|
|
});
|
|
Object.defineProperty(obj, "currentTarget", {
|
|
get: function() {
|
|
return pd(this).currentTarget;
|
|
},
|
|
set: undefined
|
|
});
|
|
obj.composedPath = function composedPath() {
|
|
const currentTarget = pd(this).currentTarget;
|
|
if (null == currentTarget) {
|
|
let items = [];
|
|
} else {
|
|
items = [currentTarget];
|
|
}
|
|
return items;
|
|
};
|
|
Object.defineProperty(obj, "NONE", { get: () => 0, set: undefined });
|
|
Object.defineProperty(obj, "CAPTURING_PHASE", { get: () => 1, set: undefined });
|
|
Object.defineProperty(obj, "AT_TARGET", { get: () => 2, set: undefined });
|
|
Object.defineProperty(obj, "BUBBLING_PHASE", { get: () => 3, set: undefined });
|
|
Object.defineProperty(obj, "eventPhase", {
|
|
get: function() {
|
|
return pd(this).eventPhase;
|
|
},
|
|
set: undefined
|
|
});
|
|
obj.stopPropagation = function stopPropagation() {
|
|
const tmp = pd(this);
|
|
tmp.stopped = true;
|
|
if ("function" === typeof tmp.event.stopPropagation) {
|
|
const event = tmp.event;
|
|
event.stopPropagation();
|
|
}
|
|
};
|
|
obj.stopImmediatePropagation = function stopImmediatePropagation() {
|
|
const tmp = pd(this);
|
|
tmp.stopped = true;
|
|
tmp.immediateStopped = true;
|
|
if ("function" === typeof tmp.event.stopImmediatePropagation) {
|
|
const event = tmp.event;
|
|
const result = event.stopImmediatePropagation();
|
|
}
|
|
};
|
|
Object.defineProperty(obj, "bubbles", {
|
|
get: function() {
|
|
return Boolean(pd(this).event.bubbles);
|
|
},
|
|
set: undefined
|
|
});
|
|
Object.defineProperty(obj, "cancelable", {
|
|
get: function() {
|
|
return Boolean(pd(this).event.cancelable);
|
|
},
|
|
set: undefined
|
|
});
|
|
obj.preventDefault = function preventDefault() {
|
|
setCancelFlag(pd(this));
|
|
};
|
|
Object.defineProperty(obj, "defaultPrevented", {
|
|
get: function() {
|
|
return pd(this).canceled;
|
|
},
|
|
set: undefined
|
|
});
|
|
Object.defineProperty(obj, "composed", {
|
|
get: function() {
|
|
return Boolean(pd(this).event.composed);
|
|
},
|
|
set: undefined
|
|
});
|
|
Object.defineProperty(obj, "timeStamp", {
|
|
get: function() {
|
|
return pd(this).timeStamp;
|
|
},
|
|
set: undefined
|
|
});
|
|
Object.defineProperty(obj, "srcElement", {
|
|
get: function() {
|
|
return pd(this).eventTarget;
|
|
},
|
|
set: undefined
|
|
});
|
|
Object.defineProperty(obj, "cancelBubble", {
|
|
get: function() {
|
|
return pd(this).stopped;
|
|
},
|
|
set: function(arg0) {
|
|
if (arg0) {
|
|
const self = this;
|
|
const tmp2 = pd(this);
|
|
tmp2.stopped = true;
|
|
if ("boolean" === typeof tmp2.event.cancelBubble) {
|
|
tmp2.event.cancelBubble = true;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
Object.defineProperty(obj, "returnValue", {
|
|
get: function() {
|
|
return !pd(this).canceled;
|
|
},
|
|
set: function(arg0) {
|
|
if (!arg0) {
|
|
const self = this;
|
|
setCancelFlag(pd(this));
|
|
}
|
|
}
|
|
});
|
|
obj.initEvent = function initEvent() {
|
|
|
|
};
|
|
Event.prototype = obj;
|
|
obj = { value: Event, configurable: true, writable: true };
|
|
Object.defineProperty(Event.prototype, "constructor", obj);
|
|
let tmp5 = "undefined" !== typeof window;
|
|
if (tmp5) {
|
|
const _window = window;
|
|
tmp5 = undefined !== window.Event;
|
|
}
|
|
if (tmp5) {
|
|
let _Object = Object;
|
|
const _window2 = window;
|
|
Object.setPrototypeOf(Event.prototype, window.Event.prototype);
|
|
const _window3 = window;
|
|
class Event {
|
|
constructor(arg0, arg1) {
|
|
self = this;
|
|
obj = { eventTarget: null, event: null, eventPhase: 2, currentTarget: null, canceled: false, stopped: false, immediateStopped: false, passiveListener: null };
|
|
obj.eventTarget = global;
|
|
obj.event = require;
|
|
obj.currentTarget = global;
|
|
timeStamp = require.timeStamp;
|
|
tmp = WeakMap;
|
|
if (!timeStamp) {
|
|
tmp2 = globalThis;
|
|
_Date = Date;
|
|
timeStamp = Date.now();
|
|
}
|
|
obj.timeStamp = timeStamp;
|
|
result = WeakMap.set(self, obj);
|
|
definePropertyResult = Object.defineProperty(self, "isTrusted", { value: false, enumerable: true });
|
|
keys = Object.keys(require);
|
|
for (let num = 0; num < keys.length; num = num + 1) {
|
|
tmp5 = keys[num];
|
|
if (!(tmp5 in self)) {
|
|
_Object = Object;
|
|
tmp6 = defineRedirectDescriptor;
|
|
definePropertyResult1 = Object.defineProperty(self, tmp5, defineRedirectDescriptor(tmp5));
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
const weakMap2 = new WeakMap();
|
|
EventTarget.prototype = {
|
|
addEventListener(arg0, listener, capture) {
|
|
if (null != listener) {
|
|
if ("function" !== typeof listener) {
|
|
if (!isObject(listener)) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError("'listener' should be a function or an object.");
|
|
throw typeError;
|
|
}
|
|
}
|
|
const self = this;
|
|
let obj = getListeners(this);
|
|
let BooleanResult1 = isObject(capture);
|
|
const _Boolean = Boolean;
|
|
if (BooleanResult1) {
|
|
let _BooleanResult = _Boolean(capture.capture);
|
|
} else {
|
|
_BooleanResult = _Boolean(capture);
|
|
}
|
|
let num = 2;
|
|
if (_BooleanResult) {
|
|
num = 1;
|
|
}
|
|
obj = { listener, listenerType: num };
|
|
let BooleanResult = BooleanResult1;
|
|
if (BooleanResult1) {
|
|
const _Boolean2 = Boolean;
|
|
BooleanResult = Boolean(capture.passive);
|
|
}
|
|
obj.passive = BooleanResult;
|
|
if (BooleanResult1) {
|
|
const _Boolean3 = Boolean;
|
|
BooleanResult1 = Boolean(capture.once);
|
|
}
|
|
obj.once = BooleanResult1;
|
|
obj.next = null;
|
|
const value = obj.get(arg0);
|
|
if (undefined !== value) {
|
|
let iter = value;
|
|
let tmp15 = null;
|
|
if (null != value) {
|
|
while (true) {
|
|
if (iter.listener === listener) {
|
|
if (iter.listenerType === num) {
|
|
break;
|
|
}
|
|
}
|
|
let next = iter.next;
|
|
tmp15 = iter;
|
|
iter = next;
|
|
}
|
|
}
|
|
tmp15.next = obj;
|
|
} else {
|
|
const result = obj.set(arg0, obj);
|
|
}
|
|
}
|
|
},
|
|
removeEventListener(arg0, arg1, capture) {
|
|
if (null != arg1) {
|
|
const self = this;
|
|
const obj = getListeners(this);
|
|
const _Boolean = Boolean;
|
|
if (isObject(capture)) {
|
|
let _BooleanResult = _Boolean(capture.capture);
|
|
} else {
|
|
_BooleanResult = _Boolean(capture);
|
|
}
|
|
let num = 2;
|
|
if (_BooleanResult) {
|
|
num = 1;
|
|
}
|
|
let iter = obj.get(arg0);
|
|
let tmp2 = null;
|
|
if (null != iter) {
|
|
while (true) {
|
|
let tmp3 = tmp2;
|
|
let tmp4 = iter;
|
|
if (iter.listener === arg1) {
|
|
if (iter.listenerType === num) {
|
|
break;
|
|
}
|
|
}
|
|
iter = iter.next;
|
|
tmp2 = tmp4;
|
|
}
|
|
if (null !== tmp2) {
|
|
const next = iter.next;
|
|
tmp2.next = next;
|
|
} else if (null !== iter.next) {
|
|
const result = obj.set(arg0, iter.next);
|
|
} else {
|
|
obj.delete(arg0);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
dispatchEvent(type) {
|
|
const self = this;
|
|
if (null != type) {
|
|
if ("string" === typeof type.type) {
|
|
const obj = getListeners(self);
|
|
type = type.type;
|
|
const value = obj.get(type);
|
|
let iter = value;
|
|
if (null == value) {
|
|
return true;
|
|
} else {
|
|
const _Object = Object;
|
|
let tmp36 = getWrapper(Object.getPrototypeOf(type));
|
|
const prototype = tmp36.prototype;
|
|
tmp36 = new tmp36(self, type);
|
|
let tmp27 = null;
|
|
if (null != iter) {
|
|
while (true) {
|
|
let tmp = iter;
|
|
if (iter.once) {
|
|
if (null !== tmp27) {
|
|
let tmp7 = iter;
|
|
tmp27.next = iter.next;
|
|
let tmp2 = tmp27;
|
|
} else {
|
|
let tmp3 = iter;
|
|
if (null !== iter.next) {
|
|
let tmp5 = iter;
|
|
let result = obj.set(type, iter.next);
|
|
tmp2 = tmp27;
|
|
} else {
|
|
let deleteResult = obj.delete(type);
|
|
tmp2 = tmp27;
|
|
}
|
|
}
|
|
} else {
|
|
tmp2 = iter;
|
|
}
|
|
let tmp9 = tmp36;
|
|
let tmp10 = iter;
|
|
let listener = null;
|
|
let tmp8 = setPassiveListener;
|
|
if (iter.passive) {
|
|
let tmp12 = iter;
|
|
listener = iter.listener;
|
|
}
|
|
let tmp8Result = tmp8(tmp42, listener);
|
|
let tmp14 = iter;
|
|
if ("function" === typeof iter.listener) {
|
|
let tmp21 = iter;
|
|
let listener2 = iter.listener;
|
|
let tmp22 = tmp36;
|
|
let callResult = listener2.call(self, tmp42);
|
|
} else {
|
|
let tmp15 = iter;
|
|
let tmp16 = 3 !== iter.listenerType;
|
|
if (tmp16) {
|
|
let tmp17 = iter;
|
|
tmp16 = "function" === typeof iter.listener.handleEvent;
|
|
}
|
|
if (tmp16) {
|
|
let tmp18 = iter;
|
|
listener = iter.listener;
|
|
let tmp19 = tmp36;
|
|
let handleEventResult = listener.handleEvent(tmp42);
|
|
}
|
|
}
|
|
while (true) {
|
|
let tmp24 = isStopped;
|
|
let tmp25 = tmp36;
|
|
if (isStopped(tmp42)) {
|
|
break;
|
|
} else {
|
|
let tmp26 = iter;
|
|
let next = iter.next;
|
|
iter = next;
|
|
tmp27 = tmp2;
|
|
if (null == next) {
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setPassiveListener(tmp36, null);
|
|
pd(tmp36).eventPhase = 0;
|
|
pd(tmp36).currentTarget = null;
|
|
return !tmp36.defaultPrevented;
|
|
}
|
|
}
|
|
}
|
|
const typeError = new TypeError("\"event.type\" should be a string.");
|
|
throw typeError;
|
|
}
|
|
};
|
|
obj = { value: EventTarget, configurable: true, writable: true };
|
|
Object.defineProperty(EventTarget.prototype, "constructor", obj);
|
|
let tmp9 = "undefined" !== typeof window;
|
|
if (tmp9) {
|
|
const _window4 = window;
|
|
tmp9 = undefined !== window.EventTarget;
|
|
}
|
|
if (tmp9) {
|
|
let _Object2 = Object;
|
|
const _window5 = window;
|
|
Object.setPrototypeOf(EventTarget.prototype, window.EventTarget.prototype);
|
|
}
|
|
module.exports.default = EventTarget;
|
|
module.exports.EventTarget = EventTarget;
|
|
module.exports.defineEventAttribute = defineEventAttribute;
|
|
|
|
export { defineEventAttribute };
|
|
export { EventTarget };
|
|
export default EventTarget;
|