430 lines
15 KiB
JavaScript
430 lines
15 KiB
JavaScript
var __bare_os_bundle_exports__ = (() => {
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __commonJS = (cb, mod) => function __require() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
// If the importer is in node compatibility mode or this is not an ESM
|
|
// file that has been converted to a CommonJS file using a Babel-
|
|
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
|
|
// ../../node_modules/bare-events/web.js
|
|
var require_web = __commonJS({
|
|
"../../node_modules/bare-events/web.js"(exports) {
|
|
var BUBBLES = 1;
|
|
var CANCELABLE = 2;
|
|
var COMPOSED = 4;
|
|
var CANCELED = 8;
|
|
var DISPATCH = 16;
|
|
var STOP = 32;
|
|
var CAPTURE = 1;
|
|
var PASSIVE = 2;
|
|
var ONCE = 4;
|
|
var Event = class _Event {
|
|
// https://dom.spec.whatwg.org/#dom-event-event
|
|
constructor(type, options = {}) {
|
|
const { bubbles = false, cancelable = false, composed = false } = options;
|
|
this._type = type;
|
|
this._target = null;
|
|
this._state = 0;
|
|
if (bubbles) this._state |= BUBBLES;
|
|
if (cancelable) this._state |= CANCELABLE;
|
|
if (composed) this._state |= COMPOSED;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-event-type
|
|
get type() {
|
|
return this._type;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-event-target
|
|
get target() {
|
|
return this._target;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-event-currenttarget
|
|
get currentTarget() {
|
|
return null;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-event-bubbles
|
|
get bubbles() {
|
|
return (this._state & BUBBLES) !== 0;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-event-cancelable
|
|
get cancelable() {
|
|
return (this._state & CANCELABLE) !== 0;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-event-composed
|
|
get composed() {
|
|
return (this._state & COMPOSED) !== 0;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-event-defaultprevented
|
|
get defaultPrevented() {
|
|
return (this._state & CANCELED) !== 0;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-event-istrusted
|
|
get isTrusted() {
|
|
return false;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-event-preventdefault
|
|
preventDefault() {
|
|
if (this._state & CANCELABLE) this._state |= CANCELED;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-event-stoppropagation
|
|
stopPropagation() {
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-event-stopimmediatepropagation
|
|
stopImmediatePropagation() {
|
|
this._state |= STOP;
|
|
}
|
|
toJSON() {
|
|
return {
|
|
type: this.type,
|
|
target: this.target,
|
|
bubbles: this.bubbles,
|
|
cancelable: this.cancelable,
|
|
composed: this.composed,
|
|
defaultPrevented: this.defaultPrevented,
|
|
isTrusted: this.isTrusted
|
|
};
|
|
}
|
|
[Symbol.for("bare.inspect")]() {
|
|
return {
|
|
__proto__: { constructor: _Event },
|
|
type: this.type,
|
|
target: this.target,
|
|
bubbles: this.bubbles,
|
|
cancelable: this.cancelable,
|
|
composed: this.composed,
|
|
defaultPrevented: this.defaultPrevented,
|
|
isTrusted: this.isTrusted
|
|
};
|
|
}
|
|
};
|
|
exports.Event = Event;
|
|
exports.CustomEvent = class CustomEvent extends Event {
|
|
constructor(type, options = {}) {
|
|
super(type, options);
|
|
const { detail = null } = options;
|
|
this._detail = detail;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-customevent-detail
|
|
get detail() {
|
|
return this._detail;
|
|
}
|
|
};
|
|
exports.EventTarget = class EventTarget {
|
|
// https://dom.spec.whatwg.org/#dom-eventtarget-eventtarget
|
|
constructor() {
|
|
this._listeners = /* @__PURE__ */ new Map();
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-eventtarget-addeventlistener
|
|
addEventListener(type, callback = null, options = {}) {
|
|
if (typeof options === "boolean") options = { capture: options };
|
|
const { capture = false, passive = false, once = false, signal = null } = options;
|
|
if (signal !== null && signal.aborted) return;
|
|
if (callback === null) return;
|
|
const listener = new EventListener(type, callback, capture, passive, once, signal);
|
|
const listeners = this._listeners.get(type);
|
|
if (listeners === void 0) this._listeners.set(type, listener);
|
|
else {
|
|
for (const existing of listeners) {
|
|
if (callback === existing.callback && capture === existing.capture) {
|
|
return;
|
|
}
|
|
}
|
|
listener.link(listeners);
|
|
if (signal !== null) {
|
|
let onabort2 = function() {
|
|
listener.unlink();
|
|
};
|
|
var onabort = onabort2;
|
|
signal.addEventListener("abort", onabort2);
|
|
}
|
|
}
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-eventtarget-removeeventlistener
|
|
removeEventListener(type, callback = null, options = {}) {
|
|
if (typeof options === "boolean") options = { capture: options };
|
|
const { capture = false } = options;
|
|
const listeners = this._listeners.get(type);
|
|
if (listeners === void 0) return;
|
|
for (const existing of listeners) {
|
|
if (callback === existing.callback && capture === existing.capture) {
|
|
const next = existing.unlink();
|
|
if (listeners === existing) this._listeners.set(type, next);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-eventtarget-dispatchevent
|
|
dispatchEvent(event) {
|
|
event._target = this;
|
|
event._state |= DISPATCH;
|
|
const listeners = this._listeners.get(event.type);
|
|
try {
|
|
if (listeners === void 0) return true;
|
|
for (const listener of listeners) {
|
|
if (listener.once) listener.unlink();
|
|
let callback = listener.callback;
|
|
let context = this;
|
|
if (typeof callback === "object") {
|
|
context = callback;
|
|
callback = callback.handleEvent;
|
|
}
|
|
Reflect.apply(callback, context, [event]);
|
|
if (event._state & STOP) break;
|
|
}
|
|
return (event._state & CANCELED) === 0;
|
|
} finally {
|
|
event._state &= ~DISPATCH;
|
|
event._state &= ~STOP;
|
|
}
|
|
}
|
|
toJSON() {
|
|
return {};
|
|
}
|
|
[Symbol.for("bare.inspect")]() {
|
|
return {
|
|
__proto__: { constructor: EventTarget }
|
|
};
|
|
}
|
|
};
|
|
var EventListener = class _EventListener {
|
|
constructor(type, callback, capture, passive, once, signal) {
|
|
this._type = type;
|
|
this._callback = callback;
|
|
this._signal = signal;
|
|
this._state = 0;
|
|
if (capture) this._state |= CAPTURE;
|
|
if (passive) this._state |= PASSIVE;
|
|
if (once) this._state |= ONCE;
|
|
this._previous = this;
|
|
this._next = this;
|
|
}
|
|
get type() {
|
|
return this._type;
|
|
}
|
|
get callback() {
|
|
return this._callback;
|
|
}
|
|
get capture() {
|
|
return (this._state & CAPTURE) !== 0;
|
|
}
|
|
get passive() {
|
|
return (this._state & PASSIVE) !== 0;
|
|
}
|
|
get once() {
|
|
return (this._state & ONCE) !== 0;
|
|
}
|
|
get removed() {
|
|
return this._previous === this && this._next === this;
|
|
}
|
|
link(listener) {
|
|
const next = this._next;
|
|
const previous = listener._previous;
|
|
this._next = listener;
|
|
listener._previous = this;
|
|
previous._next = next;
|
|
next._previous = previous;
|
|
return listener;
|
|
}
|
|
unlink() {
|
|
if (this.removed) return this;
|
|
const next = this._next;
|
|
const previous = this._previous;
|
|
this._next = this;
|
|
this._previous = this;
|
|
previous._next = next;
|
|
next._previous = previous;
|
|
return next;
|
|
}
|
|
*[Symbol.iterator]() {
|
|
let current = this;
|
|
while (true) {
|
|
const next = current._next;
|
|
yield current;
|
|
if (next === this) break;
|
|
current = next;
|
|
}
|
|
}
|
|
toJSON() {
|
|
return {
|
|
type: this.type,
|
|
capture: this.capture,
|
|
passive: this.passive,
|
|
once: this.once,
|
|
removed: this.removed
|
|
};
|
|
}
|
|
[Symbol.for("bare.inspect")]() {
|
|
return {
|
|
__proto__: { constructor: _EventListener },
|
|
type: this.type,
|
|
callback: this.callback,
|
|
capture: this.capture,
|
|
passive: this.passive,
|
|
once: this.once,
|
|
removed: this.removed
|
|
};
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-abort-controller/index.js
|
|
var require_bare_abort_controller = __commonJS({
|
|
"../../node_modules/bare-abort-controller/index.js"(exports, module) {
|
|
var { Event, EventTarget } = require_web();
|
|
var AbortError = class extends Error {
|
|
get name() {
|
|
return "AbortError";
|
|
}
|
|
};
|
|
var TimeoutError = class extends Error {
|
|
get name() {
|
|
return "TimeoutError";
|
|
}
|
|
};
|
|
var AbortSignal = class _AbortSignal extends EventTarget {
|
|
constructor() {
|
|
super();
|
|
this._reason = void 0;
|
|
this._dependent = false;
|
|
this._sources = [];
|
|
this._dependents = [];
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-abortsignal-aborted
|
|
get aborted() {
|
|
return this._reason !== void 0;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-abortsignal-reason
|
|
get reason() {
|
|
return this._reason;
|
|
}
|
|
// https://dom.spec.whatwg.org/#abortsignal-signal-abort
|
|
_abort(reason = new AbortError("The operation was aborted")) {
|
|
if (this.aborted) return;
|
|
this._reason = reason;
|
|
this.dispatchEvent(new Event("abort"));
|
|
for (const signal of this._dependents) {
|
|
signal._abort(reason);
|
|
}
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-abortsignal-throwifaborted
|
|
throwIfAborted() {
|
|
if (this._reason !== void 0) throw this._reason;
|
|
}
|
|
toJSON() {
|
|
return {
|
|
aborted: this.aborted,
|
|
reason: this.reason
|
|
};
|
|
}
|
|
[Symbol.for("bare.inspect")]() {
|
|
return {
|
|
__proto__: { constructor: _AbortSignal },
|
|
aborted: this.aborted,
|
|
reason: this.reason
|
|
};
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-abortsignal-abort
|
|
static abort(reason) {
|
|
const signal = new _AbortSignal();
|
|
signal._reason = reason;
|
|
return signal;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-abortsignal-timeout
|
|
static timeout(ms) {
|
|
const signal = new _AbortSignal();
|
|
const timer = setTimeout(
|
|
() => signal._abort(new TimeoutError("The operation timed out")),
|
|
ms
|
|
);
|
|
timer.unref();
|
|
return signal;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-abortsignal-any
|
|
static any(signals) {
|
|
const result = new _AbortSignal();
|
|
for (const signal of signals) {
|
|
if (signal.aborted) {
|
|
result._reason = signal.reason;
|
|
return result;
|
|
}
|
|
}
|
|
result._dependent = true;
|
|
for (const signal of signals) {
|
|
if (signal._dependent === false) {
|
|
result._sources.push(signal);
|
|
signal._dependents.push(result);
|
|
} else {
|
|
for (const source of signal._sources) {
|
|
result._sources.push(source);
|
|
source._dependents.push(result);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
var AbortController = class _AbortController {
|
|
constructor() {
|
|
this._signal = new AbortSignal();
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-abortcontroller-signal
|
|
get signal() {
|
|
return this._signal;
|
|
}
|
|
// https://dom.spec.whatwg.org/#dom-abortcontroller-abort
|
|
abort(reason) {
|
|
this._signal._abort(reason);
|
|
}
|
|
toJSON() {
|
|
return {
|
|
signal: this.signal
|
|
};
|
|
}
|
|
[Symbol.for("bare.inspect")]() {
|
|
return {
|
|
__proto__: { constructor: _AbortController },
|
|
signal: this.signal
|
|
};
|
|
}
|
|
};
|
|
module.exports = exports = AbortController;
|
|
exports.AbortController = exports;
|
|
exports.AbortSignal = AbortSignal;
|
|
}
|
|
});
|
|
|
|
// ../../bare-lib-entry-bareAbortController.js
|
|
var bare_lib_entry_bareAbortController_exports = {};
|
|
__export(bare_lib_entry_bareAbortController_exports, {
|
|
default: () => bare_lib_entry_bareAbortController_default
|
|
});
|
|
var import_bare_abort_controller = __toESM(require_bare_abort_controller());
|
|
var bare_lib_entry_bareAbortController_default = import_bare_abort_controller.default;
|
|
return __toCommonJS(bare_lib_entry_bareAbortController_exports);
|
|
})();
|
|
;(function(){var g=globalThis;var s="__bare_os_stdlib__";g[s]=g[s]||{};var e=typeof __bare_os_bundle_exports__!=="undefined"?__bare_os_bundle_exports__:void 0;var v=e!=null&&typeof e==="object"&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e;g[s]["bareAbortController"]=v;})();
|