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]||{};g[s]["bareAbortController"]=typeof __bare_os_bundle_exports__!=="undefined"?__bare_os_bundle_exports__:void 0;})();