@gjsify/stream 0.0.3 → 0.1.0

package/test.node.js

@@ -1,1234 +0,0 @@
-// ../../web/events/lib/esm/index.js
-import { EventEmitter } from "events";
-var globalEventEmitter = new EventEmitter();
-globalEventEmitter.on("load", (event) => {
-  if (typeof globalThis.onload === "function") {
-    globalThis.onload.call(globalThis, event);
-  }
-});
-globalEventEmitter.on("beforeunload", (event) => {
-  if (typeof globalThis.beforeunload === "function") {
-    globalThis.beforeunload.call(globalThis, event);
-  }
-});
-globalEventEmitter.on("unload", (event) => {
-  if (typeof globalThis.unload === "function") {
-    globalThis.unload.call(globalThis, event);
-  }
-});
-if (!globalThis.addEventListener)
-  Object.defineProperty(globalThis, "addEventListener", { value: globalEventEmitter.addListener });
-if (!globalThis.removeEventListener)
-  Object.defineProperty(globalThis, "removeEventListener", { value: globalEventEmitter.removeListener });
-
-// ../../web/event-target/lib/esm/misc.js
-function assertType(condition, message, ...args) {
-  if (!condition) {
-    throw new TypeError(format(message, args));
-  }
-}
-function format(message, args) {
-  let i = 0;
-  return message.replace(/%[os]/gu, () => anyToString(args[i++]));
-}
-function anyToString(x) {
-  if (typeof x !== "object" || x === null) {
-    return String(x);
-  }
-  return Object.prototype.toString.call(x);
-}
-
-// ../../web/event-target/lib/esm/error-handler.js
-var currentErrorHandler;
-function reportError(maybeError) {
-  try {
-    const error = maybeError instanceof Error ? maybeError : new Error(anyToString(maybeError));
-    if (currentErrorHandler) {
-      currentErrorHandler(error);
-      return;
-    }
-    if (typeof dispatchEvent === "function" && typeof ErrorEvent === "function") {
-      dispatchEvent(
-        new ErrorEvent("error", { error, message: error.message })
-      );
-    } else if (typeof process !== "undefined" && typeof process.emit === "function") {
-      process.emit("uncaughtException", error);
-      return;
-    }
-    console.error(error);
-  } catch {
-  }
-}
-
-// ../../web/event-target/lib/esm/warning-handler.js
-var currentWarnHandler;
-var Warning = class {
-  code;
-  message;
-  constructor(code, message) {
-    this.code = code;
-    this.message = message;
-  }
-  warn(...args) {
-    try {
-      if (currentWarnHandler) {
-        currentWarnHandler({ ...this, args });
-        return;
-      }
-      const stack = (new Error().stack ?? "").replace(
-        /^(?:.+?\n){2}/gu,
-        "\n"
-      );
-      console.warn(this.message, ...args, stack);
-    } catch {
-    }
-  }
-};
-
-// ../../web/event-target/lib/esm/warnings.js
-var InitEventWasCalledWhileDispatching = new Warning(
-  "W01",
-  "Unable to initialize event under dispatching."
-);
-var FalsyWasAssignedToCancelBubble = new Warning(
-  "W02",
-  "Assigning any falsy value to 'cancelBubble' property has no effect."
-);
-var TruthyWasAssignedToReturnValue = new Warning(
-  "W03",
-  "Assigning any truthy value to 'returnValue' property has no effect."
-);
-var NonCancelableEventWasCanceled = new Warning(
-  "W04",
-  "Unable to preventDefault on non-cancelable events."
-);
-var CanceledInPassiveListener = new Warning(
-  "W05",
-  "Unable to preventDefault inside passive event listener invocation."
-);
-var EventListenerWasDuplicated = new Warning(
-  "W06",
-  "An event listener wasn't added because it has been added already: %o, %o"
-);
-var OptionWasIgnored = new Warning(
-  "W07",
-  "The %o option value was abandoned because the event listener wasn't added as duplicated."
-);
-var InvalidEventListener = new Warning(
-  "W08",
-  "The 'callback' argument must be a function or an object that has 'handleEvent' method: %o"
-);
-var InvalidAttributeHandler = new Warning("W09", "Event attribute handler must be a function: %o");
-
-// ../../web/event-target/lib/esm/event.js
-var Event = class {
-  static get NONE() {
-    return NONE;
-  }
-  static get CAPTURING_PHASE() {
-    return CAPTURING_PHASE;
-  }
-  static get AT_TARGET() {
-    return AT_TARGET;
-  }
-  static get BUBBLING_PHASE() {
-    return BUBBLING_PHASE;
-  }
-  constructor(type, eventInitDict) {
-    Object.defineProperty(this, "isTrusted", {
-      value: false,
-      enumerable: true
-    });
-    const opts = 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()
-    });
-  }
-  get type() {
-    return $(this).type;
-  }
-  get target() {
-    return $(this).target;
-  }
-  get srcElement() {
-    return $(this).target;
-  }
-  get currentTarget() {
-    return $(this).currentTarget;
-  }
-  composedPath() {
-    const currentTarget = $(this).currentTarget;
-    if (currentTarget) {
-      return [currentTarget];
-    }
-    return [];
-  }
-  get NONE() {
-    return NONE;
-  }
-  get CAPTURING_PHASE() {
-    return CAPTURING_PHASE;
-  }
-  get AT_TARGET() {
-    return AT_TARGET;
-  }
-  get BUBBLING_PHASE() {
-    return BUBBLING_PHASE;
-  }
-  get eventPhase() {
-    return $(this).dispatchFlag ? 2 : 0;
-  }
-  stopPropagation() {
-    $(this).stopPropagationFlag = true;
-  }
-  get cancelBubble() {
-    return $(this).stopPropagationFlag;
-  }
-  set cancelBubble(value) {
-    if (value) {
-      $(this).stopPropagationFlag = true;
-    } else {
-      FalsyWasAssignedToCancelBubble.warn();
-    }
-  }
-  stopImmediatePropagation() {
-    const data = $(this);
-    data.stopPropagationFlag = data.stopImmediatePropagationFlag = true;
-  }
-  get bubbles() {
-    return $(this).bubbles;
-  }
-  get cancelable() {
-    return $(this).cancelable;
-  }
-  get returnValue() {
-    return !$(this).canceledFlag;
-  }
-  set returnValue(value) {
-    if (!value) {
-      setCancelFlag($(this));
-    } else {
-      TruthyWasAssignedToReturnValue.warn();
-    }
-  }
-  preventDefault() {
-    setCancelFlag($(this));
-  }
-  get defaultPrevented() {
-    return $(this).canceledFlag;
-  }
-  get composed() {
-    return $(this).composed;
-  }
-  get isTrusted() {
-    return false;
-  }
-  get timeStamp() {
-    return $(this).timeStamp;
-  }
-  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
-    });
-  }
-};
-var NONE = 0;
-var CAPTURING_PHASE = 1;
-var AT_TARGET = 2;
-var BUBBLING_PHASE = 3;
-var internalDataMap = /* @__PURE__ */ new WeakMap();
-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;
-}
-function setCancelFlag(data) {
-  if (data.inPassiveListenerFlag) {
-    CanceledInPassiveListener.warn();
-    return;
-  }
-  if (!data.cancelable) {
-    NonCancelableEventWasCanceled.warn();
-    return;
-  }
-  data.canceledFlag = true;
-}
-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 });
-var keys = Object.getOwnPropertyNames(Event.prototype);
-for (let i = 0; i < keys.length; ++i) {
-  if (keys[i] === "constructor") {
-    continue;
-  }
-  Object.defineProperty(Event.prototype, keys[i], { enumerable: true });
-}
-if (typeof globalThis !== "undefined" && typeof globalThis.Event !== "undefined") {
-  Object.setPrototypeOf(Event.prototype, globalThis.Event.prototype);
-}
-
-// ../../web/event-target/lib/esm/dom-exception.js
-function createInvalidStateError(message) {
-  if (globalThis.DOMException) {
-    return new globalThis.DOMException(message, "InvalidStateError");
-  }
-  if (DOMException == null) {
-    DOMException = class DOMException2 extends Error {
-      constructor(msg) {
-        super(msg);
-        if (Error.captureStackTrace) {
-          ;
-          Error.captureStackTrace(this, DOMException2);
-        }
-      }
-      get code() {
-        return 11;
-      }
-      get name() {
-        return "InvalidStateError";
-      }
-    };
-    Object.defineProperties(DOMException.prototype, {
-      code: { enumerable: true },
-      name: { enumerable: true }
-    });
-    defineErrorCodeProperties(DOMException);
-    defineErrorCodeProperties(DOMException.prototype);
-  }
-  return new DOMException(message);
-}
-var DOMException;
-var ErrorCodeMap = {
-  INDEX_SIZE_ERR: 1,
-  DOMSTRING_SIZE_ERR: 2,
-  HIERARCHY_REQUEST_ERR: 3,
-  WRONG_DOCUMENT_ERR: 4,
-  INVALID_CHARACTER_ERR: 5,
-  NO_DATA_ALLOWED_ERR: 6,
-  NO_MODIFICATION_ALLOWED_ERR: 7,
-  NOT_FOUND_ERR: 8,
-  NOT_SUPPORTED_ERR: 9,
-  INUSE_ATTRIBUTE_ERR: 10,
-  INVALID_STATE_ERR: 11,
-  SYNTAX_ERR: 12,
-  INVALID_MODIFICATION_ERR: 13,
-  NAMESPACE_ERR: 14,
-  INVALID_ACCESS_ERR: 15,
-  VALIDATION_ERR: 16,
-  TYPE_MISMATCH_ERR: 17,
-  SECURITY_ERR: 18,
-  NETWORK_ERR: 19,
-  ABORT_ERR: 20,
-  URL_MISMATCH_ERR: 21,
-  QUOTA_EXCEEDED_ERR: 22,
-  TIMEOUT_ERR: 23,
-  INVALID_NODE_TYPE_ERR: 24,
-  DATA_CLONE_ERR: 25
-};
-function defineErrorCodeProperties(obj) {
-  const keys3 = Object.keys(ErrorCodeMap);
-  for (let i = 0; i < keys3.length; ++i) {
-    const key = keys3[i];
-    const value = ErrorCodeMap[key];
-    Object.defineProperty(obj, key, {
-      get() {
-        return value;
-      },
-      configurable: true,
-      enumerable: true
-    });
-  }
-}
-
-// ../../web/event-target/lib/esm/event-wrapper.js
-var EventWrapper = class extends Event {
-  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();
-    }
-    internalDataMap2.set(this, { original: event });
-    const keys3 = Object.keys(event);
-    for (let i = 0; i < keys3.length; ++i) {
-      const key = keys3[i];
-      if (!(key in this)) {
-        Object.defineProperty(
-          this,
-          key,
-          defineRedirectDescriptor(event, key)
-        );
-      }
-    }
-  }
-  stopPropagation() {
-    super.stopPropagation();
-    const { original } = $2(this);
-    if ("stopPropagation" in original) {
-      original.stopPropagation();
-    }
-  }
-  get cancelBubble() {
-    return super.cancelBubble;
-  }
-  set cancelBubble(value) {
-    super.cancelBubble = value;
-    const { original } = $2(this);
-    if ("cancelBubble" in original) {
-      original.cancelBubble = value;
-    }
-  }
-  stopImmediatePropagation() {
-    super.stopImmediatePropagation();
-    const { original } = $2(this);
-    if ("stopImmediatePropagation" in original) {
-      original.stopImmediatePropagation();
-    }
-  }
-  get returnValue() {
-    return super.returnValue;
-  }
-  set returnValue(value) {
-    super.returnValue = value;
-    const { original } = $2(this);
-    if ("returnValue" in original) {
-      original.returnValue = value;
-    }
-  }
-  preventDefault() {
-    super.preventDefault();
-    const { original } = $2(this);
-    if ("preventDefault" in original) {
-      original.preventDefault();
-    }
-  }
-  get timeStamp() {
-    const { original } = $2(this);
-    if ("timeStamp" in original) {
-      return original.timeStamp;
-    }
-    return super.timeStamp;
-  }
-};
-var internalDataMap2 = /* @__PURE__ */ new WeakMap();
-function $2(event) {
-  const retv = internalDataMap2.get(event);
-  assertType(
-    retv != null,
-    "'this' is expected an Event object, but got",
-    event
-  );
-  return retv;
-}
-var wrapperClassCache = /* @__PURE__ */ new WeakMap();
-wrapperClassCache.set(Object.prototype, EventWrapper);
-if (typeof globalThis !== "undefined" && typeof globalThis.Event !== "undefined") {
-  wrapperClassCache.set(globalThis.Event.prototype, EventWrapper);
-}
-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;
-}
-function defineWrapper(BaseEventWrapper, originalPrototype) {
-  class CustomEventWrapper extends BaseEventWrapper {
-  }
-  const keys3 = Object.keys(originalPrototype);
-  for (let i = 0; i < keys3.length; ++i) {
-    Object.defineProperty(
-      CustomEventWrapper.prototype,
-      keys3[i],
-      defineRedirectDescriptor(originalPrototype, keys3[i])
-    );
-  }
-  return CustomEventWrapper;
-}
-function defineRedirectDescriptor(obj, key) {
-  const d = Object.getOwnPropertyDescriptor(obj, key);
-  return {
-    get() {
-      const original = $2(this).original;
-      const value = original[key];
-      if (typeof value === "function") {
-        return value.bind(original);
-      }
-      return value;
-    },
-    set(value) {
-      const original = $2(this).original;
-      original[key] = value;
-    },
-    configurable: d.configurable,
-    enumerable: d.enumerable
-  };
-}
-
-// ../../web/event-target/lib/esm/listener.js
-function createListener(callback, capture, passive, once, signal, signalListener) {
-  return {
-    callback,
-    flags: (capture ? ListenerFlags.Capture : 0) | (passive ? ListenerFlags.Passive : 0) | (once ? ListenerFlags.Once : 0),
-    signal,
-    signalListener
-  };
-}
-function setRemoved(listener) {
-  listener.flags |= ListenerFlags.Removed;
-}
-function isCapture(listener) {
-  return (listener.flags & ListenerFlags.Capture) === ListenerFlags.Capture;
-}
-function isPassive(listener) {
-  return (listener.flags & ListenerFlags.Passive) === ListenerFlags.Passive;
-}
-function isOnce(listener) {
-  return (listener.flags & ListenerFlags.Once) === ListenerFlags.Once;
-}
-function isRemoved(listener) {
-  return (listener.flags & ListenerFlags.Removed) === ListenerFlags.Removed;
-}
-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);
-  }
-}
-var ListenerFlags = /* @__PURE__ */ ((ListenerFlags2) => {
-  ListenerFlags2[ListenerFlags2["Capture"] = 1] = "Capture";
-  ListenerFlags2[ListenerFlags2["Passive"] = 2] = "Passive";
-  ListenerFlags2[ListenerFlags2["Once"] = 4] = "Once";
-  ListenerFlags2[ListenerFlags2["Removed"] = 8] = "Removed";
-  return ListenerFlags2;
-})(ListenerFlags || {});
-
-// ../../web/event-target/lib/esm/listener-list.js
-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;
-}
-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;
-}
-function removeListener(list, callback, capture) {
-  const index = findIndexOfListener(list, callback, capture);
-  if (index !== -1) {
-    return removeListenerAt(list, index);
-  }
-  return false;
-}
-function removeListenerAt(list, index, disableCow = false) {
-  const listener = list.listeners[index];
-  setRemoved(listener);
-  if (listener.signal) {
-    listener.signal.removeEventListener("abort", listener.signalListener);
-  }
-  if (list.cow && !disableCow) {
-    list.cow = false;
-    list.listeners = list.listeners.filter((_, i) => i !== index);
-    return false;
-  }
-  list.listeners.splice(index, 1);
-  return true;
-}
-
-// ../../web/event-target/lib/esm/listener-list-map.js
-function createListenerListMap() {
-  return /* @__PURE__ */ Object.create(null);
-}
-function ensureListenerList(listenerMap, type) {
-  return listenerMap[type] ??= {
-    attrCallback: void 0,
-    attrListener: void 0,
-    cow: false,
-    listeners: []
-  };
-}
-
-// ../../web/event-target/lib/esm/event-target.js
-var EventTarget = class {
-  constructor() {
-    internalDataMap3.set(this, createListenerListMap());
-  }
-  addEventListener(type0, callback0, options0) {
-    const listenerMap = $3(this);
-    const {
-      callback,
-      capture,
-      once,
-      passive,
-      signal,
-      type
-    } = normalizeAddOptions(type0, callback0, options0);
-    if (callback == null || (signal == null ? void 0 : signal.aborted)) {
-      return;
-    }
-    const list = ensureListenerList(listenerMap, type);
-    const i = findIndexOfListener(list, callback, capture);
-    if (i !== -1) {
-      warnDuplicate(list.listeners[i], passive, once, signal);
-      return;
-    }
-    addListener(list, callback, capture, passive, once, signal);
-  }
-  removeEventListener(type0, callback0, options0) {
-    const listenerMap = $3(this);
-    const { callback, capture, type } = normalizeOptions(
-      type0,
-      callback0,
-      options0
-    );
-    const list = listenerMap[type];
-    if (callback != null && list) {
-      removeListener(list, callback, capture);
-    }
-  }
-  dispatchEvent(e) {
-    const list = $3(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 createInvalidStateError("This event has been in dispatching.");
-    }
-    eventData.dispatchFlag = true;
-    eventData.target = eventData.currentTarget = this;
-    if (!eventData.stopPropagationFlag) {
-      const { cow, listeners } = list;
-      list.cow = true;
-      for (let i = 0; i < listeners.length; ++i) {
-        const listener = listeners[i];
-        if (isRemoved(listener)) {
-          continue;
-        }
-        if (isOnce(listener) && removeListenerAt(list, i, !cow)) {
-          i -= 1;
-        }
-        eventData.inPassiveListenerFlag = isPassive(listener);
-        invokeCallback(listener, this, event);
-        eventData.inPassiveListenerFlag = false;
-        if (eventData.stopImmediatePropagationFlag) {
-          break;
-        }
-      }
-      if (!cow) {
-        list.cow = false;
-      }
-    }
-    eventData.target = null;
-    eventData.currentTarget = null;
-    eventData.stopImmediatePropagationFlag = false;
-    eventData.stopPropagationFlag = false;
-    eventData.dispatchFlag = false;
-    return !eventData.canceledFlag;
-  }
-};
-var internalDataMap3 = /* @__PURE__ */ new WeakMap();
-function $3(target, name = "this") {
-  const retv = internalDataMap3.get(target);
-  assertType(
-    retv != null,
-    "'%s' must be an object that EventTarget constructor created, but got another one: %o",
-    name,
-    target
-  );
-  return retv;
-}
-function normalizeAddOptions(type, callback, options) {
-  assertCallback(callback);
-  if (typeof options === "object" && options !== null) {
-    return {
-      type: String(type),
-      callback: callback ?? void 0,
-      capture: Boolean(options.capture),
-      passive: Boolean(options.passive),
-      once: Boolean(options.once),
-      signal: options.signal ?? void 0
-    };
-  }
-  return {
-    type: String(type),
-    callback: callback ?? void 0,
-    capture: Boolean(options),
-    passive: false,
-    once: false,
-    signal: void 0
-  };
-}
-function normalizeOptions(type, callback, options) {
-  assertCallback(callback);
-  if (typeof options === "object" && options !== null) {
-    return {
-      type: String(type),
-      callback: callback ?? void 0,
-      capture: Boolean(options.capture)
-    };
-  }
-  return {
-    type: String(type),
-    callback: callback ?? void 0,
-    capture: Boolean(options)
-  };
-}
-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]));
-}
-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");
-  }
-}
-var keys2 = Object.getOwnPropertyNames(EventTarget.prototype);
-for (let i = 0; i < keys2.length; ++i) {
-  if (keys2[i] === "constructor") {
-    continue;
-  }
-  Object.defineProperty(EventTarget.prototype, keys2[i], { enumerable: true });
-}
-if (typeof globalThis !== "undefined" && typeof globalThis.EventTarget !== "undefined") {
-  Object.setPrototypeOf(EventTarget.prototype, globalThis.EventTarget.prototype);
-}
-
-// ../../web/event-target/lib/esm/event-attribute-handler.js
-function getEventAttributeValue(target, type) {
-  var _a2;
-  const listMap = $3(target, "target");
-  return ((_a2 = listMap[type]) == null ? void 0 : _a2.attrCallback) ?? null;
-}
-function setEventAttributeValue(target, type, callback) {
-  if (callback != null && typeof callback !== "function") {
-    InvalidAttributeHandler.warn(callback);
-  }
-  if (typeof callback === "function" || typeof callback === "object" && callback !== null) {
-    upsertEventAttributeListener(target, type, callback);
-  } else {
-    removeEventAttributeListener(target, type);
-  }
-}
-function upsertEventAttributeListener(target, type, callback) {
-  const list = ensureListenerList(
-    $3(target, "target"),
-    String(type)
-  );
-  list.attrCallback = callback;
-  if (list.attrListener == null) {
-    list.attrListener = addListener(
-      list,
-      defineEventAttributeCallback(list),
-      false,
-      false,
-      false,
-      void 0
-    );
-  }
-}
-function removeEventAttributeListener(target, type) {
-  const listMap = $3(target, "target");
-  const list = listMap[String(type)];
-  if (list && list.attrListener) {
-    removeListener(list, list.attrListener.callback, false);
-    list.attrCallback = list.attrListener = void 0;
-  }
-}
-function defineEventAttributeCallback(list) {
-  return function(event) {
-    const callback = list.attrCallback;
-    if (typeof callback === "function") {
-      callback.call(this, event);
-    }
-  };
-}
-
-// ../../web/abort-controller/lib/esm/abort-signal.js
-var GjsifyAbortSignal = class extends EventTarget {
-  reason = void 0;
-  throwIfAborted() {
-    console.warn("AbortSignal.throwIfAborted");
-  }
-  get onabort() {
-    return getEventAttributeValue(this, "abort");
-  }
-  set onabort(callback) {
-    setEventAttributeValue(this, "abort", callback);
-  }
-  constructor(internal) {
-    super();
-    if (!internal) {
-      throw new TypeError("AbortSignal cannot be constructed directly");
-    }
-  }
-  static _create() {
-    return new this(true);
-  }
-  get aborted() {
-    const aborted = abortedFlags.get(this);
-    if (typeof aborted !== "boolean") {
-      throw new TypeError(
-        `Expected 'this' to be an 'AbortSignal' object, but got ${this === null ? "null" : typeof this}`
-      );
-    }
-    return aborted;
-  }
-};
-function createAbortSignal() {
-  const signal = GjsifyAbortSignal._create();
-  abortedFlags.set(signal, false);
-  return signal;
-}
-function abortSignal(signal) {
-  if (abortedFlags.get(signal) !== false) {
-    return;
-  }
-  abortedFlags.set(signal, true);
-  signal.dispatchEvent(new Event("abort"));
-}
-var abortedFlags = /* @__PURE__ */ new WeakMap();
-Object.defineProperties(GjsifyAbortSignal.prototype, {
-  aborted: { enumerable: true }
-});
-if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
-  Object.defineProperty(GjsifyAbortSignal.prototype, Symbol.toStringTag, {
-    configurable: true,
-    value: "AbortSignal"
-  });
-}
-
-// ../../web/abort-controller/lib/esm/abort-controller.js
-var GjsifyAbortController = class {
-  constructor() {
-    signals.set(this, createAbortSignal());
-  }
-  get signal() {
-    return getSignal(this);
-  }
-  abort() {
-    abortSignal(getSignal(this));
-  }
-};
-var signals = /* @__PURE__ */ new WeakMap();
-function getSignal(controller) {
-  const signal = signals.get(controller);
-  if (signal == null) {
-    throw new TypeError(
-      `Expected 'this' to be an 'AbortController' object, but got ${controller === null ? "null" : typeof controller}`
-    );
-  }
-  return signal;
-}
-Object.defineProperties(GjsifyAbortController.prototype, {
-  signal: { enumerable: true },
-  abort: { enumerable: true }
-});
-if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
-  Object.defineProperty(GjsifyAbortController.prototype, Symbol.toStringTag, {
-    configurable: true,
-    value: "AbortController"
-  });
-}
-
-// ../../web/abort-controller/lib/esm/index.js
-var AbortController = globalThis.AbortController || GjsifyAbortController;
-var AbortSignal = globalThis.AbortSignal || GjsifyAbortSignal;
-
-// ../../gjs/unit/lib/esm/index.js
-import nodeAssert from "assert";
-var _a;
-var mainloop = (_a = globalThis == null ? void 0 : globalThis.imports) == null ? void 0 : _a.mainloop;
-var countTestsOverall = 0;
-var countTestsFailed = 0;
-var countTestsIgnored = 0;
-var runtime = "";
-var RED = "\x1B[31m";
-var GREEN = "\x1B[32m";
-var BLUE = "\x1B[34m";
-var GRAY = "\x1B[90m";
-var RESET = "\x1B[39m";
-var print = globalThis.print || console.log;
-var MatcherFactory = class {
-  constructor(actualValue, positive, negated) {
-    this.actualValue = actualValue;
-    this.positive = positive;
-    if (negated) {
-      this.not = negated;
-    } else {
-      this.not = new MatcherFactory(actualValue, !positive, this);
-    }
-  }
-  triggerResult(success, msg) {
-    if (success && !this.positive || !success && this.positive) {
-      ++countTestsFailed;
-      throw new Error(msg);
-    }
-  }
-  to(callback) {
-    this.triggerResult(
-      callback(this.actualValue),
-      `      Expected callback to validate`
-    );
-  }
-  toBe(expectedValue) {
-    this.triggerResult(
-      this.actualValue === expectedValue,
-      `      Expected values to match using ===
-      Expected: ${expectedValue} (${typeof expectedValue})
-      Actual: ${this.actualValue} (${typeof this.actualValue})`
-    );
-  }
-  toEqual(expectedValue) {
-    this.triggerResult(
-      this.actualValue == expectedValue,
-      `      Expected values to match using ==
-      Expected: ${expectedValue} (${typeof expectedValue})
-      Actual: ${this.actualValue} (${typeof this.actualValue})`
-    );
-  }
-  toEqualArray(expectedValue) {
-    let success = Array.isArray(this.actualValue) && Array.isArray(expectedValue) && this.actualValue.length === expectedValue.length;
-    for (let i = 0; i < this.actualValue.length; i++) {
-      const actualVal = this.actualValue[i];
-      const expectedVal = expectedValue[i];
-      success = actualVal == expectedVal;
-      if (!success)
-        break;
-    }
-    this.triggerResult(
-      success,
-      `      Expected array items to match using ==
-      Expected: ${expectedValue} (${typeof expectedValue})
-      Actual: ${this.actualValue} (${typeof this.actualValue})`
-    );
-  }
-  toMatch(expectedValue) {
-    if (typeof this.actualValue.match !== "function") {
-      throw new Error(`You can not use toMatch on type ${typeof this.actualValue}`);
-    }
-    this.triggerResult(
-      !!this.actualValue.match(expectedValue),
-      "      Expected values to match using regular expression\n      Expression: " + expectedValue + "\n      Actual: " + this.actualValue
-    );
-  }
-  toBeDefined() {
-    this.triggerResult(
-      typeof this.actualValue !== "undefined",
-      `      Expected value to be defined`
-    );
-  }
-  toBeUndefined() {
-    this.triggerResult(
-      typeof this.actualValue === "undefined",
-      `      Expected value to be undefined`
-    );
-  }
-  toBeNull() {
-    this.triggerResult(
-      this.actualValue === null,
-      `      Expected value to be null`
-    );
-  }
-  toBeTruthy() {
-    this.triggerResult(
-      this.actualValue,
-      `      Expected value to be truthy`
-    );
-  }
-  toBeFalsy() {
-    this.triggerResult(
-      !this.actualValue,
-      `      Expected value to be falsy`
-    );
-  }
-  toContain(needle) {
-    this.triggerResult(
-      this.actualValue instanceof Array && this.actualValue.indexOf(needle) !== -1,
-      `      Expected ` + this.actualValue + ` to contain ` + needle
-    );
-  }
-  toBeLessThan(greaterValue) {
-    this.triggerResult(
-      this.actualValue < greaterValue,
-      `      Expected ` + this.actualValue + ` to be less than ` + greaterValue
-    );
-  }
-  toBeGreaterThan(smallerValue) {
-    this.triggerResult(
-      this.actualValue > smallerValue,
-      `      Expected ` + this.actualValue + ` to be greater than ` + smallerValue
-    );
-  }
-  toBeCloseTo(expectedValue, precision) {
-    const shiftHelper = Math.pow(10, precision);
-    this.triggerResult(
-      Math.round(this.actualValue * shiftHelper) / shiftHelper === Math.round(expectedValue * shiftHelper) / shiftHelper,
-      `      Expected ` + this.actualValue + ` with precision ` + precision + ` to be close to ` + expectedValue
-    );
-  }
-  toThrow(ErrorType) {
-    let errorMessage = "";
-    let didThrow = false;
-    let typeMatch = true;
-    try {
-      this.actualValue();
-      didThrow = false;
-    } catch (e) {
-      errorMessage = e.message || "";
-      didThrow = true;
-      if (ErrorType) {
-        typeMatch = e instanceof ErrorType;
-      }
-    }
-    const functionName = this.actualValue.name || typeof this.actualValue === "function" ? "[anonymous function]" : this.actualValue.toString();
-    this.triggerResult(
-      didThrow,
-      `      Expected ${functionName} to ${this.positive ? "throw" : "not throw"} an exception ${!this.positive && errorMessage ? `, but an error with the message "${errorMessage}" was thrown` : ""}`
-    );
-    if (ErrorType) {
-      this.triggerResult(
-        typeMatch,
-        `      Expected Error type '${ErrorType.name}', but the error is not an instance of it`
-      );
-    }
-  }
-};
-var describe = async function(moduleName, callback) {
-  print("\n" + moduleName);
-  await callback();
-  beforeEachCb = null;
-  afterEachCb = null;
-};
-var beforeEachCb;
-var afterEachCb;
-var it = async function(expectation, callback) {
-  try {
-    if (typeof beforeEachCb === "function") {
-      await beforeEachCb();
-    }
-    await callback();
-    if (typeof afterEachCb === "function") {
-      await afterEachCb();
-    }
-    print(`  ${GREEN}\u2714${RESET} ${GRAY}${expectation}${RESET}`);
-  } catch (e) {
-    print(`  ${RED}\u274C${RESET} ${GRAY}${expectation}${RESET}`);
-    print(`${RED}${e.message}${RESET}`);
-  }
-};
-var expect = function(actualValue) {
-  ++countTestsOverall;
-  const expecter = new MatcherFactory(actualValue, true);
-  return expecter;
-};
-var assert = function(success, message) {
-  ++countTestsOverall;
-  if (!success) {
-    ++countTestsFailed;
-  }
-  nodeAssert(success, message);
-};
-assert.strictEqual = function(actual, expected, message) {
-  ++countTestsOverall;
-  try {
-    nodeAssert.strictEqual(actual, expected, message);
-  } catch (error) {
-    ++countTestsFailed;
-    throw error;
-  }
-};
-assert.throws = function(promiseFn, ...args) {
-  ++countTestsOverall;
-  let error;
-  try {
-    promiseFn();
-  } catch (e) {
-    error = e;
-  }
-  if (!error)
-    ++countTestsFailed;
-  nodeAssert.throws(() => {
-    if (error)
-      throw error;
-  }, args[0], args[1]);
-};
-assert.deepStrictEqual = function(actual, expected, message) {
-  ++countTestsOverall;
-  try {
-    nodeAssert.deepStrictEqual(actual, expected, message);
-  } catch (error) {
-    ++countTestsFailed;
-    throw error;
-  }
-};
-var runTests = async function(namespaces) {
-  for (const subNamespace in namespaces) {
-    const namespace = namespaces[subNamespace];
-    if (typeof namespace === "function") {
-      await namespace();
-    } else if (typeof namespace === "object") {
-      await runTests(namespace);
-    }
-  }
-};
-var printResult = () => {
-  if (countTestsIgnored) {
-    print(`
-${BLUE}\u2714 ${countTestsIgnored} ignored test${countTestsIgnored > 1 ? "s" : ""}${RESET}`);
-  }
-  if (countTestsFailed) {
-    print(`
-${RED}\u274C ${countTestsFailed} of ${countTestsOverall} tests failed${RESET}`);
-  } else {
-    print(`
-${GREEN}\u2714 ${countTestsOverall} completed${RESET}`);
-  }
-};
-var getRuntime = async () => {
-  var _a2, _b, _c, _d, _e, _f;
-  if (runtime && runtime !== "Unknown") {
-    return runtime;
-  }
-  if ((_b = (_a2 = globalThis.Deno) == null ? void 0 : _a2.version) == null ? void 0 : _b.deno) {
-    return "Deno " + ((_d = (_c = globalThis.Deno) == null ? void 0 : _c.version) == null ? void 0 : _d.deno);
-  } else {
-    let process2 = globalThis.process;
-    if (!process2) {
-      try {
-        process2 = await import("process");
-      } catch (error) {
-        console.error(error);
-        console.warn(error.message);
-        runtime = "Unknown";
-      }
-    }
-    if ((_e = process2 == null ? void 0 : process2.versions) == null ? void 0 : _e.gjs) {
-      runtime = "Gjs " + process2.versions.gjs;
-    } else if ((_f = process2 == null ? void 0 : process2.versions) == null ? void 0 : _f.node) {
-      runtime = "Node.js " + process2.versions.node;
-    }
-  }
-  return runtime || "Unknown";
-};
-var printRuntime = async () => {
-  const runtime2 = await getRuntime();
-  print(`Running on ${runtime2}`);
-};
-var run = async (namespaces) => {
-  printRuntime().then(async () => {
-    return runTests(namespaces).then(() => {
-      printResult();
-      print();
-      mainloop == null ? void 0 : mainloop.quit();
-    });
-  });
-  mainloop == null ? void 0 : mainloop.run();
-};
-
-// src/index.spec.ts
-import { Stream, Readable } from "stream";
-var index_spec_default = async () => {
-  await describe("stream.Stream", async () => {
-    await it("should be able to create an instance of Stream", async () => {
-      const stream = new Stream();
-      expect(stream).toBeDefined();
-    });
-  });
-  await describe("stream.Readable", async () => {
-    await it("should be able to create an instance of Readable", async () => {
-      const readable = new Readable();
-      expect(readable).toBeDefined();
-    });
-  });
-};
-
-// src/test.ts
-run({ testSuite: index_spec_default });