2422 lines
117 KiB
JavaScript
2422 lines
117 KiB
JavaScript
|
import { performance } from 'node:perf_hooks';
|
||
|
|
import { webcrypto } from 'node:crypto';
|
||
|
|
export { webcrypto as crypto } from 'node:crypto';
|
||
|
|
import { ByteLengthQueuingStrategy, CountQueuingStrategy, ReadableByteStreamController, ReadableStream, ReadableStreamBYOBReader, ReadableStreamBYOBRequest, ReadableStreamDefaultController, ReadableStreamDefaultReader, TransformStream, WritableStream, WritableStreamDefaultController, WritableStreamDefaultWriter } from 'node:stream/web';
|
||
|
|
export { ByteLengthQueuingStrategy, CountQueuingStrategy, ReadableByteStreamController, ReadableStream, ReadableStreamBYOBReader, ReadableStreamBYOBRequest, ReadableStreamDefaultController, ReadableStreamDefaultReader, TransformStream, WritableStream, WritableStreamDefaultController, WritableStreamDefaultWriter } from 'node:stream/web';
|
||
|
|
import { File, FormData, Headers, Request, Response, fetch } from 'undici';
|
||
|
|
export { File, FormData, Headers, Request, Response, fetch } from 'undici';
|
||
|
|
import { setTimeout as setTimeout$1, clearTimeout as clearTimeout$1 } from 'node:timers';
|
||
|
|
|
||
|
|
/** Returns the function bound to the given object. */
|
||
|
|
const __function_bind = Function.bind.bind(Function.call);
|
||
|
|
/** Returns whether the object prototype exists in another object. */
|
||
|
|
const __object_isPrototypeOf = Function.call.bind(Object.prototype.isPrototypeOf);
|
||
|
|
/** Current high resolution millisecond timestamp. */
|
||
|
|
const __performance_now = performance.now;
|
||
|
|
// @ts-expect-error
|
||
|
|
const INTERNALS = new WeakMap();
|
||
|
|
const internalsOf = (target, className, propName) => {
|
||
|
|
const internals = INTERNALS.get(target);
|
||
|
|
if (!internals)
|
||
|
|
throw new TypeError(`${className}.${propName} can only be used on instances of ${className}`);
|
||
|
|
return internals;
|
||
|
|
};
|
||
|
|
const allowStringTag = (value) => (value.prototype[Symbol.toStringTag] = value.name);
|
||
|
|
/** Returns any kind of path as a posix path. */
|
||
|
|
const pathToPosix = (pathname) => String(pathname == null ? '' : pathname)
|
||
|
|
.replace(
|
||
|
|
// convert slashes
|
||
|
|
/\\+/g, '/')
|
||
|
|
.replace(
|
||
|
|
// prefix a slash to drive letters
|
||
|
|
/^(?=[A-Za-z]:\/)/, '/')
|
||
|
|
.replace(
|
||
|
|
// encode path characters
|
||
|
|
/%/g, '%25')
|
||
|
|
.replace(/\n/g, '%0A')
|
||
|
|
.replace(/\r/g, '%0D')
|
||
|
|
.replace(/\t/g, '%09');
|
||
|
|
|
||
|
|
class DOMException extends Error {
|
||
|
|
constructor(message = '', name = 'Error') {
|
||
|
|
super(message);
|
||
|
|
this.code = 0;
|
||
|
|
this.name = name;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
DOMException.INDEX_SIZE_ERR = 1;
|
||
|
|
DOMException.DOMSTRING_SIZE_ERR = 2;
|
||
|
|
DOMException.HIERARCHY_REQUEST_ERR = 3;
|
||
|
|
DOMException.WRONG_DOCUMENT_ERR = 4;
|
||
|
|
DOMException.INVALID_CHARACTER_ERR = 5;
|
||
|
|
DOMException.NO_DATA_ALLOWED_ERR = 6;
|
||
|
|
DOMException.NO_MODIFICATION_ALLOWED_ERR = 7;
|
||
|
|
DOMException.NOT_FOUND_ERR = 8;
|
||
|
|
DOMException.NOT_SUPPORTED_ERR = 9;
|
||
|
|
DOMException.INUSE_ATTRIBUTE_ERR = 10;
|
||
|
|
DOMException.INVALID_STATE_ERR = 11;
|
||
|
|
DOMException.SYNTAX_ERR = 12;
|
||
|
|
DOMException.INVALID_MODIFICATION_ERR = 13;
|
||
|
|
DOMException.NAMESPACE_ERR = 14;
|
||
|
|
DOMException.INVALID_ACCESS_ERR = 15;
|
||
|
|
DOMException.VALIDATION_ERR = 16;
|
||
|
|
DOMException.TYPE_MISMATCH_ERR = 17;
|
||
|
|
DOMException.SECURITY_ERR = 18;
|
||
|
|
DOMException.NETWORK_ERR = 19;
|
||
|
|
DOMException.ABORT_ERR = 20;
|
||
|
|
DOMException.URL_MISMATCH_ERR = 21;
|
||
|
|
DOMException.QUOTA_EXCEEDED_ERR = 22;
|
||
|
|
DOMException.TIMEOUT_ERR = 23;
|
||
|
|
DOMException.INVALID_NODE_TYPE_ERR = 24;
|
||
|
|
DOMException.DATA_CLONE_ERR = 25;
|
||
|
|
allowStringTag(DOMException);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Assert a condition.
|
||
|
|
* @param condition The condition that it should satisfy.
|
||
|
|
* @param message The error message.
|
||
|
|
* @param args The arguments for replacing placeholders in the message.
|
||
|
|
*/
|
||
|
|
function assertType(condition, message, ...args) {
|
||
|
|
if (!condition) {
|
||
|
|
throw new TypeError(format(message, args));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Convert a text and arguments to one string.
|
||
|
|
* @param message The formating text
|
||
|
|
* @param args The arguments.
|
||
|
|
*/
|
||
|
|
function format(message, args) {
|
||
|
|
let i = 0;
|
||
|
|
return message.replace(/%[os]/gu, () => anyToString(args[i++]));
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Convert a value to a string representation.
|
||
|
|
* @param x The value to get the string representation.
|
||
|
|
*/
|
||
|
|
function anyToString(x) {
|
||
|
|
if (typeof x !== "object" || x === null) {
|
||
|
|
return String(x);
|
||
|
|
}
|
||
|
|
return Object.prototype.toString.call(x);
|
||
|
|
}
|
||
|
|
|
||
|
|
let currentErrorHandler;
|
||
|
|
/**
|
||
|
|
* Print a error message.
|
||
|
|
* @param maybeError The error object.
|
||
|
|
*/
|
||
|
|
function reportError(maybeError) {
|
||
|
|
try {
|
||
|
|
const error = maybeError instanceof Error
|
||
|
|
? maybeError
|
||
|
|
: new Error(anyToString(maybeError));
|
||
|
|
// Call the user-defined error handler if exists.
|
||
|
|
if (currentErrorHandler) ;
|
||
|
|
// Dispatch an `error` event if this is on a browser.
|
||
|
|
if (typeof dispatchEvent === "function" &&
|
||
|
|
typeof ErrorEvent === "function") {
|
||
|
|
dispatchEvent(new ErrorEvent("error", { error, message: error.message }));
|
||
|
|
}
|
||
|
|
// Emit an `uncaughtException` event if this is on Node.js.
|
||
|
|
//istanbul ignore else
|
||
|
|
else if (typeof process !== "undefined" &&
|
||
|
|
typeof process.emit === "function") {
|
||
|
|
process.emit("uncaughtException", error);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
// Otherwise, print the error.
|
||
|
|
console.error(error);
|
||
|
|
}
|
||
|
|
catch (_a) {
|
||
|
|
// ignore.
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
let currentWarnHandler;
|
||
|
|
/**
|
||
|
|
* The warning information.
|
||
|
|
*/
|
||
|
|
class Warning {
|
||
|
|
constructor(code, message) {
|
||
|
|
this.code = code;
|
||
|
|
this.message = message;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Report this warning.
|
||
|
|
* @param args The arguments of the warning.
|
||
|
|
*/
|
||
|
|
warn(...args) {
|
||
|
|
var _a;
|
||
|
|
try {
|
||
|
|
// Call the user-defined warning handler if exists.
|
||
|
|
if (currentWarnHandler) ;
|
||
|
|
// Otherwise, print the warning.
|
||
|
|
const stack = ((_a = new Error().stack) !== null && _a !== void 0 ? _a : "").replace(/^(?:.+?\n){2}/gu, "\n");
|
||
|
|
console.warn(this.message, ...args, stack);
|
||
|
|
}
|
||
|
|
catch (_b) {
|
||
|
|
// Ignore.
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const InitEventWasCalledWhileDispatching = new Warning("W01", "Unable to initialize event under dispatching.");
|
||
|
|
const FalsyWasAssignedToCancelBubble = new Warning("W02", "Assigning any falsy value to 'cancelBubble' property has no effect.");
|
||
|
|
const TruthyWasAssignedToReturnValue = new Warning("W03", "Assigning any truthy value to 'returnValue' property has no effect.");
|
||
|
|
const NonCancelableEventWasCanceled = new Warning("W04", "Unable to preventDefault on non-cancelable events.");
|
||
|
|
const CanceledInPassiveListener = new Warning("W05", "Unable to preventDefault inside passive event listener invocation.");
|
||
|
|
const EventListenerWasDuplicated = new Warning("W06", "An event listener wasn't added because it has been added already: %o, %o");
|
||
|
|
const OptionWasIgnored = new Warning("W07", "The %o option value was abandoned because the event listener wasn't added as duplicated.");
|
||
|
|
const InvalidEventListener = new Warning("W08", "The 'callback' argument must be a function or an object that has 'handleEvent' method: %o");
|
||
|
|
new Warning("W09", "Event attribute handler must be a function: %o");
|
||
|
|
|
||
|
|
/*eslint-disable class-methods-use-this */
|
||
|
|
/**
|
||
|
|
* An implementation of `Event` interface, that wraps a given event object.
|
||
|
|
* `EventTarget` shim can control the internal state of this `Event` objects.
|
||
|
|
* @see https://dom.spec.whatwg.org/#event
|
||
|
|
*/
|
||
|
|
class Event {
|
||
|
|
/**
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-none
|
||
|
|
*/
|
||
|
|
static get NONE() {
|
||
|
|
return NONE;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-capturing_phase
|
||
|
|
*/
|
||
|
|
static get CAPTURING_PHASE() {
|
||
|
|
return CAPTURING_PHASE;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-at_target
|
||
|
|
*/
|
||
|
|
static get AT_TARGET() {
|
||
|
|
return AT_TARGET;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-bubbling_phase
|
||
|
|
*/
|
||
|
|
static get BUBBLING_PHASE() {
|
||
|
|
return BUBBLING_PHASE;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Initialize this event instance.
|
||
|
|
* @param type The type of this event.
|
||
|
|
* @param eventInitDict Options to initialize.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-event
|
||
|
|
*/
|
||
|
|
constructor(type, eventInitDict) {
|
||
|
|
Object.defineProperty(this, "isTrusted", {
|
||
|
|
value: false,
|
||
|
|
enumerable: true,
|
||
|
|
});
|
||
|
|
const opts = eventInitDict !== null && eventInitDict !== void 0 ? eventInitDict : {};
|
||
|
|
internalDataMap.set(this, {
|
||
|
|
type: String(type),
|
||
|
|
bubbles: Boolean(opts.bubbles),
|
||
|
|
cancelable: Boolean(opts.cancelable),
|
||
|
|
composed: Boolean(opts.composed),
|
||
|
|
target: null,
|
||
|
|
currentTarget: null,
|
||
|
|
stopPropagationFlag: false,
|
||
|
|
stopImmediatePropagationFlag: false,
|
||
|
|
canceledFlag: false,
|
||
|
|
inPassiveListenerFlag: false,
|
||
|
|
dispatchFlag: false,
|
||
|
|
timeStamp: Date.now(),
|
||
|
|
});
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* The type of this event.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-type
|
||
|
|
*/
|
||
|
|
get type() {
|
||
|
|
return $(this).type;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* The event target of the current dispatching.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-target
|
||
|
|
*/
|
||
|
|
get target() {
|
||
|
|
return $(this).target;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* The event target of the current dispatching.
|
||
|
|
* @deprecated Use the `target` property instead.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-srcelement
|
||
|
|
*/
|
||
|
|
get srcElement() {
|
||
|
|
return $(this).target;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* The event target of the current dispatching.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-currenttarget
|
||
|
|
*/
|
||
|
|
get currentTarget() {
|
||
|
|
return $(this).currentTarget;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* The event target of the current dispatching.
|
||
|
|
* This doesn't support node tree.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-composedpath
|
||
|
|
*/
|
||
|
|
composedPath() {
|
||
|
|
const currentTarget = $(this).currentTarget;
|
||
|
|
if (currentTarget) {
|
||
|
|
return [currentTarget];
|
||
|
|
}
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-none
|
||
|
|
*/
|
||
|
|
get NONE() {
|
||
|
|
return NONE;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-capturing_phase
|
||
|
|
*/
|
||
|
|
get CAPTURING_PHASE() {
|
||
|
|
return CAPTURING_PHASE;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-at_target
|
||
|
|
*/
|
||
|
|
get AT_TARGET() {
|
||
|
|
return AT_TARGET;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-bubbling_phase
|
||
|
|
*/
|
||
|
|
get BUBBLING_PHASE() {
|
||
|
|
return BUBBLING_PHASE;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* The current event phase.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-eventphase
|
||
|
|
*/
|
||
|
|
get eventPhase() {
|
||
|
|
return $(this).dispatchFlag ? 2 : 0;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Stop event bubbling.
|
||
|
|
* Because this shim doesn't support node tree, this merely changes the `cancelBubble` property value.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-stoppropagation
|
||
|
|
*/
|
||
|
|
stopPropagation() {
|
||
|
|
$(this).stopPropagationFlag = true;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* `true` if event bubbling was stopped.
|
||
|
|
* @deprecated
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-cancelbubble
|
||
|
|
*/
|
||
|
|
get cancelBubble() {
|
||
|
|
return $(this).stopPropagationFlag;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Stop event bubbling if `true` is set.
|
||
|
|
* @deprecated Use the `stopPropagation()` method instead.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-cancelbubble
|
||
|
|
*/
|
||
|
|
set cancelBubble(value) {
|
||
|
|
if (value) {
|
||
|
|
$(this).stopPropagationFlag = true;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
FalsyWasAssignedToCancelBubble.warn();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Stop event bubbling and subsequent event listener callings.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-stopimmediatepropagation
|
||
|
|
*/
|
||
|
|
stopImmediatePropagation() {
|
||
|
|
const data = $(this);
|
||
|
|
data.stopPropagationFlag = data.stopImmediatePropagationFlag = true;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* `true` if this event will bubble.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-bubbles
|
||
|
|
*/
|
||
|
|
get bubbles() {
|
||
|
|
return $(this).bubbles;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* `true` if this event can be canceled by the `preventDefault()` method.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-cancelable
|
||
|
|
*/
|
||
|
|
get cancelable() {
|
||
|
|
return $(this).cancelable;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* `true` if the default behavior will act.
|
||
|
|
* @deprecated Use the `defaultPrevented` proeprty instead.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-returnvalue
|
||
|
|
*/
|
||
|
|
get returnValue() {
|
||
|
|
return !$(this).canceledFlag;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Cancel the default behavior if `false` is set.
|
||
|
|
* @deprecated Use the `preventDefault()` method instead.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-returnvalue
|
||
|
|
*/
|
||
|
|
set returnValue(value) {
|
||
|
|
if (!value) {
|
||
|
|
setCancelFlag($(this));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
TruthyWasAssignedToReturnValue.warn();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Cancel the default behavior.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-preventdefault
|
||
|
|
*/
|
||
|
|
preventDefault() {
|
||
|
|
setCancelFlag($(this));
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* `true` if the default behavior was canceled.
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-defaultprevented
|
||
|
|
*/
|
||
|
|
get defaultPrevented() {
|
||
|
|
return $(this).canceledFlag;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-composed
|
||
|
|
*/
|
||
|
|
get composed() {
|
||
|
|
return $(this).composed;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-istrusted
|
||
|
|
*/
|
||
|
|
//istanbul ignore next
|
||
|
|
get isTrusted() {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @see https://dom.spec.whatwg.org/#dom-event-timestamp
|
||
|
|
*/
|
||
|
|
get timeStamp() {
|
||
|
|
return $(this).timeStamp;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @deprecated Don't use this method. The constructor did initialization.
|
||
|
|
*/
|
||
|
|
initEvent(type, bubbles = false, cancelable = false) {
|
||
|
|
const data = $(this);
|
||
|
|
if (data.dispatchFlag) {
|
||
|
|
InitEventWasCalledWhileDispatching.warn();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
internalDataMap.set(this, {
|
||
|
|
...data,
|
||
|
|
type: String(type),
|
||
|
|
bubbles: Boolean(bubbles),
|
||
|
|
cancelable: Boolean(cancelable),
|
||
|
|
target: null,
|
||
|
|
currentTarget: null,
|
||
|
|
stopPropagationFlag: false,
|
||
|
|
stopImmediatePropagationFlag: false,
|
||
|
|
canceledFlag: false,
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//------------------------------------------------------------------------------
|
||
|
|
// Helpers
|
||
|
|
//------------------------------------------------------------------------------
|
||
|
|
const NONE = 0;
|
||
|
|
const CAPTURING_PHASE = 1;
|
||
|
|
const AT_TARGET = 2;
|
||
|
|
const BUBBLING_PHASE = 3;
|
||
|
|
/**
|
||
|
|
* Private data for event wrappers.
|
||
|
|
*/
|
||
|
|
const internalDataMap = new WeakMap();
|
||
|
|
/**
|
||
|
|
* Get private data.
|
||
|
|
* @param event The event object to get private data.
|
||
|
|
* @param name The variable name to report.
|
||
|
|
* @returns The private data of the event.
|
||
|
|
*/
|
||
|
|
function $(event, name = "this") {
|
||
|
|
const retv = internalDataMap.get(event);
|
||
|
|
assertType(retv != null, "'%s' must be an object that Event constructor created, but got another one: %o", name, event);
|
||
|
|
return retv;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* https://dom.spec.whatwg.org/#set-the-canceled-flag
|
||
|
|
* @param data private data.
|
||
|
|
*/
|
||
|
|
function setCancelFlag(data) {
|
||
|
|
if (data.inPassiveListenerFlag) {
|
||
|
|
CanceledInPassiveListener.warn();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (!data.cancelable) {
|
||
|
|
NonCancelableEventWasCanceled.warn();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
data.canceledFlag = true;
|
||
|
|
}
|
||
|
|
// Set enumerable
|
||
|
|
Object.defineProperty(Event, "NONE", { enumerable: true });
|
||
|
|
Object.defineProperty(Event, "CAPTURING_PHASE", { enumerable: true });
|
||
|
|
Object.defineProperty(Event, "AT_TARGET", { enumerable: true });
|
||
|
|
Object.defineProperty(Event, "BUBBLING_PHASE", { enumerable: true });
|
||
|
|
const keys$1 = Object.getOwnPropertyNames(Event.prototype);
|
||
|
|
for (let i = 0; i < keys$1.length; ++i) {
|
||
|
|
if (keys$1[i] === "constructor") {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
Object.defineProperty(Event.prototype, keys$1[i], { enumerable: true });
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* An implementation of `Event` interface, that wraps a given event object.
|
||
|
|
* This class controls the internal state of `Event`.
|
||
|
|
* @see https://dom.spec.whatwg.org/#interface-event
|
||
|
|
*/
|
||
|
|
class EventWrapper extends Event {
|
||
|
|
/**
|
||
|
|
* Wrap a given event object to control states.
|
||
|
|
* @param event The event-like object to wrap.
|
||
|
|
*/
|
||
|
|
static wrap(event) {
|
||
|
|
return new (getWrapperClassOf(event))(event);
|
||
|
|
}
|
||
|
|
constructor(event) {
|
||
|
|
super(event.type, {
|
||
|
|
bubbles: event.bubbles,
|
||
|
|
cancelable: event.cancelable,
|
||
|
|
composed: event.composed,
|
||
|
|
});
|
||
|
|
if (event.cancelBubble) {
|
||
|
|
super.stopPropagation();
|
||
|
|
}
|
||
|
|
if (event.defaultPrevented) {
|
||
|
|
super.preventDefault();
|
||
|
|
}
|
||
|
|
internalDataMap$1.set(this, { original: event });
|
||
|
|
// Define accessors
|
||
|
|
const keys = Object.keys(event);
|
||
|
|
for (let i = 0; i < keys.length; ++i) {
|
||
|
|
const key = keys[i];
|
||
|
|
if (!(key in this)) {
|
||
|
|
Object.defineProperty(this, key, defineRedirectDescriptor(event, key));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
stopPropagation() {
|
||
|
|
super.stopPropagation();
|
||
|
|
const { original } = $$1(this);
|
||
|
|
if ("stopPropagation" in original) {
|
||
|
|
original.stopPropagation();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
get cancelBubble() {
|
||
|
|
return super.cancelBubble;
|
||
|
|
}
|
||
|
|
set cancelBubble(value) {
|
||
|
|
super.cancelBubble = value;
|
||
|
|
const { original } = $$1(this);
|
||
|
|
if ("cancelBubble" in original) {
|
||
|
|
original.cancelBubble = value;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
stopImmediatePropagation() {
|
||
|
|
super.stopImmediatePropagation();
|
||
|
|
const { original } = $$1(this);
|
||
|
|
if ("stopImmediatePropagation" in original) {
|
||
|
|
original.stopImmediatePropagation();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
get returnValue() {
|
||
|
|
return super.returnValue;
|
||
|
|
}
|
||
|
|
set returnValue(value) {
|
||
|
|
super.returnValue = value;
|
||
|
|
const { original } = $$1(this);
|
||
|
|
if ("returnValue" in original) {
|
||
|
|
original.returnValue = value;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
preventDefault() {
|
||
|
|
super.preventDefault();
|
||
|
|
const { original } = $$1(this);
|
||
|
|
if ("preventDefault" in original) {
|
||
|
|
original.preventDefault();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
get timeStamp() {
|
||
|
|
const { original } = $$1(this);
|
||
|
|
if ("timeStamp" in original) {
|
||
|
|
return original.timeStamp;
|
||
|
|
}
|
||
|
|
return super.timeStamp;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Private data for event wrappers.
|
||
|
|
*/
|
||
|
|
const internalDataMap$1 = new WeakMap();
|
||
|
|
/**
|
||
|
|
* Get private data.
|
||
|
|
* @param event The event object to get private data.
|
||
|
|
* @returns The private data of the event.
|
||
|
|
*/
|
||
|
|
function $$1(event) {
|
||
|
|
const retv = internalDataMap$1.get(event);
|
||
|
|
assertType(retv != null, "'this' is expected an Event object, but got", event);
|
||
|
|
return retv;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Cache for wrapper classes.
|
||
|
|
* @type {WeakMap<Object, Function>}
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
const wrapperClassCache = new WeakMap();
|
||
|
|
// Make association for wrappers.
|
||
|
|
wrapperClassCache.set(Object.prototype, EventWrapper);
|
||
|
|
/**
|
||
|
|
* Get the wrapper class of a given prototype.
|
||
|
|
* @param originalEvent The event object to wrap.
|
||
|
|
*/
|
||
|
|
function getWrapperClassOf(originalEvent) {
|
||
|
|
const prototype = Object.getPrototypeOf(originalEvent);
|
||
|
|
if (prototype == null) {
|
||
|
|
return EventWrapper;
|
||
|
|
}
|
||
|
|
let wrapper = wrapperClassCache.get(prototype);
|
||
|
|
if (wrapper == null) {
|
||
|
|
wrapper = defineWrapper(getWrapperClassOf(prototype), prototype);
|
||
|
|
wrapperClassCache.set(prototype, wrapper);
|
||
|
|
}
|
||
|
|
return wrapper;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Define new wrapper class.
|
||
|
|
* @param BaseEventWrapper The base wrapper class.
|
||
|
|
* @param originalPrototype The prototype of the original event.
|
||
|
|
*/
|
||
|
|
function defineWrapper(BaseEventWrapper, originalPrototype) {
|
||
|
|
class CustomEventWrapper extends BaseEventWrapper {
|
||
|
|
}
|
||
|
|
const keys = Object.keys(originalPrototype);
|
||
|
|
for (let i = 0; i < keys.length; ++i) {
|
||
|
|
Object.defineProperty(CustomEventWrapper.prototype, keys[i], defineRedirectDescriptor(originalPrototype, keys[i]));
|
||
|
|
}
|
||
|
|
return CustomEventWrapper;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Get the property descriptor to redirect a given property.
|
||
|
|
*/
|
||
|
|
function defineRedirectDescriptor(obj, key) {
|
||
|
|
const d = Object.getOwnPropertyDescriptor(obj, key);
|
||
|
|
return {
|
||
|
|
get() {
|
||
|
|
const original = $$1(this).original;
|
||
|
|
const value = original[key];
|
||
|
|
if (typeof value === "function") {
|
||
|
|
return value.bind(original);
|
||
|
|
}
|
||
|
|
return value;
|
||
|
|
},
|
||
|
|
set(value) {
|
||
|
|
const original = $$1(this).original;
|
||
|
|
original[key] = value;
|
||
|
|
},
|
||
|
|
configurable: d.configurable,
|
||
|
|
enumerable: d.enumerable,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create a new listener.
|
||
|
|
* @param callback The callback function.
|
||
|
|
* @param capture The capture flag.
|
||
|
|
* @param passive The passive flag.
|
||
|
|
* @param once The once flag.
|
||
|
|
* @param signal The abort signal.
|
||
|
|
* @param signalListener The abort event listener for the abort signal.
|
||
|
|
*/
|
||
|
|
function createListener(callback, capture, passive, once, signal, signalListener) {
|
||
|
|
return {
|
||
|
|
callback,
|
||
|
|
flags: (capture ? 1 /* Capture */ : 0) |
|
||
|
|
(passive ? 2 /* Passive */ : 0) |
|
||
|
|
(once ? 4 /* Once */ : 0),
|
||
|
|
signal,
|
||
|
|
signalListener,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Set the `removed` flag to the given listener.
|
||
|
|
* @param listener The listener to check.
|
||
|
|
*/
|
||
|
|
function setRemoved(listener) {
|
||
|
|
listener.flags |= 8 /* Removed */;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Check if the given listener has the `capture` flag or not.
|
||
|
|
* @param listener The listener to check.
|
||
|
|
*/
|
||
|
|
function isCapture(listener) {
|
||
|
|
return (listener.flags & 1 /* Capture */) === 1 /* Capture */;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Check if the given listener has the `passive` flag or not.
|
||
|
|
* @param listener The listener to check.
|
||
|
|
*/
|
||
|
|
function isPassive(listener) {
|
||
|
|
return (listener.flags & 2 /* Passive */) === 2 /* Passive */;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Check if the given listener has the `once` flag or not.
|
||
|
|
* @param listener The listener to check.
|
||
|
|
*/
|
||
|
|
function isOnce(listener) {
|
||
|
|
return (listener.flags & 4 /* Once */) === 4 /* Once */;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Check if the given listener has the `removed` flag or not.
|
||
|
|
* @param listener The listener to check.
|
||
|
|
*/
|
||
|
|
function isRemoved(listener) {
|
||
|
|
return (listener.flags & 8 /* Removed */) === 8 /* Removed */;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Call an event listener.
|
||
|
|
* @param listener The listener to call.
|
||
|
|
* @param target The event target object for `thisArg`.
|
||
|
|
* @param event The event object for the first argument.
|
||
|
|
* @param attribute `true` if this callback is an event attribute handler.
|
||
|
|
*/
|
||
|
|
function invokeCallback({ callback }, target, event) {
|
||
|
|
try {
|
||
|
|
if (typeof callback === "function") {
|
||
|
|
callback.call(target, event);
|
||
|
|
}
|
||
|
|
else if (typeof callback.handleEvent === "function") {
|
||
|
|
callback.handleEvent(event);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (thrownError) {
|
||
|
|
reportError(thrownError);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Find the index of given listener.
|
||
|
|
* This returns `-1` if not found.
|
||
|
|
* @param list The listener list.
|
||
|
|
* @param callback The callback function to find.
|
||
|
|
* @param capture The capture flag to find.
|
||
|
|
*/
|
||
|
|
function findIndexOfListener({ listeners }, callback, capture) {
|
||
|
|
for (let i = 0; i < listeners.length; ++i) {
|
||
|
|
if (listeners[i].callback === callback &&
|
||
|
|
isCapture(listeners[i]) === capture) {
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Add the given listener.
|
||
|
|
* Does copy-on-write if needed.
|
||
|
|
* @param list The listener list.
|
||
|
|
* @param callback The callback function.
|
||
|
|
* @param capture The capture flag.
|
||
|
|
* @param passive The passive flag.
|
||
|
|
* @param once The once flag.
|
||
|
|
* @param signal The abort signal.
|
||
|
|
*/
|
||
|
|
function addListener(list, callback, capture, passive, once, signal) {
|
||
|
|
let signalListener;
|
||
|
|
if (signal) {
|
||
|
|
signalListener = removeListener.bind(null, list, callback, capture);
|
||
|
|
signal.addEventListener("abort", signalListener);
|
||
|
|
}
|
||
|
|
const listener = createListener(callback, capture, passive, once, signal, signalListener);
|
||
|
|
if (list.cow) {
|
||
|
|
list.cow = false;
|
||
|
|
list.listeners = [...list.listeners, listener];
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
list.listeners.push(listener);
|
||
|
|
}
|
||
|
|
return listener;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Remove a listener.
|
||
|
|
* @param list The listener list.
|
||
|
|
* @param callback The callback function to find.
|
||
|
|
* @param capture The capture flag to find.
|
||
|
|
* @returns `true` if it mutated the list directly.
|
||
|
|
*/
|
||
|
|
function removeListener(list, callback, capture) {
|
||
|
|
const index = findIndexOfListener(list, callback, capture);
|
||
|
|
if (index !== -1) {
|
||
|
|
return removeListenerAt(list, index);
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Remove a listener.
|
||
|
|
* @param list The listener list.
|
||
|
|
* @param index The index of the target listener.
|
||
|
|
* @param disableCow Disable copy-on-write if true.
|
||
|
|
* @returns `true` if it mutated the `listeners` array directly.
|
||
|
|
*/
|
||
|
|
function removeListenerAt(list, index, disableCow = false) {
|
||
|
|
const listener = list.listeners[index];
|
||
|
|
// Set the removed flag.
|
||
|
|
setRemoved(listener);
|
||
|
|
// Dispose the abort signal listener if exists.
|
||
|
|
if (listener.signal) {
|
||
|
|
listener.signal.removeEventListener("abort", listener.signalListener);
|
||
|
|
}
|
||
|
|
// Remove it from the array.
|
||
|
|
if (list.cow && !disableCow) {
|
||
|
|
list.cow = false;
|
||
|
|
list.listeners = list.listeners.filter((_, i) => i !== index);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
list.listeners.splice(index, 1);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create a new `ListenerListMap` object.
|
||
|
|
*/
|
||
|
|
function createListenerListMap() {
|
||
|
|
return Object.create(null);
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Get the listener list of the given type.
|
||
|
|
* If the listener list has not been initialized, initialize and return it.
|
||
|
|
* @param listenerMap The listener list map.
|
||
|
|
* @param type The event type to get.
|
||
|
|
*/
|
||
|
|
function ensureListenerList(listenerMap, type) {
|
||
|
|
var _a;
|
||
|
|
return ((_a = listenerMap[type]) !== null && _a !== void 0 ? _a : (listenerMap[type] = {
|
||
|
|
attrCallback: undefined,
|
||
|
|
attrListener: undefined,
|
||
|
|
cow: false,
|
||
|
|
listeners: [],
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* An implementation of the `EventTarget` interface.
|
||
|
|
* @see https://dom.spec.whatwg.org/#eventtarget
|
||
|
|
*/
|
||
|
|
class EventTarget {
|
||
|
|
/**
|
||
|
|
* Initialize this instance.
|
||
|
|
*/
|
||
|
|
constructor() {
|
||
|
|
internalDataMap$2.set(this, createListenerListMap());
|
||
|
|
}
|
||
|
|
// Implementation
|
||
|
|
addEventListener(type0, callback0, options0) {
|
||
|
|
const listenerMap = $$2(this);
|
||
|
|
const { callback, capture, once, passive, signal, type, } = normalizeAddOptions(type0, callback0, options0);
|
||
|
|
if (callback == null || (signal === null || signal === void 0 ? void 0 : signal.aborted)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const list = ensureListenerList(listenerMap, type);
|
||
|
|
// Find existing listener.
|
||
|
|
const i = findIndexOfListener(list, callback, capture);
|
||
|
|
if (i !== -1) {
|
||
|
|
warnDuplicate(list.listeners[i], passive, once, signal);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
// Add the new listener.
|
||
|
|
addListener(list, callback, capture, passive, once, signal);
|
||
|
|
}
|
||
|
|
// Implementation
|
||
|
|
removeEventListener(type0, callback0, options0) {
|
||
|
|
const listenerMap = $$2(this);
|
||
|
|
const { callback, capture, type } = normalizeOptions(type0, callback0, options0);
|
||
|
|
const list = listenerMap[type];
|
||
|
|
if (callback != null && list) {
|
||
|
|
removeListener(list, callback, capture);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Implementation
|
||
|
|
dispatchEvent(e) {
|
||
|
|
const list = $$2(this)[String(e.type)];
|
||
|
|
if (list == null) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
const event = e instanceof Event ? e : EventWrapper.wrap(e);
|
||
|
|
const eventData = $(event, "event");
|
||
|
|
if (eventData.dispatchFlag) {
|
||
|
|
throw new DOMException("This event has been in dispatching.");
|
||
|
|
}
|
||
|
|
eventData.dispatchFlag = true;
|
||
|
|
eventData.target = eventData.currentTarget = this;
|
||
|
|
if (!eventData.stopPropagationFlag) {
|
||
|
|
const { cow, listeners } = list;
|
||
|
|
// Set copy-on-write flag.
|
||
|
|
list.cow = true;
|
||
|
|
// Call listeners.
|
||
|
|
for (let i = 0; i < listeners.length; ++i) {
|
||
|
|
const listener = listeners[i];
|
||
|
|
// Skip if removed.
|
||
|
|
if (isRemoved(listener)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
// Remove this listener if has the `once` flag.
|
||
|
|
if (isOnce(listener) && removeListenerAt(list, i, !cow)) {
|
||
|
|
// Because this listener was removed, the next index is the
|
||
|
|
// same as the current value.
|
||
|
|
i -= 1;
|
||
|
|
}
|
||
|
|
// Call this listener with the `passive` flag.
|
||
|
|
eventData.inPassiveListenerFlag = isPassive(listener);
|
||
|
|
invokeCallback(listener, this, event);
|
||
|
|
eventData.inPassiveListenerFlag = false;
|
||
|
|
// Stop if the `event.stopImmediatePropagation()` method was called.
|
||
|
|
if (eventData.stopImmediatePropagationFlag) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Restore copy-on-write flag.
|
||
|
|
if (!cow) {
|
||
|
|
list.cow = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
eventData.target = null;
|
||
|
|
eventData.currentTarget = null;
|
||
|
|
eventData.stopImmediatePropagationFlag = false;
|
||
|
|
eventData.stopPropagationFlag = false;
|
||
|
|
eventData.dispatchFlag = false;
|
||
|
|
return !eventData.canceledFlag;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Internal data.
|
||
|
|
*/
|
||
|
|
const internalDataMap$2 = new WeakMap();
|
||
|
|
/**
|
||
|
|
* Get private data.
|
||
|
|
* @param target The event target object to get private data.
|
||
|
|
* @param name The variable name to report.
|
||
|
|
* @returns The private data of the event.
|
||
|
|
*/
|
||
|
|
function $$2(target, name = "this") {
|
||
|
|
const retv = internalDataMap$2.get(target);
|
||
|
|
assertType(retv != null, "'%s' must be an object that EventTarget constructor created, but got another one: %o", name, target);
|
||
|
|
return retv;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Normalize options.
|
||
|
|
* @param options The options to normalize.
|
||
|
|
*/
|
||
|
|
function normalizeAddOptions(type, callback, options) {
|
||
|
|
var _a;
|
||
|
|
assertCallback(callback);
|
||
|
|
if (typeof options === "object" && options !== null) {
|
||
|
|
return {
|
||
|
|
type: String(type),
|
||
|
|
callback: callback !== null && callback !== void 0 ? callback : undefined,
|
||
|
|
capture: Boolean(options.capture),
|
||
|
|
passive: Boolean(options.passive),
|
||
|
|
once: Boolean(options.once),
|
||
|
|
signal: (_a = options.signal) !== null && _a !== void 0 ? _a : undefined,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
return {
|
||
|
|
type: String(type),
|
||
|
|
callback: callback !== null && callback !== void 0 ? callback : undefined,
|
||
|
|
capture: Boolean(options),
|
||
|
|
passive: false,
|
||
|
|
once: false,
|
||
|
|
signal: undefined,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Normalize options.
|
||
|
|
* @param options The options to normalize.
|
||
|
|
*/
|
||
|
|
function normalizeOptions(type, callback, options) {
|
||
|
|
assertCallback(callback);
|
||
|
|
if (typeof options === "object" && options !== null) {
|
||
|
|
return {
|
||
|
|
type: String(type),
|
||
|
|
callback: callback !== null && callback !== void 0 ? callback : undefined,
|
||
|
|
capture: Boolean(options.capture),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
return {
|
||
|
|
type: String(type),
|
||
|
|
callback: callback !== null && callback !== void 0 ? callback : undefined,
|
||
|
|
capture: Boolean(options),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Assert the type of 'callback' argument.
|
||
|
|
* @param callback The callback to check.
|
||
|
|
*/
|
||
|
|
function assertCallback(callback) {
|
||
|
|
if (typeof callback === "function" ||
|
||
|
|
(typeof callback === "object" &&
|
||
|
|
callback !== null &&
|
||
|
|
typeof callback.handleEvent === "function")) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (callback == null || typeof callback === "object") {
|
||
|
|
InvalidEventListener.warn(callback);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
throw new TypeError(format(InvalidEventListener.message, [callback]));
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Print warning for duplicated.
|
||
|
|
* @param listener The current listener that is duplicated.
|
||
|
|
* @param passive The passive flag of the new duplicated listener.
|
||
|
|
* @param once The once flag of the new duplicated listener.
|
||
|
|
* @param signal The signal object of the new duplicated listener.
|
||
|
|
*/
|
||
|
|
function warnDuplicate(listener, passive, once, signal) {
|
||
|
|
EventListenerWasDuplicated.warn(isCapture(listener) ? "capture" : "bubble", listener.callback);
|
||
|
|
if (isPassive(listener) !== passive) {
|
||
|
|
OptionWasIgnored.warn("passive");
|
||
|
|
}
|
||
|
|
if (isOnce(listener) !== once) {
|
||
|
|
OptionWasIgnored.warn("once");
|
||
|
|
}
|
||
|
|
if (listener.signal !== signal) {
|
||
|
|
OptionWasIgnored.warn("signal");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Set enumerable
|
||
|
|
const keys$1$1 = Object.getOwnPropertyNames(EventTarget.prototype);
|
||
|
|
for (let i = 0; i < keys$1$1.length; ++i) {
|
||
|
|
if (keys$1$1[i] === "constructor") {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
Object.defineProperty(EventTarget.prototype, keys$1$1[i], { enumerable: true });
|
||
|
|
}
|
||
|
|
|
||
|
|
function u(u,D){for(var t=0;t<D.length;t++){var F=D[t];F.enumerable=F.enumerable||!1,F.configurable=!0,"value"in F&&(F.writable=!0),Object.defineProperty(u,F.key,F);}}function D(D,t,F){return t&&u(D.prototype,t),F&&u(D,F),D}function t(u,D){(null==D||D>u.length)&&(D=u.length);for(var t=0,F=new Array(D);t<D;t++)F[t]=u[t];return F}function F(u,D){var F="undefined"!=typeof Symbol&&u[Symbol.iterator]||u["@@iterator"];if(F)return (F=F.call(u)).next.bind(F);if(Array.isArray(u)||(F=function(u,D){if(u){if("string"==typeof u)return t(u,D);var F=Object.prototype.toString.call(u).slice(8,-1);return "Object"===F&&u.constructor&&(F=u.constructor.name),"Map"===F||"Set"===F?Array.from(u):"Arguments"===F||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(F)?t(u,D):void 0}}(u))||D&&u&&"number"==typeof u.length){F&&(u=F);var e=0;return function(){return e>=u.length?{done:!0}:{done:!1,value:u[e++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var e=/(?:[\$A-Z_a-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08C7\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u
|
||
|
|
|
||
|
|
const INTERNAL$2 = { tick: 0, pool: new Map() };
|
||
|
|
function requestAnimationFrame(callback) {
|
||
|
|
if (!INTERNAL$2.pool.size) {
|
||
|
|
setTimeout$1(() => {
|
||
|
|
const next = __performance_now();
|
||
|
|
for (const func of INTERNAL$2.pool.values()) {
|
||
|
|
func(next);
|
||
|
|
}
|
||
|
|
INTERNAL$2.pool.clear();
|
||
|
|
}, 1000 / 16);
|
||
|
|
}
|
||
|
|
const func = __function_bind(callback, undefined);
|
||
|
|
const tick = ++INTERNAL$2.tick;
|
||
|
|
INTERNAL$2.pool.set(tick, func);
|
||
|
|
return tick;
|
||
|
|
}
|
||
|
|
function cancelAnimationFrame(requestId) {
|
||
|
|
const timeout = INTERNAL$2.pool.get(requestId);
|
||
|
|
if (timeout) {
|
||
|
|
clearTimeout$1(timeout);
|
||
|
|
INTERNAL$2.pool.delete(requestId);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
class Node extends EventTarget {
|
||
|
|
append(...nodesOrDOMStrings) {
|
||
|
|
}
|
||
|
|
appendChild(childNode) {
|
||
|
|
return childNode;
|
||
|
|
}
|
||
|
|
after(...nodesOrDOMStrings) {
|
||
|
|
}
|
||
|
|
before(...nodesOrDOMStrings) {
|
||
|
|
}
|
||
|
|
prepend(...nodesOrDOMStrings) {
|
||
|
|
}
|
||
|
|
replaceChild(newChild, oldChild) {
|
||
|
|
return oldChild;
|
||
|
|
}
|
||
|
|
removeChild(childNode) {
|
||
|
|
return childNode;
|
||
|
|
}
|
||
|
|
get attributes() {
|
||
|
|
return {};
|
||
|
|
}
|
||
|
|
get childNodes() {
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
get children() {
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
get ownerDocument() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
get nodeValue() {
|
||
|
|
return '';
|
||
|
|
}
|
||
|
|
set nodeValue(value) {
|
||
|
|
}
|
||
|
|
get textContent() {
|
||
|
|
return '';
|
||
|
|
}
|
||
|
|
set textContent(value) {
|
||
|
|
}
|
||
|
|
get previousElementSibling() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
get nextElementSibling() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
[Symbol.for('nodejs.util.inspect.custom')](depth, options) {
|
||
|
|
return `${this.constructor.name}`;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
class DocumentFragment extends Node {
|
||
|
|
}
|
||
|
|
class ShadowRoot extends DocumentFragment {
|
||
|
|
get innerHTML() {
|
||
|
|
return '';
|
||
|
|
}
|
||
|
|
set innerHTML(value) {
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const NodeFilter$1 = Object.assign({
|
||
|
|
NodeFilter() {
|
||
|
|
throw new TypeError('Illegal constructor');
|
||
|
|
},
|
||
|
|
}.NodeFilter, {
|
||
|
|
FILTER_ACCEPT: 1,
|
||
|
|
FILTER_REJECT: 2,
|
||
|
|
FILTER_SKIP: 3,
|
||
|
|
SHOW_ALL: 4294967295,
|
||
|
|
SHOW_ELEMENT: 1,
|
||
|
|
SHOW_ATTRIBUTE: 2,
|
||
|
|
SHOW_TEXT: 4,
|
||
|
|
SHOW_CDATA_SECTION: 8,
|
||
|
|
SHOW_ENTITY_REFERENCE: 16,
|
||
|
|
SHOW_ENTITY: 32,
|
||
|
|
SHOW_PROCESSING_INSTRUCTION: 64,
|
||
|
|
SHOW_COMMENT: 128,
|
||
|
|
SHOW_DOCUMENT: 256,
|
||
|
|
SHOW_DOCUMENT_TYPE: 512,
|
||
|
|
SHOW_DOCUMENT_FRAGMENT: 1024,
|
||
|
|
SHOW_NOTATION: 2048,
|
||
|
|
});
|
||
|
|
class NodeIterator$1 {
|
||
|
|
nextNode() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
previousNode() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
get filter() {
|
||
|
|
const internals = internalsOf(this, 'NodeIterator', 'filter');
|
||
|
|
return internals.filter;
|
||
|
|
}
|
||
|
|
get pointerBeforeReferenceNode() {
|
||
|
|
const internals = internalsOf(this, 'NodeIterator', 'pointerBeforeReferenceNode');
|
||
|
|
return internals.pointerBeforeReferenceNode;
|
||
|
|
}
|
||
|
|
get referenceNode() {
|
||
|
|
const internals = internalsOf(this, 'NodeIterator', 'referenceNode');
|
||
|
|
return internals.referenceNode;
|
||
|
|
}
|
||
|
|
get root() {
|
||
|
|
const internals = internalsOf(this, 'NodeIterator', 'root');
|
||
|
|
return internals.root;
|
||
|
|
}
|
||
|
|
get whatToShow() {
|
||
|
|
const internals = internalsOf(this, 'NodeIterator', 'whatToShow');
|
||
|
|
return internals.whatToShow;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
allowStringTag(Node);
|
||
|
|
allowStringTag(NodeIterator$1);
|
||
|
|
allowStringTag(DocumentFragment);
|
||
|
|
allowStringTag(ShadowRoot);
|
||
|
|
|
||
|
|
class CharacterData extends Node {
|
||
|
|
constructor(data) {
|
||
|
|
INTERNALS.set(super(), {
|
||
|
|
data: String(data),
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get data() {
|
||
|
|
return internalsOf(this, 'CharacterData', 'data')
|
||
|
|
.data;
|
||
|
|
}
|
||
|
|
get textContent() {
|
||
|
|
return internalsOf(this, 'CharacterData', 'textContent').data;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
class Comment extends CharacterData {
|
||
|
|
}
|
||
|
|
class Text extends CharacterData {
|
||
|
|
get assignedSlot() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
get wholeText() {
|
||
|
|
return internalsOf(this, 'CharacterData', 'textContent').data;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
allowStringTag(CharacterData);
|
||
|
|
allowStringTag(Text);
|
||
|
|
allowStringTag(Comment);
|
||
|
|
|
||
|
|
class CustomEvent extends Event {
|
||
|
|
constructor(type, params) {
|
||
|
|
params = Object(params);
|
||
|
|
super(type, params);
|
||
|
|
if ('detail' in params)
|
||
|
|
this.detail = params.detail;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
allowStringTag(CustomEvent);
|
||
|
|
|
||
|
|
const INTERNAL$1 = { tick: 0, pool: new Map() };
|
||
|
|
function requestIdleCallback(callback) {
|
||
|
|
if (!INTERNAL$1.pool.size) {
|
||
|
|
setTimeout$1(() => {
|
||
|
|
const next = __performance_now();
|
||
|
|
for (const func of INTERNAL$1.pool.values()) {
|
||
|
|
func(next);
|
||
|
|
}
|
||
|
|
INTERNAL$1.pool.clear();
|
||
|
|
}, 1000 / 16);
|
||
|
|
}
|
||
|
|
const func = __function_bind(callback, undefined);
|
||
|
|
const tick = ++INTERNAL$1.tick;
|
||
|
|
INTERNAL$1.pool.set(tick, func);
|
||
|
|
return tick;
|
||
|
|
}
|
||
|
|
function cancelIdleCallback(requestId) {
|
||
|
|
const timeout = INTERNAL$1.pool.get(requestId);
|
||
|
|
if (timeout) {
|
||
|
|
clearTimeout$1(timeout);
|
||
|
|
INTERNAL$1.pool.delete(requestId);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const PRIMITIVE = 0;
|
||
|
|
const ARRAY = 1;
|
||
|
|
const OBJECT = 2;
|
||
|
|
const DATE = 3;
|
||
|
|
const REGEXP = 4;
|
||
|
|
const MAP = 5;
|
||
|
|
const SET = 6;
|
||
|
|
const ERROR = 7;
|
||
|
|
const BIGINT = 8;
|
||
|
|
// export const SYMBOL = 9;
|
||
|
|
|
||
|
|
const env = typeof self === 'object' ? self : globalThis;
|
||
|
|
|
||
|
|
const deserializer = ($, _) => {
|
||
|
|
const as = (out, index) => {
|
||
|
|
$.set(index, out);
|
||
|
|
return out;
|
||
|
|
};
|
||
|
|
|
||
|
|
const unpair = index => {
|
||
|
|
if ($.has(index))
|
||
|
|
return $.get(index);
|
||
|
|
|
||
|
|
const [type, value] = _[index];
|
||
|
|
switch (type) {
|
||
|
|
case PRIMITIVE:
|
||
|
|
return as(value, index);
|
||
|
|
case ARRAY: {
|
||
|
|
const arr = as([], index);
|
||
|
|
for (const index of value)
|
||
|
|
arr.push(unpair(index));
|
||
|
|
return arr;
|
||
|
|
}
|
||
|
|
case OBJECT: {
|
||
|
|
const object = as({}, index);
|
||
|
|
for (const [key, index] of value)
|
||
|
|
object[unpair(key)] = unpair(index);
|
||
|
|
return object;
|
||
|
|
}
|
||
|
|
case DATE:
|
||
|
|
return as(new Date(value), index);
|
||
|
|
case REGEXP: {
|
||
|
|
const {source, flags} = value;
|
||
|
|
return as(new RegExp(source, flags), index);
|
||
|
|
}
|
||
|
|
case MAP: {
|
||
|
|
const map = as(new Map, index);
|
||
|
|
for (const [key, index] of value)
|
||
|
|
map.set(unpair(key), unpair(index));
|
||
|
|
return map;
|
||
|
|
}
|
||
|
|
case SET: {
|
||
|
|
const set = as(new Set, index);
|
||
|
|
for (const index of value)
|
||
|
|
set.add(unpair(index));
|
||
|
|
return set;
|
||
|
|
}
|
||
|
|
case ERROR: {
|
||
|
|
const {name, message} = value;
|
||
|
|
return as(new env[name](message), index);
|
||
|
|
}
|
||
|
|
case BIGINT:
|
||
|
|
return as(BigInt(value), index);
|
||
|
|
case 'BigInt':
|
||
|
|
return as(Object(BigInt(value)), index);
|
||
|
|
}
|
||
|
|
return as(new env[type](value), index);
|
||
|
|
};
|
||
|
|
|
||
|
|
return unpair;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @typedef {Array<string,any>} Record a type representation
|
||
|
|
*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns a deserialized value from a serialized array of Records.
|
||
|
|
* @param {Record[]} serialized a previously serialized value.
|
||
|
|
* @returns {any}
|
||
|
|
*/
|
||
|
|
const deserialize = serialized => deserializer(new Map, serialized)(0);
|
||
|
|
|
||
|
|
const EMPTY = '';
|
||
|
|
|
||
|
|
const {toString} = {};
|
||
|
|
const {keys} = Object;
|
||
|
|
|
||
|
|
const typeOf = value => {
|
||
|
|
const type = typeof value;
|
||
|
|
if (type !== 'object' || !value)
|
||
|
|
return [PRIMITIVE, type];
|
||
|
|
|
||
|
|
const asString = toString.call(value).slice(8, -1);
|
||
|
|
switch (asString) {
|
||
|
|
case 'Array':
|
||
|
|
return [ARRAY, EMPTY];
|
||
|
|
case 'Object':
|
||
|
|
return [OBJECT, EMPTY];
|
||
|
|
case 'Date':
|
||
|
|
return [DATE, EMPTY];
|
||
|
|
case 'RegExp':
|
||
|
|
return [REGEXP, EMPTY];
|
||
|
|
case 'Map':
|
||
|
|
return [MAP, EMPTY];
|
||
|
|
case 'Set':
|
||
|
|
return [SET, EMPTY];
|
||
|
|
}
|
||
|
|
|
||
|
|
if (asString.includes('Array'))
|
||
|
|
return [ARRAY, asString];
|
||
|
|
|
||
|
|
if (asString.includes('Error'))
|
||
|
|
return [ERROR, asString];
|
||
|
|
|
||
|
|
return [OBJECT, asString];
|
||
|
|
};
|
||
|
|
|
||
|
|
const shouldSkip = ([TYPE, type]) => (
|
||
|
|
TYPE === PRIMITIVE &&
|
||
|
|
(type === 'function' || type === 'symbol')
|
||
|
|
);
|
||
|
|
|
||
|
|
const serializer = (strict, json, $, _) => {
|
||
|
|
|
||
|
|
const as = (out, value) => {
|
||
|
|
const index = _.push(out) - 1;
|
||
|
|
$.set(value, index);
|
||
|
|
return index;
|
||
|
|
};
|
||
|
|
|
||
|
|
const pair = value => {
|
||
|
|
if ($.has(value))
|
||
|
|
return $.get(value);
|
||
|
|
|
||
|
|
let [TYPE, type] = typeOf(value);
|
||
|
|
switch (TYPE) {
|
||
|
|
case PRIMITIVE: {
|
||
|
|
let entry = value;
|
||
|
|
switch (type) {
|
||
|
|
case 'bigint':
|
||
|
|
TYPE = BIGINT;
|
||
|
|
entry = value.toString();
|
||
|
|
break;
|
||
|
|
case 'function':
|
||
|
|
case 'symbol':
|
||
|
|
if (strict)
|
||
|
|
throw new TypeError('unable to serialize ' + type);
|
||
|
|
entry = null;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
return as([TYPE, entry], value);
|
||
|
|
}
|
||
|
|
case ARRAY: {
|
||
|
|
if (type)
|
||
|
|
return as([type, [...value]], value);
|
||
|
|
|
||
|
|
const arr = [];
|
||
|
|
const index = as([TYPE, arr], value);
|
||
|
|
for (const entry of value)
|
||
|
|
arr.push(pair(entry));
|
||
|
|
return index;
|
||
|
|
}
|
||
|
|
case OBJECT: {
|
||
|
|
if (type) {
|
||
|
|
switch (type) {
|
||
|
|
case 'BigInt':
|
||
|
|
return as([type, value.toString()], value);
|
||
|
|
case 'Boolean':
|
||
|
|
case 'Number':
|
||
|
|
case 'String':
|
||
|
|
return as([type, value.valueOf()], value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (json && ('toJSON' in value))
|
||
|
|
return pair(value.toJSON());
|
||
|
|
|
||
|
|
const entries = [];
|
||
|
|
const index = as([TYPE, entries], value);
|
||
|
|
for (const key of keys(value)) {
|
||
|
|
if (strict || !shouldSkip(typeOf(value[key])))
|
||
|
|
entries.push([pair(key), pair(value[key])]);
|
||
|
|
}
|
||
|
|
return index;
|
||
|
|
}
|
||
|
|
case DATE:
|
||
|
|
return as([TYPE, value.toISOString()], value);
|
||
|
|
case REGEXP: {
|
||
|
|
const {source, flags} = value;
|
||
|
|
return as([TYPE, {source, flags}], value);
|
||
|
|
}
|
||
|
|
case MAP: {
|
||
|
|
const entries = [];
|
||
|
|
const index = as([TYPE, entries], value);
|
||
|
|
for (const [key, entry] of value) {
|
||
|
|
if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))
|
||
|
|
entries.push([pair(key), pair(entry)]);
|
||
|
|
}
|
||
|
|
return index;
|
||
|
|
}
|
||
|
|
case SET: {
|
||
|
|
const entries = [];
|
||
|
|
const index = as([TYPE, entries], value);
|
||
|
|
for (const entry of value) {
|
||
|
|
if (strict || !shouldSkip(typeOf(entry)))
|
||
|
|
entries.push(pair(entry));
|
||
|
|
}
|
||
|
|
return index;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const {message} = value;
|
||
|
|
return as([TYPE, {name: type, message}], value);
|
||
|
|
};
|
||
|
|
|
||
|
|
return pair;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @typedef {Array<string,any>} Record a type representation
|
||
|
|
*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns an array of serialized Records.
|
||
|
|
* @param {any} value a serializable value.
|
||
|
|
* @param {{lossy?: boolean}?} options an object with a `lossy` property that,
|
||
|
|
* if `true`, will not throw errors on incompatible types, and behave more
|
||
|
|
* like JSON stringify would behave. Symbol and Function will be discarded.
|
||
|
|
* @returns {Record[]}
|
||
|
|
*/
|
||
|
|
const serialize = (value, {json, lossy} = {}) => {
|
||
|
|
const _ = [];
|
||
|
|
return serializer(!(json || lossy), !!json, new Map, _)(value), _;
|
||
|
|
};
|
||
|
|
|
||
|
|
var structuredClone = (any, options) => deserialize(serialize(any, options));
|
||
|
|
|
||
|
|
const INTERNAL = { tick: 0, pool: new Map() };
|
||
|
|
function setTimeout(callback, delay = 0, ...args) {
|
||
|
|
const func = __function_bind(callback, globalThis);
|
||
|
|
const tick = ++INTERNAL.tick;
|
||
|
|
const timeout = setTimeout$1(func, delay, ...args);
|
||
|
|
INTERNAL.pool.set(tick, timeout);
|
||
|
|
return tick;
|
||
|
|
}
|
||
|
|
function clearTimeout(timeoutId) {
|
||
|
|
const timeout = INTERNAL.pool.get(timeoutId);
|
||
|
|
if (timeout) {
|
||
|
|
clearTimeout$1(timeout);
|
||
|
|
INTERNAL.pool.delete(timeoutId);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
class TreeWalker {
|
||
|
|
parentNode() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
firstChild() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
lastChild() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
previousSibling() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
nextSibling() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
previousNode() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
nextNode() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
get currentNode() {
|
||
|
|
const internals = internalsOf(this, 'TreeWalker', 'currentNode');
|
||
|
|
return internals.currentNode;
|
||
|
|
}
|
||
|
|
get root() {
|
||
|
|
const internals = internalsOf(this, 'TreeWalker', 'root');
|
||
|
|
return internals.root;
|
||
|
|
}
|
||
|
|
get whatToShow() {
|
||
|
|
const internals = internalsOf(this, 'TreeWalker', 'whatToShow');
|
||
|
|
return internals.whatToShow;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
allowStringTag(TreeWalker);
|
||
|
|
|
||
|
|
class ImageData {
|
||
|
|
constructor(arg0, arg1, ...args) {
|
||
|
|
if (arguments.length < 2)
|
||
|
|
throw new TypeError(`Failed to construct 'ImageData': 2 arguments required.`);
|
||
|
|
/** Whether Uint8ClampedArray data is provided. */
|
||
|
|
const hasData = __object_isPrototypeOf(Uint8ClampedArray.prototype, arg0);
|
||
|
|
/** Image data, either provided or calculated. */
|
||
|
|
const d = hasData
|
||
|
|
? arg0
|
||
|
|
: new Uint8ClampedArray(asNumber(arg0, 'width') * asNumber(arg1, 'height') * 4);
|
||
|
|
/** Image width. */
|
||
|
|
const w = asNumber(hasData ? arg1 : arg0, 'width');
|
||
|
|
/** Image height. */
|
||
|
|
const h = d.length / w / 4;
|
||
|
|
/** Image color space. */
|
||
|
|
const c = String(Object(hasData ? args[1] : args[0]).colorSpace || 'srgb');
|
||
|
|
// throw if a provided height does not match the calculated height
|
||
|
|
if (args.length && asNumber(args[0], 'height') !== h)
|
||
|
|
throw new DOMException('height is not equal to (4 * width * height)', 'IndexSizeError');
|
||
|
|
// throw if a provided colorspace does not match a known colorspace
|
||
|
|
if (c !== 'srgb' && c !== 'rec2020' && c !== 'display-p3')
|
||
|
|
throw new TypeError('colorSpace is not known value');
|
||
|
|
Object.defineProperty(this, 'data', {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
value: d,
|
||
|
|
});
|
||
|
|
INTERNALS.set(this, {
|
||
|
|
width: w,
|
||
|
|
height: h,
|
||
|
|
colorSpace: c,
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get data() {
|
||
|
|
internalsOf(this, 'ImageData', 'data');
|
||
|
|
return Object.getOwnPropertyDescriptor(this, 'data').value;
|
||
|
|
}
|
||
|
|
get width() {
|
||
|
|
return internalsOf(this, 'ImageData', 'width').width;
|
||
|
|
}
|
||
|
|
get height() {
|
||
|
|
return internalsOf(this, 'ImageData', 'height').height;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
allowStringTag(ImageData);
|
||
|
|
/** Returns a coerced number, optionally throwing if the number is zero-ish. */
|
||
|
|
const asNumber = (value, axis) => {
|
||
|
|
value = Number(value) || 0;
|
||
|
|
if (value === 0)
|
||
|
|
throw new TypeError(`The source ${axis} is zero or not a number.`);
|
||
|
|
return value;
|
||
|
|
};
|
||
|
|
|
||
|
|
class CanvasRenderingContext2D {
|
||
|
|
get canvas() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'canvas').canvas;
|
||
|
|
}
|
||
|
|
get direction() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'direction')
|
||
|
|
.direction;
|
||
|
|
}
|
||
|
|
get fillStyle() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'fillStyle')
|
||
|
|
.fillStyle;
|
||
|
|
}
|
||
|
|
get filter() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'filter').filter;
|
||
|
|
}
|
||
|
|
get globalAlpha() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'globalAlpha')
|
||
|
|
.globalAlpha;
|
||
|
|
}
|
||
|
|
get globalCompositeOperation() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'globalCompositeOperation').globalCompositeOperation;
|
||
|
|
}
|
||
|
|
get font() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'font').font;
|
||
|
|
}
|
||
|
|
get imageSmoothingEnabled() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'imageSmoothingEnabled').imageSmoothingEnabled;
|
||
|
|
}
|
||
|
|
get imageSmoothingQuality() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'imageSmoothingQuality').imageSmoothingQuality;
|
||
|
|
}
|
||
|
|
get lineCap() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'lineCap').lineCap;
|
||
|
|
}
|
||
|
|
get lineDashOffset() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'lineDashOffset')
|
||
|
|
.lineDashOffset;
|
||
|
|
}
|
||
|
|
get lineJoin() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'lineJoin').lineJoin;
|
||
|
|
}
|
||
|
|
get lineWidth() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'lineWidth')
|
||
|
|
.lineWidth;
|
||
|
|
}
|
||
|
|
get miterLimit() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'miterLimit')
|
||
|
|
.miterLimit;
|
||
|
|
}
|
||
|
|
get strokeStyle() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'strokeStyle')
|
||
|
|
.strokeStyle;
|
||
|
|
}
|
||
|
|
get shadowOffsetX() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'shadowOffsetX')
|
||
|
|
.shadowOffsetX;
|
||
|
|
}
|
||
|
|
get shadowOffsetY() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'shadowOffsetY')
|
||
|
|
.shadowOffsetY;
|
||
|
|
}
|
||
|
|
get shadowBlur() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'shadowBlur')
|
||
|
|
.shadowBlur;
|
||
|
|
}
|
||
|
|
get shadowColor() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'shadowColor')
|
||
|
|
.shadowColor;
|
||
|
|
}
|
||
|
|
get textAlign() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'textAlign')
|
||
|
|
.textAlign;
|
||
|
|
}
|
||
|
|
get textBaseline() {
|
||
|
|
return internalsOf(this, 'CanvasRenderingContext2D', 'textBaseline')
|
||
|
|
.textBaseline;
|
||
|
|
}
|
||
|
|
arc() { }
|
||
|
|
arcTo() { }
|
||
|
|
beginPath() { }
|
||
|
|
bezierCurveTo() { }
|
||
|
|
clearRect() { }
|
||
|
|
clip() { }
|
||
|
|
closePath() { }
|
||
|
|
createImageData(arg0, arg1) {
|
||
|
|
/** Whether ImageData is provided. */
|
||
|
|
const hasData = __object_isPrototypeOf(ImageData.prototype, arg0);
|
||
|
|
const w = hasData ? arg0.width : arg0;
|
||
|
|
const h = hasData ? arg0.height : arg1;
|
||
|
|
const d = hasData
|
||
|
|
? arg0.data
|
||
|
|
: new Uint8ClampedArray(w * h * 4);
|
||
|
|
return new ImageData(d, w, h);
|
||
|
|
}
|
||
|
|
createLinearGradient() { }
|
||
|
|
createPattern() { }
|
||
|
|
createRadialGradient() { }
|
||
|
|
drawFocusIfNeeded() { }
|
||
|
|
drawImage() { }
|
||
|
|
ellipse() { }
|
||
|
|
fill() { }
|
||
|
|
fillRect() { }
|
||
|
|
fillText() { }
|
||
|
|
getContextAttributes() { }
|
||
|
|
getImageData() { }
|
||
|
|
getLineDash() { }
|
||
|
|
getTransform() { }
|
||
|
|
isPointInPath() { }
|
||
|
|
isPointInStroke() { }
|
||
|
|
lineTo() { }
|
||
|
|
measureText() { }
|
||
|
|
moveTo() { }
|
||
|
|
putImageData() { }
|
||
|
|
quadraticCurveTo() { }
|
||
|
|
rect() { }
|
||
|
|
resetTransform() { }
|
||
|
|
restore() { }
|
||
|
|
rotate() { }
|
||
|
|
save() { }
|
||
|
|
scale() { }
|
||
|
|
setLineDash() { }
|
||
|
|
setTransform() { }
|
||
|
|
stroke() { }
|
||
|
|
strokeRect() { }
|
||
|
|
strokeText() { }
|
||
|
|
transform() { }
|
||
|
|
translate() { }
|
||
|
|
}
|
||
|
|
allowStringTag(CanvasRenderingContext2D);
|
||
|
|
const __createCanvasRenderingContext2D = (canvas) => {
|
||
|
|
const renderingContext2D = Object.create(CanvasRenderingContext2D.prototype);
|
||
|
|
INTERNALS.set(renderingContext2D, {
|
||
|
|
canvas,
|
||
|
|
direction: 'inherit',
|
||
|
|
fillStyle: '#000',
|
||
|
|
filter: 'none',
|
||
|
|
font: '10px sans-serif',
|
||
|
|
globalAlpha: 0,
|
||
|
|
globalCompositeOperation: 'source-over',
|
||
|
|
imageSmoothingEnabled: false,
|
||
|
|
imageSmoothingQuality: 'high',
|
||
|
|
lineCap: 'butt',
|
||
|
|
lineDashOffset: 0.0,
|
||
|
|
lineJoin: 'miter',
|
||
|
|
lineWidth: 1.0,
|
||
|
|
miterLimit: 10.0,
|
||
|
|
shadowBlur: 0,
|
||
|
|
shadowColor: '#000',
|
||
|
|
shadowOffsetX: 0,
|
||
|
|
shadowOffsetY: 0,
|
||
|
|
strokeStyle: '#000',
|
||
|
|
textAlign: 'start',
|
||
|
|
textBaseline: 'alphabetic',
|
||
|
|
});
|
||
|
|
return renderingContext2D;
|
||
|
|
};
|
||
|
|
|
||
|
|
class CustomElementRegistry {
|
||
|
|
/** Defines a new custom element using the given tag name and HTMLElement constructor. */
|
||
|
|
define(name, constructor, options) {
|
||
|
|
const internals = internalsOf(this, 'CustomElementRegistry', 'define');
|
||
|
|
name = String(name);
|
||
|
|
if (/[A-Z]/.test(name))
|
||
|
|
throw new SyntaxError('Custom element name cannot contain an uppercase ASCII letter');
|
||
|
|
if (!/^[a-z]/.test(name))
|
||
|
|
throw new SyntaxError('Custom element name must have a lowercase ASCII letter as its first character');
|
||
|
|
if (!/-/.test(name))
|
||
|
|
throw new SyntaxError('Custom element name must contain a hyphen');
|
||
|
|
INTERNALS.set(constructor, {
|
||
|
|
attributes: {},
|
||
|
|
localName: name,
|
||
|
|
});
|
||
|
|
internals.constructorByName.set(name, constructor);
|
||
|
|
internals.nameByConstructor.set(constructor, name);
|
||
|
|
}
|
||
|
|
/** Returns the constructor associated with the given tag name. */
|
||
|
|
get(name) {
|
||
|
|
const internals = internalsOf(this, 'CustomElementRegistry', 'get');
|
||
|
|
name = String(name).toLowerCase();
|
||
|
|
return internals.constructorByName.get(name);
|
||
|
|
}
|
||
|
|
getName(constructor) {
|
||
|
|
const internals = internalsOf(this, 'CustomElementRegistry', 'getName');
|
||
|
|
return internals.nameByConstructor.get(constructor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
allowStringTag(CustomElementRegistry);
|
||
|
|
const initCustomElementRegistry = (target, exclude) => {
|
||
|
|
if (exclude.has('customElements'))
|
||
|
|
return;
|
||
|
|
const CustomElementRegistry = target.CustomElementRegistry || globalThis.CustomElementRegistry;
|
||
|
|
const customElements = target.customElements ||
|
||
|
|
(target.customElements = new CustomElementRegistry());
|
||
|
|
INTERNALS.set(customElements, {
|
||
|
|
constructorByName: new Map(),
|
||
|
|
nameByConstructor: new Map(),
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
class Element extends Node {
|
||
|
|
constructor() {
|
||
|
|
super();
|
||
|
|
if (INTERNALS.has(new.target)) {
|
||
|
|
const internals = internalsOf(new.target, 'Element', 'localName');
|
||
|
|
INTERNALS.set(this, {
|
||
|
|
attributes: {},
|
||
|
|
localName: internals.localName,
|
||
|
|
ownerDocument: this.ownerDocument,
|
||
|
|
shadowInit: null,
|
||
|
|
shadowRoot: null,
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
hasAttribute(name) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
getAttribute(name) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
setAttribute(name, value) {
|
||
|
|
}
|
||
|
|
removeAttribute(name) {
|
||
|
|
}
|
||
|
|
attachShadow(init) {
|
||
|
|
if (arguments.length < 1)
|
||
|
|
throw new TypeError(`Failed to execute 'attachShadow' on 'Element': 1 argument required, but only 0 present.`);
|
||
|
|
if (init !== Object(init))
|
||
|
|
throw new TypeError(`Failed to execute 'attachShadow' on 'Element': The provided value is not of type 'ShadowRootInit'.`);
|
||
|
|
if (init.mode !== 'open' && init.mode !== 'closed')
|
||
|
|
throw new TypeError(`Failed to execute 'attachShadow' on 'Element': Failed to read the 'mode' property from 'ShadowRootInit': The provided value '${init.mode}' is not a valid enum value of type ShadowRootMode.`);
|
||
|
|
const internals = internalsOf(this, 'Element', 'attachShadow');
|
||
|
|
if (internals.shadowRoot)
|
||
|
|
throw new Error('The operation is not supported.');
|
||
|
|
internals.shadowInit = internals.shadowInit || {
|
||
|
|
mode: init.mode,
|
||
|
|
delegatesFocus: Boolean(init.delegatesFocus),
|
||
|
|
};
|
||
|
|
internals.shadowRoot =
|
||
|
|
internals.shadowRoot ||
|
||
|
|
(/^open$/.test(internals.shadowInit.mode)
|
||
|
|
? Object.setPrototypeOf(new EventTarget(), ShadowRoot.prototype)
|
||
|
|
: null);
|
||
|
|
return internals.shadowRoot;
|
||
|
|
}
|
||
|
|
get assignedSlot() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
get innerHTML() {
|
||
|
|
internalsOf(this, 'Element', 'innerHTML');
|
||
|
|
return '';
|
||
|
|
}
|
||
|
|
set innerHTML(value) {
|
||
|
|
internalsOf(this, 'Element', 'innerHTML');
|
||
|
|
}
|
||
|
|
get shadowRoot() {
|
||
|
|
const internals = internalsOf(this, 'Element', 'shadowRoot');
|
||
|
|
return Object(internals.shadowInit).mode === 'open'
|
||
|
|
? internals.shadowRoot
|
||
|
|
: null;
|
||
|
|
}
|
||
|
|
get localName() {
|
||
|
|
return internalsOf(this, 'Element', 'localName')
|
||
|
|
.localName;
|
||
|
|
}
|
||
|
|
get nodeName() {
|
||
|
|
return internalsOf(this, 'Element', 'nodeName')
|
||
|
|
.localName.toUpperCase();
|
||
|
|
}
|
||
|
|
get tagName() {
|
||
|
|
return internalsOf(this, 'Element', 'tagName')
|
||
|
|
.localName.toUpperCase();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
class HTMLElement extends Element {
|
||
|
|
}
|
||
|
|
class HTMLBodyElement extends HTMLElement {
|
||
|
|
}
|
||
|
|
class HTMLDivElement extends HTMLElement {
|
||
|
|
}
|
||
|
|
class HTMLHeadElement extends HTMLElement {
|
||
|
|
}
|
||
|
|
class HTMLHtmlElement extends HTMLElement {
|
||
|
|
}
|
||
|
|
class HTMLSpanElement extends HTMLElement {
|
||
|
|
}
|
||
|
|
class HTMLStyleElement extends HTMLElement {
|
||
|
|
}
|
||
|
|
class HTMLTemplateElement extends HTMLElement {
|
||
|
|
}
|
||
|
|
class HTMLUnknownElement extends HTMLElement {
|
||
|
|
}
|
||
|
|
allowStringTag(Element);
|
||
|
|
allowStringTag(HTMLElement);
|
||
|
|
allowStringTag(HTMLBodyElement);
|
||
|
|
allowStringTag(HTMLDivElement);
|
||
|
|
allowStringTag(HTMLHeadElement);
|
||
|
|
allowStringTag(HTMLHtmlElement);
|
||
|
|
allowStringTag(HTMLSpanElement);
|
||
|
|
allowStringTag(HTMLStyleElement);
|
||
|
|
allowStringTag(HTMLTemplateElement);
|
||
|
|
allowStringTag(HTMLUnknownElement);
|
||
|
|
|
||
|
|
class Document extends Node {
|
||
|
|
createElement(name) {
|
||
|
|
const internals = internalsOf(this, 'Document', 'createElement');
|
||
|
|
const customElementInternals = INTERNALS.get(internals.target.customElements);
|
||
|
|
name = String(name).toLowerCase();
|
||
|
|
const TypeOfHTMLElement = internals.constructorByName.get(name) ||
|
||
|
|
(customElementInternals &&
|
||
|
|
customElementInternals.constructorByName.get(name)) ||
|
||
|
|
HTMLUnknownElement;
|
||
|
|
const element = Object.setPrototypeOf(new EventTarget(), TypeOfHTMLElement.prototype);
|
||
|
|
INTERNALS.set(element, {
|
||
|
|
attributes: {},
|
||
|
|
localName: name,
|
||
|
|
ownerDocument: this,
|
||
|
|
shadowInit: null,
|
||
|
|
shadowRoot: null,
|
||
|
|
});
|
||
|
|
return element;
|
||
|
|
}
|
||
|
|
createNodeIterator(root, whatToShow = NodeFilter.SHOW_ALL, filter) {
|
||
|
|
const target = Object.create(NodeIterator.prototype);
|
||
|
|
INTERNALS.set(target, {
|
||
|
|
filter,
|
||
|
|
pointerBeforeReferenceNode: false,
|
||
|
|
referenceNode: root,
|
||
|
|
root,
|
||
|
|
whatToShow,
|
||
|
|
});
|
||
|
|
return target;
|
||
|
|
}
|
||
|
|
createTextNode(data) {
|
||
|
|
return new Text(data);
|
||
|
|
}
|
||
|
|
createTreeWalker(root, whatToShow = NodeFilter.SHOW_ALL, filter, expandEntityReferences) {
|
||
|
|
const target = Object.create(TreeWalker.prototype);
|
||
|
|
INTERNALS.set(target, {
|
||
|
|
filter,
|
||
|
|
currentNode: root,
|
||
|
|
root,
|
||
|
|
whatToShow,
|
||
|
|
});
|
||
|
|
return target;
|
||
|
|
}
|
||
|
|
get adoptedStyleSheets() {
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
get styleSheets() {
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
class HTMLDocument extends Document {
|
||
|
|
}
|
||
|
|
allowStringTag(Document);
|
||
|
|
allowStringTag(HTMLDocument);
|
||
|
|
const initDocument = (target, exclude) => {
|
||
|
|
if (exclude.has('document'))
|
||
|
|
return;
|
||
|
|
const EventTarget = target.EventTarget || globalThis.EventTarget;
|
||
|
|
const HTMLDocument = target.HTMLDocument || globalThis.HTMLDocument;
|
||
|
|
const document = (target.document = Object.setPrototypeOf(new EventTarget(), HTMLDocument.prototype));
|
||
|
|
INTERNALS.set(document, {
|
||
|
|
target,
|
||
|
|
constructorByName: new Map([
|
||
|
|
['body', target.HTMLBodyElement],
|
||
|
|
['canvas', target.HTMLCanvasElement],
|
||
|
|
['div', target.HTMLDivElement],
|
||
|
|
['head', target.HTMLHeadElement],
|
||
|
|
['html', target.HTMLHtmlElement],
|
||
|
|
['img', target.HTMLImageElement],
|
||
|
|
['span', target.HTMLSpanElement],
|
||
|
|
['style', target.HTMLStyleElement],
|
||
|
|
]),
|
||
|
|
nameByConstructor: new Map(),
|
||
|
|
});
|
||
|
|
const initElement = (name, Class) => {
|
||
|
|
const target = Object.setPrototypeOf(new EventTarget(), Class.prototype);
|
||
|
|
INTERNALS.set(target, {
|
||
|
|
attributes: {},
|
||
|
|
localName: name,
|
||
|
|
ownerDocument: document,
|
||
|
|
shadowRoot: null,
|
||
|
|
shadowInit: null,
|
||
|
|
});
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
document.body = initElement('body', target.HTMLBodyElement);
|
||
|
|
document.head = initElement('head', target.HTMLHeadElement);
|
||
|
|
document.documentElement = initElement('html', target.HTMLHtmlElement);
|
||
|
|
};
|
||
|
|
|
||
|
|
class HTMLCanvasElement extends HTMLElement {
|
||
|
|
get height() {
|
||
|
|
return internalsOf(this, 'HTMLCanvasElement', 'height').height;
|
||
|
|
}
|
||
|
|
set height(value) {
|
||
|
|
internalsOf(this, 'HTMLCanvasElement', 'height').height =
|
||
|
|
Number(value) || 0;
|
||
|
|
}
|
||
|
|
get width() {
|
||
|
|
return internalsOf(this, 'HTMLCanvasElement', 'width').width;
|
||
|
|
}
|
||
|
|
set width(value) {
|
||
|
|
internalsOf(this, 'HTMLCanvasElement', 'width').width = Number(value) || 0;
|
||
|
|
}
|
||
|
|
captureStream() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
getContext(contextType) {
|
||
|
|
const internals = internalsOf(this, 'HTMLCanvasElement', 'getContext');
|
||
|
|
switch (contextType) {
|
||
|
|
case '2d':
|
||
|
|
if (internals.renderingContext2D)
|
||
|
|
return internals.renderingContext2D;
|
||
|
|
internals.renderingContext2D = __createCanvasRenderingContext2D(this);
|
||
|
|
return internals.renderingContext2D;
|
||
|
|
default:
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
toBlob() { }
|
||
|
|
toDataURL() { }
|
||
|
|
transferControlToOffscreen() { }
|
||
|
|
}
|
||
|
|
allowStringTag(HTMLCanvasElement);
|
||
|
|
|
||
|
|
class HTMLImageElement extends HTMLElement {
|
||
|
|
get src() {
|
||
|
|
return internalsOf(this, 'HTMLImageElement', 'src').src;
|
||
|
|
}
|
||
|
|
set src(value) {
|
||
|
|
const internals = internalsOf(this, 'HTMLImageElement', 'src');
|
||
|
|
internals.src = String(value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
allowStringTag(HTMLImageElement);
|
||
|
|
|
||
|
|
function Image() {
|
||
|
|
// @ts-expect-error
|
||
|
|
INTERNALS.set(this, {
|
||
|
|
attributes: {},
|
||
|
|
localName: 'img',
|
||
|
|
innerHTML: '',
|
||
|
|
shadowRoot: null,
|
||
|
|
shadowInit: null,
|
||
|
|
});
|
||
|
|
}
|
||
|
|
Image.prototype = HTMLImageElement.prototype;
|
||
|
|
|
||
|
|
class MediaQueryList extends EventTarget {
|
||
|
|
get matches() {
|
||
|
|
return internalsOf(this, 'MediaQueryList', 'matches').matches;
|
||
|
|
}
|
||
|
|
get media() {
|
||
|
|
return internalsOf(this, 'MediaQueryList', 'media').media;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
allowStringTag(MediaQueryList);
|
||
|
|
const initMediaQueryList = (target, exclude) => {
|
||
|
|
if (exclude.has('MediaQueryList') || exclude.has('matchMedia'))
|
||
|
|
return;
|
||
|
|
const EventTarget = target.EventTarget || globalThis.EventTarget;
|
||
|
|
const MediaQueryList = target.MediaQueryList || globalThis.MediaQueryList;
|
||
|
|
target.matchMedia = function matchMedia(media) {
|
||
|
|
const mql = Object.setPrototypeOf(new EventTarget(), MediaQueryList.prototype);
|
||
|
|
INTERNALS.set(mql, {
|
||
|
|
matches: false,
|
||
|
|
media,
|
||
|
|
});
|
||
|
|
return mql;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
class IntersectionObserver {
|
||
|
|
disconnect() { }
|
||
|
|
observe() { }
|
||
|
|
takeRecords() {
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
unobserve() { }
|
||
|
|
}
|
||
|
|
class MutationObserver {
|
||
|
|
disconnect() { }
|
||
|
|
observe() { }
|
||
|
|
takeRecords() {
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
unobserve() { }
|
||
|
|
}
|
||
|
|
class ResizeObserver {
|
||
|
|
disconnect() { }
|
||
|
|
observe() { }
|
||
|
|
takeRecords() {
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
unobserve() { }
|
||
|
|
}
|
||
|
|
allowStringTag(MutationObserver);
|
||
|
|
allowStringTag(IntersectionObserver);
|
||
|
|
allowStringTag(ResizeObserver);
|
||
|
|
|
||
|
|
class OffscreenCanvas extends EventTarget {
|
||
|
|
constructor(width, height) {
|
||
|
|
super();
|
||
|
|
if (arguments.length < 2)
|
||
|
|
throw new TypeError(`Failed to construct 'OffscreenCanvas': 2 arguments required.`);
|
||
|
|
width = Number(width) || 0;
|
||
|
|
height = Number(height) || 0;
|
||
|
|
INTERNALS.set(this, { width, height });
|
||
|
|
}
|
||
|
|
get height() {
|
||
|
|
return internalsOf(this, 'OffscreenCanvas', 'height').height;
|
||
|
|
}
|
||
|
|
set height(value) {
|
||
|
|
internalsOf(this, 'OffscreenCanvas', 'height').height = Number(value) || 0;
|
||
|
|
}
|
||
|
|
get width() {
|
||
|
|
return internalsOf(this, 'OffscreenCanvas', 'width').width;
|
||
|
|
}
|
||
|
|
set width(value) {
|
||
|
|
internalsOf(this, 'OffscreenCanvas', 'width').width = Number(value) || 0;
|
||
|
|
}
|
||
|
|
getContext(contextType) {
|
||
|
|
const internals = internalsOf(this, 'HTMLCanvasElement', 'getContext');
|
||
|
|
switch (contextType) {
|
||
|
|
case '2d':
|
||
|
|
if (internals.renderingContext2D)
|
||
|
|
return internals.renderingContext2D;
|
||
|
|
internals.renderingContext2D = __createCanvasRenderingContext2D(this);
|
||
|
|
return internals.renderingContext2D;
|
||
|
|
default:
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
convertToBlob(options) {
|
||
|
|
options = Object(options);
|
||
|
|
Number(options.quality) || 0;
|
||
|
|
const type = getImageType(String(options.type).trim().toLowerCase());
|
||
|
|
return Promise.resolve(new Blob([], { type }));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
allowStringTag(OffscreenCanvas);
|
||
|
|
const getImageType = (type) => type === 'image/avif' ||
|
||
|
|
type === 'image/jpeg' ||
|
||
|
|
type === 'image/png' ||
|
||
|
|
type === 'image/webp'
|
||
|
|
? type
|
||
|
|
: 'image/png';
|
||
|
|
|
||
|
|
class Storage {
|
||
|
|
clear() {
|
||
|
|
internalsOf(this, 'Storage', 'clear').storage.clear();
|
||
|
|
}
|
||
|
|
getItem(key) {
|
||
|
|
return getStringOrNull(internalsOf(this, 'Storage', 'getItem').storage.get(String(key)));
|
||
|
|
}
|
||
|
|
key(index) {
|
||
|
|
return getStringOrNull([
|
||
|
|
...internalsOf(this, 'Storage', 'key').storage.keys(),
|
||
|
|
][Number(index) || 0]);
|
||
|
|
}
|
||
|
|
removeItem(key) {
|
||
|
|
internalsOf(this, 'Storage', 'getItem').storage.delete(String(key));
|
||
|
|
}
|
||
|
|
setItem(key, value) {
|
||
|
|
internalsOf(this, 'Storage', 'getItem').storage.set(String(key), String(value));
|
||
|
|
}
|
||
|
|
get length() {
|
||
|
|
return internalsOf(this, 'Storage', 'size').storage.size;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const getStringOrNull = (value) => typeof value === 'string' ? value : null;
|
||
|
|
const initStorage = (target, exclude) => {
|
||
|
|
if (exclude.has('Storage') || exclude.has('localStorage'))
|
||
|
|
return;
|
||
|
|
target.localStorage = Object.create(Storage.prototype);
|
||
|
|
const storageInternals = new Map();
|
||
|
|
INTERNALS.set(target.localStorage, {
|
||
|
|
storage: storageInternals,
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
class StyleSheet {
|
||
|
|
}
|
||
|
|
class CSSStyleSheet extends StyleSheet {
|
||
|
|
async replace(text) {
|
||
|
|
return new CSSStyleSheet();
|
||
|
|
}
|
||
|
|
replaceSync(text) {
|
||
|
|
return new CSSStyleSheet();
|
||
|
|
}
|
||
|
|
get cssRules() {
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
allowStringTag(StyleSheet);
|
||
|
|
allowStringTag(CSSStyleSheet);
|
||
|
|
|
||
|
|
class Window extends EventTarget {
|
||
|
|
get self() {
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
get top() {
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
get window() {
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
get innerHeight() {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
get innerWidth() {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
get scrollX() {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
get scrollY() {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
allowStringTag(Window);
|
||
|
|
const initWindow = (target, exclude) => {
|
||
|
|
if (exclude.has('Window') || exclude.has('window'))
|
||
|
|
return;
|
||
|
|
target.window = target;
|
||
|
|
};
|
||
|
|
|
||
|
|
function alert(...messages) {
|
||
|
|
console.log(...messages);
|
||
|
|
}
|
||
|
|
|
||
|
|
const exclusionsForHTMLElement = [
|
||
|
|
'CustomElementsRegistry',
|
||
|
|
'HTMLElement',
|
||
|
|
'HTMLBodyElement',
|
||
|
|
'HTMLCanvasElement',
|
||
|
|
'HTMLDivElement',
|
||
|
|
'HTMLHeadElement',
|
||
|
|
'HTMLHtmlElement',
|
||
|
|
'HTMLImageElement',
|
||
|
|
'HTMLStyleElement',
|
||
|
|
'HTMLTemplateElement',
|
||
|
|
'HTMLUnknownElement',
|
||
|
|
'Image',
|
||
|
|
];
|
||
|
|
const exclusionsForElement = ['Element', ...exclusionsForHTMLElement];
|
||
|
|
const exclusionsForDocument = [
|
||
|
|
'CustomElementsRegistry',
|
||
|
|
'Document',
|
||
|
|
'HTMLDocument',
|
||
|
|
'document',
|
||
|
|
'customElements',
|
||
|
|
];
|
||
|
|
const exclusionsForNode = [
|
||
|
|
'Node',
|
||
|
|
'DocumentFragment',
|
||
|
|
'ShadowRoot',
|
||
|
|
...exclusionsForDocument,
|
||
|
|
...exclusionsForElement,
|
||
|
|
];
|
||
|
|
const exclusionsForEventTarget = [
|
||
|
|
'Event',
|
||
|
|
'CustomEvent',
|
||
|
|
'EventTarget',
|
||
|
|
'OffscreenCanvas',
|
||
|
|
'MediaQueryList',
|
||
|
|
'Window',
|
||
|
|
...exclusionsForNode,
|
||
|
|
];
|
||
|
|
const exclusionsForEvent = [
|
||
|
|
'Event',
|
||
|
|
'CustomEvent',
|
||
|
|
'EventTarget',
|
||
|
|
'MediaQueryList',
|
||
|
|
'OffscreenCanvas',
|
||
|
|
'Window',
|
||
|
|
...exclusionsForNode,
|
||
|
|
];
|
||
|
|
const exclusions = {
|
||
|
|
'Document+': exclusionsForDocument,
|
||
|
|
'Element+': exclusionsForElement,
|
||
|
|
'Event+': exclusionsForEvent,
|
||
|
|
'EventTarget+': exclusionsForEventTarget,
|
||
|
|
'HTMLElement+': exclusionsForHTMLElement,
|
||
|
|
'Node+': exclusionsForNode,
|
||
|
|
'StyleSheet+': ['StyleSheet', 'CSSStyleSheet'],
|
||
|
|
};
|
||
|
|
|
||
|
|
const inheritance = {
|
||
|
|
CSSStyleSheet: 'StyleSheet',
|
||
|
|
CustomEvent: 'Event',
|
||
|
|
DOMException: 'Error',
|
||
|
|
Document: 'Node',
|
||
|
|
DocumentFragment: 'Node',
|
||
|
|
Element: 'Node',
|
||
|
|
HTMLDocument: 'Document',
|
||
|
|
HTMLElement: 'Element',
|
||
|
|
HTMLBodyElement: 'HTMLElement',
|
||
|
|
HTMLCanvasElement: 'HTMLElement',
|
||
|
|
HTMLDivElement: 'HTMLElement',
|
||
|
|
HTMLHeadElement: 'HTMLElement',
|
||
|
|
HTMLHtmlElement: 'HTMLElement',
|
||
|
|
HTMLImageElement: 'HTMLElement',
|
||
|
|
HTMLSpanElement: 'HTMLElement',
|
||
|
|
HTMLStyleElement: 'HTMLElement',
|
||
|
|
HTMLTemplateElement: 'HTMLElement',
|
||
|
|
HTMLUnknownElement: 'HTMLElement',
|
||
|
|
Image: 'HTMLElement',
|
||
|
|
MediaQueryList: 'EventTarget',
|
||
|
|
Node: 'EventTarget',
|
||
|
|
OffscreenCanvas: 'EventTarget',
|
||
|
|
ShadowRoot: 'DocumentFragment',
|
||
|
|
Window: 'EventTarget',
|
||
|
|
};
|
||
|
|
|
||
|
|
const polyfill = (target, options) => {
|
||
|
|
const webAPIs = {
|
||
|
|
ByteLengthQueuingStrategy,
|
||
|
|
CanvasRenderingContext2D,
|
||
|
|
CharacterData,
|
||
|
|
Comment,
|
||
|
|
CountQueuingStrategy,
|
||
|
|
CSSStyleSheet,
|
||
|
|
CustomElementRegistry,
|
||
|
|
CustomEvent,
|
||
|
|
Document,
|
||
|
|
DocumentFragment,
|
||
|
|
DOMException,
|
||
|
|
Element,
|
||
|
|
Event,
|
||
|
|
EventTarget,
|
||
|
|
File,
|
||
|
|
FormData,
|
||
|
|
HTMLDocument,
|
||
|
|
HTMLElement,
|
||
|
|
HTMLBodyElement,
|
||
|
|
HTMLCanvasElement,
|
||
|
|
HTMLDivElement,
|
||
|
|
HTMLHeadElement,
|
||
|
|
HTMLHtmlElement,
|
||
|
|
HTMLImageElement,
|
||
|
|
HTMLSpanElement,
|
||
|
|
HTMLStyleElement,
|
||
|
|
HTMLTemplateElement,
|
||
|
|
HTMLUnknownElement,
|
||
|
|
Headers,
|
||
|
|
IntersectionObserver,
|
||
|
|
Image,
|
||
|
|
ImageData,
|
||
|
|
MediaQueryList,
|
||
|
|
MutationObserver,
|
||
|
|
Node,
|
||
|
|
NodeFilter: NodeFilter$1,
|
||
|
|
NodeIterator: NodeIterator$1,
|
||
|
|
OffscreenCanvas,
|
||
|
|
ReadableByteStreamController,
|
||
|
|
ReadableStream,
|
||
|
|
ReadableStreamBYOBReader,
|
||
|
|
ReadableStreamBYOBRequest,
|
||
|
|
ReadableStreamDefaultController,
|
||
|
|
ReadableStreamDefaultReader,
|
||
|
|
Request,
|
||
|
|
ResizeObserver,
|
||
|
|
Response,
|
||
|
|
ShadowRoot,
|
||
|
|
Storage,
|
||
|
|
StyleSheet,
|
||
|
|
Text,
|
||
|
|
TransformStream,
|
||
|
|
TreeWalker,
|
||
|
|
URLPattern: U,
|
||
|
|
WritableStream,
|
||
|
|
WritableStreamDefaultController,
|
||
|
|
WritableStreamDefaultWriter,
|
||
|
|
Window,
|
||
|
|
alert,
|
||
|
|
cancelAnimationFrame,
|
||
|
|
cancelIdleCallback,
|
||
|
|
clearTimeout,
|
||
|
|
crypto: webcrypto,
|
||
|
|
fetch,
|
||
|
|
requestAnimationFrame,
|
||
|
|
requestIdleCallback,
|
||
|
|
setTimeout,
|
||
|
|
structuredClone,
|
||
|
|
};
|
||
|
|
// initialize exclude options
|
||
|
|
const excludeOptions = new Set(typeof Object(options).exclude === 'string'
|
||
|
|
? String(Object(options).exclude).trim().split(/\s+/)
|
||
|
|
: Array.isArray(Object(options).exclude)
|
||
|
|
? Object(options).exclude.reduce((array, entry) => array.splice(array.length, 0, ...(typeof entry === 'string' ? entry.trim().split(/\s+/) : [])) && array, [])
|
||
|
|
: []);
|
||
|
|
// expand exclude options using exclusion shorthands
|
||
|
|
for (const excludeOption of excludeOptions) {
|
||
|
|
if (excludeOption in exclusions) {
|
||
|
|
for (const exclusion of exclusions[excludeOption]) {
|
||
|
|
excludeOptions.add(exclusion);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// apply each WebAPI
|
||
|
|
for (const name of Object.keys(webAPIs)) {
|
||
|
|
// skip WebAPIs that are excluded
|
||
|
|
if (excludeOptions.has(name))
|
||
|
|
continue;
|
||
|
|
// skip WebAPIs that are built-in
|
||
|
|
if (Object.hasOwnProperty.call(target, name))
|
||
|
|
continue;
|
||
|
|
// define WebAPIs on the target
|
||
|
|
Object.defineProperty(target, name, {
|
||
|
|
configurable: true,
|
||
|
|
enumerable: true,
|
||
|
|
writable: true,
|
||
|
|
value: webAPIs[name],
|
||
|
|
});
|
||
|
|
}
|
||
|
|
// ensure WebAPIs correctly inherit other WebAPIs
|
||
|
|
for (const name of Object.keys(webAPIs)) {
|
||
|
|
// skip WebAPIs that are excluded
|
||
|
|
if (excludeOptions.has(name))
|
||
|
|
continue;
|
||
|
|
// skip WebAPIs that do not extend other WebAPIs
|
||
|
|
if (!Object.hasOwnProperty.call(inheritance, name))
|
||
|
|
continue;
|
||
|
|
const Class = target[name];
|
||
|
|
const Super = target[inheritance[name]];
|
||
|
|
// skip WebAPIs that are not available
|
||
|
|
if (!Class || !Super)
|
||
|
|
continue;
|
||
|
|
// skip WebAPIs that are already inherited correctly
|
||
|
|
if (Object.getPrototypeOf(Class.prototype) === Super.prototype)
|
||
|
|
continue;
|
||
|
|
// define WebAPIs inheritance
|
||
|
|
Object.setPrototypeOf(Class.prototype, Super.prototype);
|
||
|
|
}
|
||
|
|
if (!excludeOptions.has('HTMLDocument') &&
|
||
|
|
!excludeOptions.has('HTMLElement')) {
|
||
|
|
initDocument(target, excludeOptions);
|
||
|
|
if (!excludeOptions.has('CustomElementRegistry')) {
|
||
|
|
initCustomElementRegistry(target, excludeOptions);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
initMediaQueryList(target, excludeOptions);
|
||
|
|
initStorage(target, excludeOptions);
|
||
|
|
initWindow(target, excludeOptions);
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
polyfill.internals = (target, name) => {
|
||
|
|
const init = {
|
||
|
|
CustomElementRegistry: initCustomElementRegistry,
|
||
|
|
Document: initDocument,
|
||
|
|
MediaQueryList: initMediaQueryList,
|
||
|
|
Storage: initStorage,
|
||
|
|
Window: initWindow,
|
||
|
|
};
|
||
|
|
init[name](target, new Set());
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
|
||
|
|
export { CSSStyleSheet, CanvasRenderingContext2D, CharacterData, Comment, CustomElementRegistry, CustomEvent, DOMException, Document, DocumentFragment, Element, Event, EventTarget, HTMLBodyElement, HTMLCanvasElement, HTMLDivElement, HTMLDocument, HTMLElement, HTMLHeadElement, HTMLHtmlElement, HTMLImageElement, HTMLSpanElement, HTMLStyleElement, HTMLTemplateElement, HTMLUnknownElement, Image, ImageData, IntersectionObserver, MediaQueryList, MutationObserver, Node, NodeFilter$1 as NodeFilter, NodeIterator$1 as NodeIterator, OffscreenCanvas, ResizeObserver, ShadowRoot, StyleSheet, Text, TreeWalker, U as URLPattern, Window, alert, cancelAnimationFrame, cancelIdleCallback, clearTimeout, pathToPosix, polyfill, requestAnimationFrame, requestIdleCallback, setTimeout, structuredClone };
|
||
|
|
//# sourceMappingURL=mod.js.map
|