1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 | function assertType(condition, message, ...args) {
|
8 | if (!condition) {
|
9 | throw new TypeError(format(message, args));
|
10 | }
|
11 | }
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 | function format(message, args) {
|
18 | let i = 0;
|
19 | return message.replace(/%[os]/gu, () => anyToString(args[i++]));
|
20 | }
|
21 |
|
22 |
|
23 |
|
24 |
|
25 | function anyToString(x) {
|
26 | if (typeof x !== "object" || x === null) {
|
27 | return String(x);
|
28 | }
|
29 | return Object.prototype.toString.call(x);
|
30 | }
|
31 |
|
32 | let currentErrorHandler;
|
33 |
|
34 |
|
35 |
|
36 |
|
37 | function setErrorHandler(value) {
|
38 | assertType(typeof value === "function" || value === undefined, "The error handler must be a function or undefined, but got %o.", value);
|
39 | currentErrorHandler = value;
|
40 | }
|
41 |
|
42 |
|
43 |
|
44 |
|
45 | function reportError(maybeError) {
|
46 | try {
|
47 | const error = maybeError instanceof Error
|
48 | ? maybeError
|
49 | : new Error(anyToString(maybeError));
|
50 |
|
51 | if (currentErrorHandler) {
|
52 | currentErrorHandler(error);
|
53 | return;
|
54 | }
|
55 |
|
56 | if (typeof dispatchEvent === "function" &&
|
57 | typeof ErrorEvent === "function") {
|
58 | dispatchEvent(new ErrorEvent("error", { error, message: error.message }));
|
59 | }
|
60 |
|
61 |
|
62 | else if (typeof process !== "undefined" &&
|
63 | typeof process.emit === "function") {
|
64 | process.emit("uncaughtException", error);
|
65 | return;
|
66 | }
|
67 |
|
68 | console.error(error);
|
69 | }
|
70 | catch (_a) {
|
71 |
|
72 | }
|
73 | }
|
74 |
|
75 |
|
76 |
|
77 |
|
78 |
|
79 | const Global = typeof window !== "undefined"
|
80 | ? window
|
81 | : typeof self !== "undefined"
|
82 | ? self
|
83 | : typeof global !== "undefined"
|
84 | ? global
|
85 | : typeof globalThis !== "undefined"
|
86 | ? globalThis
|
87 | : undefined;
|
88 |
|
89 | let currentWarnHandler;
|
90 |
|
91 |
|
92 |
|
93 |
|
94 | function setWarningHandler(value) {
|
95 | assertType(typeof value === "function" || value === undefined, "The warning handler must be a function or undefined, but got %o.", value);
|
96 | currentWarnHandler = value;
|
97 | }
|
98 |
|
99 |
|
100 |
|
101 | class Warning {
|
102 | constructor(code, message) {
|
103 | this.code = code;
|
104 | this.message = message;
|
105 | }
|
106 | |
107 |
|
108 |
|
109 |
|
110 | warn(...args) {
|
111 | var _a;
|
112 | try {
|
113 |
|
114 | if (currentWarnHandler) {
|
115 | currentWarnHandler({ ...this, args });
|
116 | return;
|
117 | }
|
118 |
|
119 | const stack = ((_a = new Error().stack) !== null && _a !== void 0 ? _a : "").replace(/^(?:.+?\n){2}/gu, "\n");
|
120 | console.warn(this.message, ...args, stack);
|
121 | }
|
122 | catch (_b) {
|
123 |
|
124 | }
|
125 | }
|
126 | }
|
127 |
|
128 | const InitEventWasCalledWhileDispatching = new Warning("W01", "Unable to initialize event under dispatching.");
|
129 | const FalsyWasAssignedToCancelBubble = new Warning("W02", "Assigning any falsy value to 'cancelBubble' property has no effect.");
|
130 | const TruthyWasAssignedToReturnValue = new Warning("W03", "Assigning any truthy value to 'returnValue' property has no effect.");
|
131 | const NonCancelableEventWasCanceled = new Warning("W04", "Unable to preventDefault on non-cancelable events.");
|
132 | const CanceledInPassiveListener = new Warning("W05", "Unable to preventDefault inside passive event listener invocation.");
|
133 | const EventListenerWasDuplicated = new Warning("W06", "An event listener wasn't added because it has been added already: %o, %o");
|
134 | const OptionWasIgnored = new Warning("W07", "The %o option value was abandoned because the event listener wasn't added as duplicated.");
|
135 | const InvalidEventListener = new Warning("W08", "The 'callback' argument must be a function or an object that has 'handleEvent' method: %o");
|
136 | const InvalidAttributeHandler = new Warning("W09", "Event attribute handler must be a function: %o");
|
137 |
|
138 |
|
139 |
|
140 |
|
141 |
|
142 |
|
143 |
|
144 | class Event {
|
145 | |
146 |
|
147 |
|
148 | static get NONE() {
|
149 | return NONE;
|
150 | }
|
151 | |
152 |
|
153 |
|
154 | static get CAPTURING_PHASE() {
|
155 | return CAPTURING_PHASE;
|
156 | }
|
157 | |
158 |
|
159 |
|
160 | static get AT_TARGET() {
|
161 | return AT_TARGET;
|
162 | }
|
163 | |
164 |
|
165 |
|
166 | static get BUBBLING_PHASE() {
|
167 | return BUBBLING_PHASE;
|
168 | }
|
169 | |
170 |
|
171 |
|
172 |
|
173 |
|
174 |
|
175 | constructor(type, eventInitDict) {
|
176 | Object.defineProperty(this, "isTrusted", {
|
177 | value: false,
|
178 | enumerable: true,
|
179 | });
|
180 | const opts = eventInitDict !== null && eventInitDict !== void 0 ? eventInitDict : {};
|
181 | internalDataMap.set(this, {
|
182 | type: String(type),
|
183 | bubbles: Boolean(opts.bubbles),
|
184 | cancelable: Boolean(opts.cancelable),
|
185 | composed: Boolean(opts.composed),
|
186 | target: null,
|
187 | currentTarget: null,
|
188 | stopPropagationFlag: false,
|
189 | stopImmediatePropagationFlag: false,
|
190 | canceledFlag: false,
|
191 | inPassiveListenerFlag: false,
|
192 | dispatchFlag: false,
|
193 | timeStamp: Date.now(),
|
194 | });
|
195 | }
|
196 | |
197 |
|
198 |
|
199 |
|
200 | get type() {
|
201 | return $(this).type;
|
202 | }
|
203 | |
204 |
|
205 |
|
206 |
|
207 | get target() {
|
208 | return $(this).target;
|
209 | }
|
210 | |
211 |
|
212 |
|
213 |
|
214 |
|
215 | get srcElement() {
|
216 | return $(this).target;
|
217 | }
|
218 | |
219 |
|
220 |
|
221 |
|
222 | get currentTarget() {
|
223 | return $(this).currentTarget;
|
224 | }
|
225 | |
226 |
|
227 |
|
228 |
|
229 |
|
230 | composedPath() {
|
231 | const currentTarget = $(this).currentTarget;
|
232 | if (currentTarget) {
|
233 | return [currentTarget];
|
234 | }
|
235 | return [];
|
236 | }
|
237 | |
238 |
|
239 |
|
240 | get NONE() {
|
241 | return NONE;
|
242 | }
|
243 | |
244 |
|
245 |
|
246 | get CAPTURING_PHASE() {
|
247 | return CAPTURING_PHASE;
|
248 | }
|
249 | |
250 |
|
251 |
|
252 | get AT_TARGET() {
|
253 | return AT_TARGET;
|
254 | }
|
255 | |
256 |
|
257 |
|
258 | get BUBBLING_PHASE() {
|
259 | return BUBBLING_PHASE;
|
260 | }
|
261 | |
262 |
|
263 |
|
264 |
|
265 | get eventPhase() {
|
266 | return $(this).dispatchFlag ? 2 : 0;
|
267 | }
|
268 | |
269 |
|
270 |
|
271 |
|
272 |
|
273 | stopPropagation() {
|
274 | $(this).stopPropagationFlag = true;
|
275 | }
|
276 | |
277 |
|
278 |
|
279 |
|
280 |
|
281 | get cancelBubble() {
|
282 | return $(this).stopPropagationFlag;
|
283 | }
|
284 | |
285 |
|
286 |
|
287 |
|
288 |
|
289 | set cancelBubble(value) {
|
290 | if (value) {
|
291 | $(this).stopPropagationFlag = true;
|
292 | }
|
293 | else {
|
294 | FalsyWasAssignedToCancelBubble.warn();
|
295 | }
|
296 | }
|
297 | |
298 |
|
299 |
|
300 |
|
301 | stopImmediatePropagation() {
|
302 | const data = $(this);
|
303 | data.stopPropagationFlag = data.stopImmediatePropagationFlag = true;
|
304 | }
|
305 | |
306 |
|
307 |
|
308 |
|
309 | get bubbles() {
|
310 | return $(this).bubbles;
|
311 | }
|
312 | |
313 |
|
314 |
|
315 |
|
316 | get cancelable() {
|
317 | return $(this).cancelable;
|
318 | }
|
319 | |
320 |
|
321 |
|
322 |
|
323 |
|
324 | get returnValue() {
|
325 | return !$(this).canceledFlag;
|
326 | }
|
327 | |
328 |
|
329 |
|
330 |
|
331 |
|
332 | set returnValue(value) {
|
333 | if (!value) {
|
334 | setCancelFlag($(this));
|
335 | }
|
336 | else {
|
337 | TruthyWasAssignedToReturnValue.warn();
|
338 | }
|
339 | }
|
340 | |
341 |
|
342 |
|
343 |
|
344 | preventDefault() {
|
345 | setCancelFlag($(this));
|
346 | }
|
347 | |
348 |
|
349 |
|
350 |
|
351 | get defaultPrevented() {
|
352 | return $(this).canceledFlag;
|
353 | }
|
354 | |
355 |
|
356 |
|
357 | get composed() {
|
358 | return $(this).composed;
|
359 | }
|
360 | |
361 |
|
362 |
|
363 |
|
364 | get isTrusted() {
|
365 | return false;
|
366 | }
|
367 | |
368 |
|
369 |
|
370 | get timeStamp() {
|
371 | return $(this).timeStamp;
|
372 | }
|
373 | |
374 |
|
375 |
|
376 | initEvent(type, bubbles = false, cancelable = false) {
|
377 | const data = $(this);
|
378 | if (data.dispatchFlag) {
|
379 | InitEventWasCalledWhileDispatching.warn();
|
380 | return;
|
381 | }
|
382 | internalDataMap.set(this, {
|
383 | ...data,
|
384 | type: String(type),
|
385 | bubbles: Boolean(bubbles),
|
386 | cancelable: Boolean(cancelable),
|
387 | target: null,
|
388 | currentTarget: null,
|
389 | stopPropagationFlag: false,
|
390 | stopImmediatePropagationFlag: false,
|
391 | canceledFlag: false,
|
392 | });
|
393 | }
|
394 | }
|
395 |
|
396 |
|
397 |
|
398 | const NONE = 0;
|
399 | const CAPTURING_PHASE = 1;
|
400 | const AT_TARGET = 2;
|
401 | const BUBBLING_PHASE = 3;
|
402 |
|
403 |
|
404 |
|
405 | const internalDataMap = new WeakMap();
|
406 |
|
407 |
|
408 |
|
409 |
|
410 |
|
411 |
|
412 | function $(event, name = "this") {
|
413 | const retv = internalDataMap.get(event);
|
414 | assertType(retv != null, "'%s' must be an object that Event constructor created, but got another one: %o", name, event);
|
415 | return retv;
|
416 | }
|
417 |
|
418 |
|
419 |
|
420 |
|
421 | function setCancelFlag(data) {
|
422 | if (data.inPassiveListenerFlag) {
|
423 | CanceledInPassiveListener.warn();
|
424 | return;
|
425 | }
|
426 | if (!data.cancelable) {
|
427 | NonCancelableEventWasCanceled.warn();
|
428 | return;
|
429 | }
|
430 | data.canceledFlag = true;
|
431 | }
|
432 |
|
433 | Object.defineProperty(Event, "NONE", { enumerable: true });
|
434 | Object.defineProperty(Event, "CAPTURING_PHASE", { enumerable: true });
|
435 | Object.defineProperty(Event, "AT_TARGET", { enumerable: true });
|
436 | Object.defineProperty(Event, "BUBBLING_PHASE", { enumerable: true });
|
437 | const keys = Object.getOwnPropertyNames(Event.prototype);
|
438 | for (let i = 0; i < keys.length; ++i) {
|
439 | if (keys[i] === "constructor") {
|
440 | continue;
|
441 | }
|
442 | Object.defineProperty(Event.prototype, keys[i], { enumerable: true });
|
443 | }
|
444 |
|
445 | if (typeof Global !== "undefined" && typeof Global.Event !== "undefined") {
|
446 | Object.setPrototypeOf(Event.prototype, Global.Event.prototype);
|
447 | }
|
448 |
|
449 |
|
450 |
|
451 |
|
452 |
|
453 | function createInvalidStateError(message) {
|
454 | if (Global.DOMException) {
|
455 | return new Global.DOMException(message, "InvalidStateError");
|
456 | }
|
457 | if (DOMException == null) {
|
458 | DOMException = class DOMException extends Error {
|
459 | constructor(msg) {
|
460 | super(msg);
|
461 | if (Error.captureStackTrace) {
|
462 | Error.captureStackTrace(this, DOMException);
|
463 | }
|
464 | }
|
465 |
|
466 | get code() {
|
467 | return 11;
|
468 | }
|
469 |
|
470 | get name() {
|
471 | return "InvalidStateError";
|
472 | }
|
473 | };
|
474 | Object.defineProperties(DOMException.prototype, {
|
475 | code: { enumerable: true },
|
476 | name: { enumerable: true },
|
477 | });
|
478 | defineErrorCodeProperties(DOMException);
|
479 | defineErrorCodeProperties(DOMException.prototype);
|
480 | }
|
481 | return new DOMException(message);
|
482 | }
|
483 |
|
484 |
|
485 |
|
486 | let DOMException;
|
487 | const ErrorCodeMap = {
|
488 | INDEX_SIZE_ERR: 1,
|
489 | DOMSTRING_SIZE_ERR: 2,
|
490 | HIERARCHY_REQUEST_ERR: 3,
|
491 | WRONG_DOCUMENT_ERR: 4,
|
492 | INVALID_CHARACTER_ERR: 5,
|
493 | NO_DATA_ALLOWED_ERR: 6,
|
494 | NO_MODIFICATION_ALLOWED_ERR: 7,
|
495 | NOT_FOUND_ERR: 8,
|
496 | NOT_SUPPORTED_ERR: 9,
|
497 | INUSE_ATTRIBUTE_ERR: 10,
|
498 | INVALID_STATE_ERR: 11,
|
499 | SYNTAX_ERR: 12,
|
500 | INVALID_MODIFICATION_ERR: 13,
|
501 | NAMESPACE_ERR: 14,
|
502 | INVALID_ACCESS_ERR: 15,
|
503 | VALIDATION_ERR: 16,
|
504 | TYPE_MISMATCH_ERR: 17,
|
505 | SECURITY_ERR: 18,
|
506 | NETWORK_ERR: 19,
|
507 | ABORT_ERR: 20,
|
508 | URL_MISMATCH_ERR: 21,
|
509 | QUOTA_EXCEEDED_ERR: 22,
|
510 | TIMEOUT_ERR: 23,
|
511 | INVALID_NODE_TYPE_ERR: 24,
|
512 | DATA_CLONE_ERR: 25,
|
513 | };
|
514 | function defineErrorCodeProperties(obj) {
|
515 | const keys = Object.keys(ErrorCodeMap);
|
516 | for (let i = 0; i < keys.length; ++i) {
|
517 | const key = keys[i];
|
518 | const value = ErrorCodeMap[key];
|
519 | Object.defineProperty(obj, key, {
|
520 | get() {
|
521 | return value;
|
522 | },
|
523 | configurable: true,
|
524 | enumerable: true,
|
525 | });
|
526 | }
|
527 | }
|
528 |
|
529 |
|
530 |
|
531 |
|
532 |
|
533 |
|
534 | class EventWrapper extends Event {
|
535 | |
536 |
|
537 |
|
538 |
|
539 | static wrap(event) {
|
540 | return new (getWrapperClassOf(event))(event);
|
541 | }
|
542 | constructor(event) {
|
543 | super(event.type, {
|
544 | bubbles: event.bubbles,
|
545 | cancelable: event.cancelable,
|
546 | composed: event.composed,
|
547 | });
|
548 | if (event.cancelBubble) {
|
549 | super.stopPropagation();
|
550 | }
|
551 | if (event.defaultPrevented) {
|
552 | super.preventDefault();
|
553 | }
|
554 | internalDataMap$1.set(this, { original: event });
|
555 |
|
556 | const keys = Object.keys(event);
|
557 | for (let i = 0; i < keys.length; ++i) {
|
558 | const key = keys[i];
|
559 | if (!(key in this)) {
|
560 | Object.defineProperty(this, key, defineRedirectDescriptor(event, key));
|
561 | }
|
562 | }
|
563 | }
|
564 | stopPropagation() {
|
565 | super.stopPropagation();
|
566 | const { original } = $$1(this);
|
567 | if ("stopPropagation" in original) {
|
568 | original.stopPropagation();
|
569 | }
|
570 | }
|
571 | get cancelBubble() {
|
572 | return super.cancelBubble;
|
573 | }
|
574 | set cancelBubble(value) {
|
575 | super.cancelBubble = value;
|
576 | const { original } = $$1(this);
|
577 | if ("cancelBubble" in original) {
|
578 | original.cancelBubble = value;
|
579 | }
|
580 | }
|
581 | stopImmediatePropagation() {
|
582 | super.stopImmediatePropagation();
|
583 | const { original } = $$1(this);
|
584 | if ("stopImmediatePropagation" in original) {
|
585 | original.stopImmediatePropagation();
|
586 | }
|
587 | }
|
588 | get returnValue() {
|
589 | return super.returnValue;
|
590 | }
|
591 | set returnValue(value) {
|
592 | super.returnValue = value;
|
593 | const { original } = $$1(this);
|
594 | if ("returnValue" in original) {
|
595 | original.returnValue = value;
|
596 | }
|
597 | }
|
598 | preventDefault() {
|
599 | super.preventDefault();
|
600 | const { original } = $$1(this);
|
601 | if ("preventDefault" in original) {
|
602 | original.preventDefault();
|
603 | }
|
604 | }
|
605 | get timeStamp() {
|
606 | const { original } = $$1(this);
|
607 | if ("timeStamp" in original) {
|
608 | return original.timeStamp;
|
609 | }
|
610 | return super.timeStamp;
|
611 | }
|
612 | }
|
613 |
|
614 |
|
615 |
|
616 | const internalDataMap$1 = new WeakMap();
|
617 |
|
618 |
|
619 |
|
620 |
|
621 |
|
622 | function $$1(event) {
|
623 | const retv = internalDataMap$1.get(event);
|
624 | assertType(retv != null, "'this' is expected an Event object, but got", event);
|
625 | return retv;
|
626 | }
|
627 | /**
|
628 | * Cache for wrapper classes.
|
629 | * @type {WeakMap<Object, Function>}
|
630 | * @private
|
631 | */
|
632 | const wrapperClassCache = new WeakMap();
|
633 |
|
634 | wrapperClassCache.set(Object.prototype, EventWrapper);
|
635 | if (typeof Global !== "undefined" && typeof Global.Event !== "undefined") {
|
636 | wrapperClassCache.set(Global.Event.prototype, EventWrapper);
|
637 | }
|
638 |
|
639 |
|
640 |
|
641 |
|
642 | function getWrapperClassOf(originalEvent) {
|
643 | const prototype = Object.getPrototypeOf(originalEvent);
|
644 | if (prototype == null) {
|
645 | return EventWrapper;
|
646 | }
|
647 | let wrapper = wrapperClassCache.get(prototype);
|
648 | if (wrapper == null) {
|
649 | wrapper = defineWrapper(getWrapperClassOf(prototype), prototype);
|
650 | wrapperClassCache.set(prototype, wrapper);
|
651 | }
|
652 | return wrapper;
|
653 | }
|
654 |
|
655 |
|
656 |
|
657 |
|
658 |
|
659 | function defineWrapper(BaseEventWrapper, originalPrototype) {
|
660 | class CustomEventWrapper extends BaseEventWrapper {
|
661 | }
|
662 | const keys = Object.keys(originalPrototype);
|
663 | for (let i = 0; i < keys.length; ++i) {
|
664 | Object.defineProperty(CustomEventWrapper.prototype, keys[i], defineRedirectDescriptor(originalPrototype, keys[i]));
|
665 | }
|
666 | return CustomEventWrapper;
|
667 | }
|
668 |
|
669 |
|
670 |
|
671 | function defineRedirectDescriptor(obj, key) {
|
672 | const d = Object.getOwnPropertyDescriptor(obj, key);
|
673 | return {
|
674 | get() {
|
675 | const original = $$1(this).original;
|
676 | const value = original[key];
|
677 | if (typeof value === "function") {
|
678 | return value.bind(original);
|
679 | }
|
680 | return value;
|
681 | },
|
682 | set(value) {
|
683 | const original = $$1(this).original;
|
684 | original[key] = value;
|
685 | },
|
686 | configurable: d.configurable,
|
687 | enumerable: d.enumerable,
|
688 | };
|
689 | }
|
690 |
|
691 |
|
692 |
|
693 |
|
694 |
|
695 |
|
696 |
|
697 |
|
698 |
|
699 |
|
700 | function createListener(callback, capture, passive, once, signal, signalListener) {
|
701 | return {
|
702 | callback,
|
703 | flags: (capture ? 1 : 0) |
|
704 | (passive ? 2 : 0) |
|
705 | (once ? 4 : 0),
|
706 | signal,
|
707 | signalListener,
|
708 | };
|
709 | }
|
710 |
|
711 |
|
712 |
|
713 |
|
714 | function setRemoved(listener) {
|
715 | listener.flags |= 8 ;
|
716 | }
|
717 |
|
718 |
|
719 |
|
720 |
|
721 | function isCapture(listener) {
|
722 | return (listener.flags & 1 ) === 1 ;
|
723 | }
|
724 |
|
725 |
|
726 |
|
727 |
|
728 | function isPassive(listener) {
|
729 | return (listener.flags & 2 ) === 2 ;
|
730 | }
|
731 |
|
732 |
|
733 |
|
734 |
|
735 | function isOnce(listener) {
|
736 | return (listener.flags & 4 ) === 4 ;
|
737 | }
|
738 |
|
739 |
|
740 |
|
741 |
|
742 | function isRemoved(listener) {
|
743 | return (listener.flags & 8 ) === 8 ;
|
744 | }
|
745 |
|
746 |
|
747 |
|
748 |
|
749 |
|
750 |
|
751 |
|
752 | function invokeCallback({ callback }, target, event) {
|
753 | try {
|
754 | if (typeof callback === "function") {
|
755 | callback.call(target, event);
|
756 | }
|
757 | else if (typeof callback.handleEvent === "function") {
|
758 | callback.handleEvent(event);
|
759 | }
|
760 | }
|
761 | catch (thrownError) {
|
762 | reportError(thrownError);
|
763 | }
|
764 | }
|
765 |
|
766 |
|
767 |
|
768 |
|
769 |
|
770 |
|
771 |
|
772 |
|
773 | function findIndexOfListener({ listeners }, callback, capture) {
|
774 | for (let i = 0; i < listeners.length; ++i) {
|
775 | if (listeners[i].callback === callback &&
|
776 | isCapture(listeners[i]) === capture) {
|
777 | return i;
|
778 | }
|
779 | }
|
780 | return -1;
|
781 | }
|
782 |
|
783 |
|
784 |
|
785 |
|
786 |
|
787 |
|
788 |
|
789 |
|
790 |
|
791 |
|
792 | function addListener(list, callback, capture, passive, once, signal) {
|
793 | let signalListener;
|
794 | if (signal) {
|
795 | signalListener = removeListener.bind(null, list, callback, capture);
|
796 | signal.addEventListener("abort", signalListener);
|
797 | }
|
798 | const listener = createListener(callback, capture, passive, once, signal, signalListener);
|
799 | if (list.cow) {
|
800 | list.cow = false;
|
801 | list.listeners = [...list.listeners, listener];
|
802 | }
|
803 | else {
|
804 | list.listeners.push(listener);
|
805 | }
|
806 | return listener;
|
807 | }
|
808 |
|
809 |
|
810 |
|
811 |
|
812 |
|
813 |
|
814 |
|
815 | function removeListener(list, callback, capture) {
|
816 | const index = findIndexOfListener(list, callback, capture);
|
817 | if (index !== -1) {
|
818 | return removeListenerAt(list, index);
|
819 | }
|
820 | return false;
|
821 | }
|
822 |
|
823 |
|
824 |
|
825 |
|
826 |
|
827 |
|
828 |
|
829 | function removeListenerAt(list, index, disableCow = false) {
|
830 | const listener = list.listeners[index];
|
831 |
|
832 | setRemoved(listener);
|
833 |
|
834 | if (listener.signal) {
|
835 | listener.signal.removeEventListener("abort", listener.signalListener);
|
836 | }
|
837 |
|
838 | if (list.cow && !disableCow) {
|
839 | list.cow = false;
|
840 | list.listeners = list.listeners.filter((_, i) => i !== index);
|
841 | return false;
|
842 | }
|
843 | list.listeners.splice(index, 1);
|
844 | return true;
|
845 | }
|
846 |
|
847 |
|
848 |
|
849 |
|
850 | function createListenerListMap() {
|
851 | return Object.create(null);
|
852 | }
|
853 |
|
854 |
|
855 |
|
856 |
|
857 |
|
858 |
|
859 | function ensureListenerList(listenerMap, type) {
|
860 | var _a;
|
861 | return ((_a = listenerMap[type]) !== null && _a !== void 0 ? _a : (listenerMap[type] = {
|
862 | attrCallback: undefined,
|
863 | attrListener: undefined,
|
864 | cow: false,
|
865 | listeners: [],
|
866 | }));
|
867 | }
|
868 |
|
869 |
|
870 |
|
871 |
|
872 |
|
873 | class EventTarget {
|
874 | |
875 |
|
876 |
|
877 | constructor() {
|
878 | internalDataMap$2.set(this, createListenerListMap());
|
879 | }
|
880 | // Implementation
|
881 | addEventListener(type0, callback0, options0) {
|
882 | const listenerMap = $$2(this);
|
883 | const { callback, capture, once, passive, signal, type, } = normalizeAddOptions(type0, callback0, options0);
|
884 | if (callback == null || (signal === null || signal === void 0 ? void 0 : signal.aborted)) {
|
885 | return;
|
886 | }
|
887 | const list = ensureListenerList(listenerMap, type);
|
888 |
|
889 | const i = findIndexOfListener(list, callback, capture);
|
890 | if (i !== -1) {
|
891 | warnDuplicate(list.listeners[i], passive, once, signal);
|
892 | return;
|
893 | }
|
894 |
|
895 | addListener(list, callback, capture, passive, once, signal);
|
896 | }
|
897 |
|
898 | removeEventListener(type0, callback0, options0) {
|
899 | const listenerMap = $$2(this);
|
900 | const { callback, capture, type } = normalizeOptions(type0, callback0, options0);
|
901 | const list = listenerMap[type];
|
902 | if (callback != null && list) {
|
903 | removeListener(list, callback, capture);
|
904 | }
|
905 | }
|
906 |
|
907 | dispatchEvent(e) {
|
908 | const list = $$2(this)[String(e.type)];
|
909 | if (list == null) {
|
910 | return true;
|
911 | }
|
912 | const event = e instanceof Event ? e : EventWrapper.wrap(e);
|
913 | const eventData = $(event, "event");
|
914 | if (eventData.dispatchFlag) {
|
915 | throw createInvalidStateError("This event has been in dispatching.");
|
916 | }
|
917 | eventData.dispatchFlag = true;
|
918 | eventData.target = eventData.currentTarget = this;
|
919 | if (!eventData.stopPropagationFlag) {
|
920 | const { cow, listeners } = list;
|
921 |
|
922 | list.cow = true;
|
923 |
|
924 | for (let i = 0; i < listeners.length; ++i) {
|
925 | const listener = listeners[i];
|
926 |
|
927 | if (isRemoved(listener)) {
|
928 | continue;
|
929 | }
|
930 |
|
931 | if (isOnce(listener) && removeListenerAt(list, i, !cow)) {
|
932 |
|
933 |
|
934 | i -= 1;
|
935 | }
|
936 |
|
937 | eventData.inPassiveListenerFlag = isPassive(listener);
|
938 | invokeCallback(listener, this, event);
|
939 | eventData.inPassiveListenerFlag = false;
|
940 |
|
941 | if (eventData.stopImmediatePropagationFlag) {
|
942 | break;
|
943 | }
|
944 | }
|
945 |
|
946 | if (!cow) {
|
947 | list.cow = false;
|
948 | }
|
949 | }
|
950 | eventData.target = null;
|
951 | eventData.currentTarget = null;
|
952 | eventData.stopImmediatePropagationFlag = false;
|
953 | eventData.stopPropagationFlag = false;
|
954 | eventData.dispatchFlag = false;
|
955 | return !eventData.canceledFlag;
|
956 | }
|
957 | }
|
958 |
|
959 |
|
960 |
|
961 | const internalDataMap$2 = new WeakMap();
|
962 |
|
963 |
|
964 |
|
965 |
|
966 |
|
967 |
|
968 | function $$2(target, name = "this") {
|
969 | const retv = internalDataMap$2.get(target);
|
970 | assertType(retv != null, "'%s' must be an object that EventTarget constructor created, but got another one: %o", name, target);
|
971 | return retv;
|
972 | }
|
973 | /**
|
974 | * Normalize options.
|
975 | * @param options The options to normalize.
|
976 | */
|
977 | function normalizeAddOptions(type, callback, options) {
|
978 | var _a;
|
979 | assertCallback(callback);
|
980 | if (typeof options === "object" && options !== null) {
|
981 | return {
|
982 | type: String(type),
|
983 | callback: callback !== null && callback !== void 0 ? callback : undefined,
|
984 | capture: Boolean(options.capture),
|
985 | passive: Boolean(options.passive),
|
986 | once: Boolean(options.once),
|
987 | signal: (_a = options.signal) !== null && _a !== void 0 ? _a : undefined,
|
988 | };
|
989 | }
|
990 | return {
|
991 | type: String(type),
|
992 | callback: callback !== null && callback !== void 0 ? callback : undefined,
|
993 | capture: Boolean(options),
|
994 | passive: false,
|
995 | once: false,
|
996 | signal: undefined,
|
997 | };
|
998 | }
|
999 |
|
1000 |
|
1001 |
|
1002 |
|
1003 | function normalizeOptions(type, callback, options) {
|
1004 | assertCallback(callback);
|
1005 | if (typeof options === "object" && options !== null) {
|
1006 | return {
|
1007 | type: String(type),
|
1008 | callback: callback !== null && callback !== void 0 ? callback : undefined,
|
1009 | capture: Boolean(options.capture),
|
1010 | };
|
1011 | }
|
1012 | return {
|
1013 | type: String(type),
|
1014 | callback: callback !== null && callback !== void 0 ? callback : undefined,
|
1015 | capture: Boolean(options),
|
1016 | };
|
1017 | }
|
1018 |
|
1019 |
|
1020 |
|
1021 |
|
1022 | function assertCallback(callback) {
|
1023 | if (typeof callback === "function" ||
|
1024 | (typeof callback === "object" &&
|
1025 | callback !== null &&
|
1026 | typeof callback.handleEvent === "function")) {
|
1027 | return;
|
1028 | }
|
1029 | if (callback == null || typeof callback === "object") {
|
1030 | InvalidEventListener.warn(callback);
|
1031 | return;
|
1032 | }
|
1033 | throw new TypeError(format(InvalidEventListener.message, [callback]));
|
1034 | }
|
1035 |
|
1036 |
|
1037 |
|
1038 |
|
1039 |
|
1040 |
|
1041 |
|
1042 | function warnDuplicate(listener, passive, once, signal) {
|
1043 | EventListenerWasDuplicated.warn(isCapture(listener) ? "capture" : "bubble", listener.callback);
|
1044 | if (isPassive(listener) !== passive) {
|
1045 | OptionWasIgnored.warn("passive");
|
1046 | }
|
1047 | if (isOnce(listener) !== once) {
|
1048 | OptionWasIgnored.warn("once");
|
1049 | }
|
1050 | if (listener.signal !== signal) {
|
1051 | OptionWasIgnored.warn("signal");
|
1052 | }
|
1053 | }
|
1054 |
|
1055 | const keys$1 = Object.getOwnPropertyNames(EventTarget.prototype);
|
1056 | for (let i = 0; i < keys$1.length; ++i) {
|
1057 | if (keys$1[i] === "constructor") {
|
1058 | continue;
|
1059 | }
|
1060 | Object.defineProperty(EventTarget.prototype, keys$1[i], { enumerable: true });
|
1061 | }
|
1062 |
|
1063 | if (typeof Global !== "undefined" &&
|
1064 | typeof Global.EventTarget !== "undefined") {
|
1065 | Object.setPrototypeOf(EventTarget.prototype, Global.EventTarget.prototype);
|
1066 | }
|
1067 |
|
1068 |
|
1069 |
|
1070 |
|
1071 |
|
1072 |
|
1073 | function getEventAttributeValue(target, type) {
|
1074 | var _a, _b;
|
1075 | const listMap = $$2(target, "target");
|
1076 | return (_b = (_a = listMap[type]) === null || _a === void 0 ? void 0 : _a.attrCallback) !== null && _b !== void 0 ? _b : null;
|
1077 | }
|
1078 |
|
1079 |
|
1080 |
|
1081 |
|
1082 |
|
1083 |
|
1084 | function setEventAttributeValue(target, type, callback) {
|
1085 | if (callback != null && typeof callback !== "function") {
|
1086 | InvalidAttributeHandler.warn(callback);
|
1087 | }
|
1088 | if (typeof callback === "function" ||
|
1089 | (typeof callback === "object" && callback !== null)) {
|
1090 | upsertEventAttributeListener(target, type, callback);
|
1091 | }
|
1092 | else {
|
1093 | removeEventAttributeListener(target, type);
|
1094 | }
|
1095 | }
|
1096 |
|
1097 |
|
1098 |
|
1099 |
|
1100 |
|
1101 |
|
1102 |
|
1103 |
|
1104 |
|
1105 | function upsertEventAttributeListener(target, type, callback) {
|
1106 | const list = ensureListenerList($$2(target, "target"), String(type));
|
1107 | list.attrCallback = callback;
|
1108 | if (list.attrListener == null) {
|
1109 | list.attrListener = addListener(list, defineEventAttributeCallback(list), false, false, false, undefined);
|
1110 | }
|
1111 | }
|
1112 |
|
1113 |
|
1114 |
|
1115 |
|
1116 |
|
1117 |
|
1118 | function removeEventAttributeListener(target, type) {
|
1119 | const listMap = $$2(target, "target");
|
1120 | const list = listMap[String(type)];
|
1121 | if (list && list.attrListener) {
|
1122 | removeListener(list, list.attrListener.callback, false);
|
1123 | list.attrCallback = list.attrListener = undefined;
|
1124 | }
|
1125 | }
|
1126 |
|
1127 |
|
1128 |
|
1129 |
|
1130 |
|
1131 | function defineEventAttributeCallback(list) {
|
1132 | return function (event) {
|
1133 | const callback = list.attrCallback;
|
1134 | if (typeof callback === "function") {
|
1135 | callback.call(this, event);
|
1136 | }
|
1137 | };
|
1138 | }
|
1139 |
|
1140 |
|
1141 |
|
1142 |
|
1143 |
|
1144 |
|
1145 | function defineCustomEventTarget(...types) {
|
1146 | class CustomEventTarget extends EventTarget {
|
1147 | }
|
1148 | for (let i = 0; i < types.length; ++i) {
|
1149 | defineEventAttribute(CustomEventTarget.prototype, types[i]);
|
1150 | }
|
1151 | return CustomEventTarget;
|
1152 | }
|
1153 |
|
1154 |
|
1155 |
|
1156 |
|
1157 |
|
1158 |
|
1159 |
|
1160 | function defineEventAttribute(target, type, _eventClass) {
|
1161 | Object.defineProperty(target, `on${type}`, {
|
1162 | get() {
|
1163 | return getEventAttributeValue(this, type);
|
1164 | },
|
1165 | set(value) {
|
1166 | setEventAttributeValue(this, type, value);
|
1167 | },
|
1168 | configurable: true,
|
1169 | enumerable: true,
|
1170 | });
|
1171 | }
|
1172 |
|
1173 | export default EventTarget;
|
1174 | export { Event, EventTarget, defineCustomEventTarget, defineEventAttribute, getEventAttributeValue, setErrorHandler, setEventAttributeValue, setWarningHandler };
|
1175 |
|