1681-engine 0.0.0-stage → 0.5.9

package/dist/ecs/World.js

@@ -0,0 +1,306 @@
+import { SparseSet as k } from "./SparseSet.js";
+import { isFields as A, growColumns as x } from "./fields.js";
+let y = 0;
+const p = [];
+function O(f) {
+  const t = { id: y++, name: f };
+  return p[t.id] = t, t;
+}
+function U(f, t) {
+  const s = { id: y++, name: f, fields: t };
+  return p[s.id] = s, s;
+}
+function b(f, t, s) {
+  return { name: f, phase: t, run: s };
+}
+const E = 22, u = (1 << E) - 1, v = 2 ** 31, h = (f) => f & u;
+class z {
+  /** Current generation per slot; an id is alive when its generation matches and the slot is in use. */
+  generations = [];
+  inUse = [];
+  free = [];
+  live = 0;
+  stores = [];
+  /** Typed-array columns of the field components, by component id. */
+  cols = [];
+  systems = [];
+  pending = [];
+  /** `slots` results by the component ids asked for, rebuilt only when one of those sets changed membership. */
+  slotCache = /* @__PURE__ */ new Map();
+  /** Walks (`query`, `each`, system runs) in progress: structure changes wait until it is 0. */
+  walking = 0;
+  /** A new entity with no components. */
+  create() {
+    let t;
+    if (this.free.length)
+      t = this.free.pop();
+    else {
+      if (t = this.generations.length, t > u) throw new Error("World: too many live entities");
+      this.generations.push(0), this.inUse.push(!1);
+    }
+    return this.inUse[t] = !0, this.live++, this.generations[t] * (u + 1) + t;
+  }
+  /** A new entity with these components. */
+  spawn(...t) {
+    const s = this.create();
+    for (const [i, e] of t) this.add(s, i, e);
+    return s;
+  }
+  isAlive(t) {
+    const s = h(t);
+    return this.inUse[s] === !0 && this.generations[s] === Math.floor(t / (u + 1));
+  }
+  /** Every live entity, for tools (a debugger, a save); allocates, so not for a per-frame path. */
+  entities() {
+    const t = [];
+    for (let s = 0; s < this.inUse.length; s++) this.inUse[s] && t.push(this.generations[s] * (u + 1) + s);
+    return t;
+  }
+  /** The component types `e` holds, for tools; allocates. */
+  componentsOf(t) {
+    if (!this.isAlive(t)) return [];
+    const s = h(t), i = [];
+    return this.stores.forEach((e, n) => {
+      e?.has(s) && i.push(p[n]);
+    }), i;
+  }
+  /** Live entities. */
+  get size() {
+    return this.live;
+  }
+  /** Removes an entity and every component it had (deferred while a walk is in progress). */
+  destroy(t) {
+    if (!this.isAlive(t)) return;
+    if (this.walking > 0) {
+      this.pending.push({ kind: "destroy", e: t });
+      return;
+    }
+    const s = h(t);
+    for (const i of this.stores) i?.delete(s, h);
+    this.inUse[s] = !1, this.generations[s] = (this.generations[s] + 1) % v, this.free.push(s), this.live--;
+  }
+  add(t, s, i) {
+    if (!this.isAlive(t)) throw new Error(`World.add: entity ${t} is not alive`);
+    const e = h(t);
+    if (A(s)) {
+      const n = this.columnsOf(s, e + 1), l = i ?? {};
+      for (const r of Object.keys(s.fields)) n[r][e] = l[r] ?? 0;
+      return this.store(s).set(e, t, e), e;
+    }
+    return this.store(s).set(e, t, i), i;
+  }
+  /**
+   * The typed-array columns of a field component, indexed by slot. Fetch them per system run: adding entities may
+   * grow them into new arrays.
+   */
+  columns(t) {
+    return this.columnsOf(t, this.generations.length);
+  }
+  get(t, s) {
+    if (this.isAlive(t))
+      return this.stores[s.id]?.get(h(t));
+  }
+  /** The component, or an error naming what is missing: for code that knows the entity has it. */
+  require(t, s) {
+    const i = this.stores[s.id];
+    if (!this.isAlive(t) || !i?.has(h(t))) throw new Error(`World.require: entity ${t} has no ${s.name}`);
+    return i.get(h(t));
+  }
+  has(t, s) {
+    return this.isAlive(t) && (this.stores[s.id]?.has(h(t)) ?? !1);
+  }
+  /** Takes one component off an entity (deferred while a walk is in progress). */
+  remove(t, s) {
+    if (this.isAlive(t)) {
+      if (this.walking > 0) {
+        this.pending.push({ kind: "remove", e: t, type: s });
+        return;
+      }
+      this.stores[s.id]?.delete(h(t), h);
+    }
+  }
+  /** How many entities hold `type`. */
+  count(t) {
+    return this.stores[t.id]?.size ?? 0;
+  }
+  /**
+   * Calls `fn(entity, ...components)` for every live entity holding all of `types`. Allocates nothing per entity:
+   * the form for systems that walk thousands of bodies every step.
+   */
+  each(...t) {
+    const s = t[t.length - 1], i = t.slice(0, -1), e = this.setsFor(i);
+    if (!e) return;
+    const n = m(e), l = n.entities.length;
+    this.walking++;
+    try {
+      if (e.length === 1)
+        for (let r = l - 1; r >= 0; r--) s(n.entities[r], n.values[r]);
+      else if (e.length === 2) {
+        const [r, o] = e;
+        for (let a = l - 1; a >= 0; a--) {
+          const d = n.entities[a], c = h(d);
+          !r.has(c) || !o.has(c) || s(d, r.get(c), o.get(c));
+        }
+      } else {
+        const r = new Array(e.length);
+        for (let o = l - 1; o >= 0; o--) {
+          const a = n.entities[o], d = h(a);
+          let c = !0;
+          for (let g = 0; g < e.length; g++) {
+            const w = e[g];
+            if (!w.has(d)) {
+              c = !1;
+              break;
+            }
+            r[g] = w.get(d);
+          }
+          c && s(a, ...r);
+        }
+      }
+    } finally {
+      this.endWalk();
+    }
+  }
+  /**
+   * The slot index of every entity holding all of `types`, as a typed array: the fastest walk there is, made for
+   * field components (`defineFields`), whose columns are indexed by slot.
+   *
+   * ```ts
+   * const p = world.columns(Position), v = world.columns(Velocity);
+   * const slots = world.slots(Position, Velocity);
+   * for (let k = 0; k < slots.length; k++) { const i = slots[k]!; p.x[i]! += v.x[i]! * dt; }
+   * ```
+   *
+   * The result is cached and rebuilt only when an entity joins or leaves one of those components, so asking every
+   * step is cheap. It is a view the world owns: read it, don't keep it past the step, and fetch it again after
+   * adding or removing components.
+   */
+  slots(...t) {
+    const s = t.map((o) => o.id).join(","), i = this.setsFor(t);
+    if (!i) return S;
+    let e = this.slotCache.get(s);
+    if (e && e.versions.every((o, a) => o === i[a].version)) return e.view;
+    const n = m(i), l = e && e.slots.length >= n.size ? e.slots : new Int32Array(Math.max(16, n.size));
+    let r = 0;
+    for (let o = 0; o < n.entities.length; o++) {
+      const a = h(n.entities[o]);
+      let d = !0;
+      for (const c of i)
+        if (c !== n && !c.has(a)) {
+          d = !1;
+          break;
+        }
+      d && (l[r++] = a);
+    }
+    return e = { versions: i.map((o) => o.version), slots: l, view: l.subarray(0, r) }, this.slotCache.set(s, e), e.view;
+  }
+  /**
+   * Every live entity holding all of `types`, with those components in the same order. Yields a fresh row per
+   * entity: convenient, but `each` is the form for hot loops.
+   */
+  *query(...t) {
+    const s = this.setsFor(t);
+    if (!s) return;
+    const i = m(s);
+    this.walking++;
+    try {
+      for (let e = i.entities.length - 1; e >= 0; e--) {
+        const n = i.entities[e], l = h(n), r = [n];
+        let o = !0;
+        for (const a of s) {
+          if (!a.has(l)) {
+            o = !1;
+            break;
+          }
+          r.push(a.get(l));
+        }
+        o && (yield r);
+      }
+    } finally {
+      this.endWalk();
+    }
+  }
+  /** The first entity matching the query, or undefined: for singletons (the player, the camera target). */
+  first(...t) {
+    for (const s of this.query(...t)) return s;
+  }
+  addSystem(t) {
+    if (this.systems.some((s) => s.name === t.name)) throw new Error(`World.addSystem: a system named "${t.name}" is already added`);
+    return this.systems.push(t), this;
+  }
+  removeSystem(t) {
+    const s = this.systems.findIndex((e) => e.name === t);
+    if (s < 0) return;
+    const [i] = this.systems.splice(s, 1);
+    i.dispose?.();
+  }
+  /** Runs every system of `phase` in the order added. A system that throws is reported and the rest still run. */
+  run(t, s, i) {
+    const e = { dt: s.dt, now: s.now, alpha: s.alpha, world: this };
+    this.walking++;
+    try {
+      for (const n of this.systems)
+        if (n.phase === t)
+          try {
+            n.run(e);
+          } catch (l) {
+            if (i) i(n, l);
+            else throw l;
+          }
+    } finally {
+      this.endWalk();
+    }
+  }
+  /** Every entity, component and system gone. */
+  clear() {
+    for (const t of this.systems.splice(0)) t.dispose?.();
+    for (const t of this.stores) t?.clear();
+    this.generations = this.generations.map((t) => (t + 1) % v), this.inUse.fill(!1), this.free.length = 0;
+    for (let t = this.generations.length - 1; t >= 0; t--) this.free.push(t);
+    this.live = 0, this.pending.length = 0, this.slotCache.clear();
+  }
+  columnsOf(t, s) {
+    let i = this.cols[t.id];
+    const e = i ? Object.values(i)[0]?.length ?? 0 : 0;
+    if (!i || e < s) {
+      let n = Math.max(64, e);
+      for (; n < s; ) n *= 2;
+      i = x(t.fields, n, i), this.cols[t.id] = i;
+    }
+    return i;
+  }
+  store(t) {
+    let s = this.stores[t.id];
+    return s || (s = new k(), this.stores[t.id] = s), s;
+  }
+  /** The stores for `types`, or null when one has never been used (so nothing can match). */
+  setsFor(t) {
+    if (t.length === 0) return null;
+    const s = [];
+    for (const i of t) {
+      const e = this.stores[i.id];
+      if (!e || e.size === 0) return null;
+      s.push(e);
+    }
+    return s;
+  }
+  endWalk() {
+    if (this.walking--, this.walking > 0 || this.pending.length === 0) return;
+    const t = this.pending.splice(0);
+    for (const s of t)
+      s.kind === "destroy" ? this.destroy(s.e) : this.remove(s.e, s.type);
+  }
+}
+const S = new Int32Array(0);
+function m(f) {
+  let t = f[0];
+  for (const s of f) s.size < t.size && (t = s);
+  return t;
+}
+export {
+  z as World,
+  O as defineComponent,
+  U as defineFields,
+  h as entityIndex,
+  b as system
+};

package/dist/ecs/fields.js

@@ -0,0 +1,25 @@
+const c = {
+  f32: Float32Array,
+  f64: Float64Array,
+  i8: Int8Array,
+  i16: Int16Array,
+  i32: Int32Array,
+  u8: Uint8Array,
+  u16: Uint16Array,
+  u32: Uint32Array
+};
+function u(r) {
+  return r.fields !== void 0;
+}
+function f(r, e, a) {
+  const n = {};
+  for (const [t, s] of Object.entries(r)) {
+    const o = new c[s](e), i = a?.[t];
+    i && o.set(i), n[t] = o;
+  }
+  return n;
+}
+export {
+  f as growColumns,
+  u as isFields
+};

package/dist/engine/Engine.js

@@ -0,0 +1,106 @@
+import { TextureSource as d, Application as p } from "pixi.js";
+import { Stage as o } from "../core/Stage.js";
+import { TextureRegistry as l } from "../core/TextureRegistry.js";
+import { patchPixi as m } from "../core/pixiPatches.js";
+import { EventBus as f } from "../events/EventBus.js";
+import { followReducedMotion as g } from "../platform/reducedMotion.js";
+import { FixedLoop as w } from "./FixedLoop.js";
+import { HiddenPause as k } from "./HiddenPause.js";
+import { SceneManager as v } from "./SceneManager.js";
+class x extends o {
+  constructor(e, t, r) {
+    super(e, t), this.tick = r;
+  }
+  tick;
+  update(e, t) {
+    this.tick(e, t);
+  }
+}
+class u {
+  constructor(e, t, r) {
+    this.app = e, this.loop = new w(r.hz === void 0 ? {} : { hz: r.hz }), this.stage = new x(e, t, (i, n) => this.tick(i, n));
+    const s = this.stage.cameras.main;
+    s.setZoom(r.zoom ?? 1), s.defaultZoom = s.zoom, s.roundPixels = r.pixelPerfect === !0, s.resolution = e.renderer.resolution, this.scenes = new v(this), o.onCaught = (i, n) => this.events.emit("error", { where: i, error: n }), e.ticker.add(this.onTick), r.pauseWhenHidden === !0 && this.unwatch.push(this.hiddenPause.watch()), r.followReducedMotion === !0 && this.unwatch.push(g());
+  }
+  app;
+  stage;
+  loop;
+  scenes;
+  events = new f();
+  running = !0;
+  destroyed = !1;
+  /** Pauses through the loop's own switch, so a hidden tab never counts as the game's own pause (`forget`). */
+  hiddenPause = this.makeHiddenPause();
+  unwatch = [];
+  onTick = (e) => this.stage.frame(e.deltaMS);
+  static async create(e) {
+    const t = e.pixelPerfect === !0;
+    d.defaultOptions.scaleMode = t ? "nearest" : "linear";
+    const r = t ? 1 : e.resolution ?? Math.min(2, typeof devicePixelRatio == "number" ? devicePixelRatio : 1);
+    m();
+    const s = new p(), i = e.width === void 0 && e.height === void 0;
+    return await s.init({
+      ...i ? { resizeTo: e.parent } : { width: e.width ?? 800, height: e.height ?? 600 },
+      background: e.background ?? "#000000",
+      antialias: !t,
+      resolution: r,
+      autoDensity: !0,
+      preference: e.preference ?? "webgl"
+    }), e.parent.appendChild(s.canvas), new u(s, e.textures ?? new l(), e);
+  }
+  /** The scene that updates now, if any. */
+  get scene() {
+    return this.scenes.current;
+  }
+  /** Stops simulating and drawing; the canvas keeps its last frame. */
+  pause() {
+    this.hiddenPause.forget(), this.pauseLoop();
+  }
+  resume() {
+    this.hiddenPause.forget(), this.resumeLoop();
+  }
+  makeHiddenPause() {
+    const e = this;
+    return new k({
+      get paused() {
+        return !e.running;
+      },
+      pause: () => e.pauseLoop(),
+      resume: () => e.resumeLoop()
+    });
+  }
+  pauseLoop() {
+    this.running && (this.running = !1, this.app.ticker.stop());
+  }
+  resumeLoop() {
+    this.running || this.destroyed || (this.running = !0, this.loop.reset(), this.app.ticker.start());
+  }
+  get paused() {
+    return !this.running;
+  }
+  /** Reports a fault to `events.error` (and the console when nobody listens). */
+  reportError(e, t) {
+    this.events.listenerCount("error") === 0 && console.error(`[engine] ${e}`, t), this.events.emit("error", { where: e, error: t });
+  }
+  /** Leaves every scene, removes the canvas and frees the renderer. */
+  async destroy() {
+    if (!this.destroyed) {
+      this.destroyed = !0;
+      for (const e of this.unwatch.splice(0)) e();
+      await this.scenes.clear(), this.app.ticker.remove(this.onTick), o.onCaught && (o.onCaught = null), this.stage.destroy(), this.events.clear(), this.app.destroy({ removeView: !0 }, { children: !0 });
+    }
+  }
+  tick(e, t) {
+    const r = this.scenes.current;
+    if (r) {
+      const s = (h, c) => this.reportError(`system ${h.name}`, c), i = this.loop.stepSeconds, n = this.loop.advance(t, () => {
+        r.world.run("fixed", { dt: i, now: e, alpha: 0 }, s), r.fixedUpdate(i);
+      }), a = t / 1e3;
+      r.world.run("frame", { dt: a, now: e, alpha: n }, s), r.update(a, n);
+    }
+    this.events.emit("frame", { now: e, dt: t / 1e3 });
+  }
+}
+export {
+  u as Engine
+};

package/dist/engine/FixedLoop.js

@@ -0,0 +1,36 @@
+class i {
+  stepMs;
+  stepSeconds;
+  maxSteps;
+  carry = 0;
+  /** Steps taken since the loop started. */
+  tick = 0;
+  constructor(s = {}) {
+    const t = s.hz ?? 60;
+    if (!(t > 0)) throw new Error(`FixedLoop: hz must be positive, got ${t}`);
+    this.stepMs = 1e3 / t, this.stepSeconds = 1 / t, this.maxSteps = Math.max(1, s.maxStepsPerFrame ?? 8);
+  }
+  /**
+   * Feeds one frame of `deltaMs` and runs `step` as many times as it owes. Returns the share of a step left over
+   * (0–1), for interpolating what is drawn between the last two steps.
+   */
+  advance(s, t) {
+    s > 0 && Number.isFinite(s) && (this.carry += s);
+    let e = 0;
+    for (; this.carry >= this.stepMs; ) {
+      if (e === this.maxSteps) {
+        this.carry %= this.stepMs;
+        break;
+      }
+      this.carry -= this.stepMs, e++, t(this.tick++);
+    }
+    return this.carry / this.stepMs;
+  }
+  /** Forgets any debt, e.g. after a scene change or a long load. */
+  reset() {
+    this.carry = 0;
+  }
+}
+export {
+  i as FixedLoop
+};

package/dist/engine/HiddenPause.js

@@ -0,0 +1,27 @@
+class s {
+  constructor(e) {
+    this.target = e;
+  }
+  target;
+  pausedByUs = !1;
+  hidden() {
+    this.target.paused || (this.target.pause(), this.pausedByUs = !0);
+  }
+  shown() {
+    this.pausedByUs && (this.pausedByUs = !1, this.target.paused && this.target.resume());
+  }
+  /** The game paused or resumed it itself: whatever happens next is its choice, not ours to undo. */
+  forget() {
+    this.pausedByUs = !1;
+  }
+  /** Listens to `visibilitychange` on `doc`; returns the unsubscribe. A no-op without a document. */
+  watch(e = typeof document > "u" ? null : document) {
+    if (!e) return () => {
+    };
+    const t = () => e.visibilityState === "hidden" ? this.hidden() : this.shown();
+    return e.addEventListener("visibilitychange", t), e.visibilityState === "hidden" && this.hidden(), () => e.removeEventListener("visibilitychange", t);
+  }
+}
+export {
+  s as HiddenPause
+};

package/dist/engine/Scene.js

@@ -0,0 +1,78 @@
+import { Container as o } from "pixi.js";
+import { World as s } from "../ecs/World.js";
+class u {
+  world = new s();
+  /** Everything the scene draws in the world goes under this (the camera moves it). */
+  root = new o({ sortableChildren: !0 });
+  /** Everything the scene draws on the screen (HUD) goes under this. */
+  hud = new o();
+  bound = null;
+  timers = /* @__PURE__ */ new Set();
+  inputs = [];
+  /** The engine running this scene; only valid between `enter` and `exit`. */
+  get engine() {
+    if (!this.bound) throw new Error(`${this.constructor.name}: not running in an engine`);
+    return this.bound;
+  }
+  /** Called once when the scene becomes active. May be async: the scene starts updating when it resolves. */
+  onEnter() {
+  }
+  /** Called when the scene is removed. The world and containers are cleared after it returns. */
+  onExit() {
+  }
+  /** Called when another scene is pushed over this one. */
+  onPause() {
+  }
+  /** Called when the scene over this one is popped. */
+  onResume() {
+  }
+  /** Once per simulation step, `dt` in seconds. */
+  fixedUpdate(t) {
+  }
+  /** Once per rendered frame, `dt` in seconds; `alpha` is the share of a step since the last one (0–1). */
+  update(t, e) {
+  }
+  /**
+   * Calls `fn` after `ms` on the stage's clock, unless the scene has left by then: its timers are cancelled when it
+   * exits. Only valid while the scene is running (between `enter` and `exit`).
+   */
+  delay(t, e) {
+    const n = this.engine.stage.time.delayedCall(t, () => {
+      this.timers.delete(r), e();
+    }), r = {
+      remove: () => {
+        this.timers.delete(r), n.remove();
+      }
+    };
+    return this.timers.add(r), r;
+  }
+  /**
+   * Registers input the scene reads (an `Actions`) and returns it, so a field can be written in one line:
+   * `private readonly input = this.useInput(new Actions(keyboard, bindings));`. When a scene pushed over this one
+   * pops, every registered input is flushed before `onResume`, so a key pressed in the menu is not a press here.
+   */
+  useInput(t) {
+    return this.inputs.push(t), t;
+  }
+  /** @internal Called by the scene manager before `onResume`. */
+  flushInput() {
+    for (const t of this.inputs) t.flush();
+  }
+  /** @internal Engine-side wiring; games call `engine.scenes`. */
+  attach(t) {
+    this.bound = t, t.stage.world.addChild(this.root), t.stage.screen.addChild(this.hud);
+  }
+  /** @internal Clears what the scene made but keeps its containers, so the same scene may be entered again. */
+  detach() {
+    for (const t of [...this.timers]) t.remove();
+    this.world.clear();
+    for (const t of [this.root, this.hud]) {
+      for (const e of t.removeChildren()) e.destroy({ children: !0 });
+      t.removeFromParent();
+    }
+    this.bound = null;
+  }
+}
+export {
+  u as Scene
+};

package/dist/engine/SceneManager.js

@@ -0,0 +1,72 @@
+class i {
+  constructor(t) {
+    this.engine = t;
+  }
+  engine;
+  stack = [];
+  queue = Promise.resolve();
+  /** True while an async `onEnter` is running: nothing updates until it is done. */
+  entering = !1;
+  /** The scene that updates, if any. */
+  get current() {
+    return this.entering ? void 0 : this.stack[this.stack.length - 1];
+  }
+  /** Every scene on the stack, bottom first. */
+  get all() {
+    return this.stack;
+  }
+  /** Removes every scene and enters `scene`. */
+  replace(t) {
+    return this.enqueue(async () => {
+      for (; this.stack.length; ) this.exitTop();
+      this.engine.stage.cameras.main.reset(), await this.enter(t);
+    });
+  }
+  /** Pauses the current scene and enters `scene` over it. */
+  push(t) {
+    return this.enqueue(async () => {
+      this.stack[this.stack.length - 1]?.onPause(), await this.enter(t);
+    });
+  }
+  /** Leaves the current scene and resumes the one under it. */
+  pop() {
+    return this.enqueue(async () => {
+      if (!this.stack.length) return;
+      this.exitTop();
+      const t = this.stack[this.stack.length - 1];
+      t && (t.flushInput(), t.onResume());
+    });
+  }
+  /** Leaves every scene (the engine is shutting down). */
+  clear() {
+    return this.enqueue(async () => {
+      for (; this.stack.length; ) this.exitTop();
+    });
+  }
+  async enter(t) {
+    if (this.stack.includes(t)) throw new Error(`${t.constructor.name} is already on the scene stack`);
+    t.attach(this.engine), this.stack.push(t), this.entering = !0;
+    try {
+      await t.onEnter();
+    } finally {
+      this.entering = !1;
+    }
+    this.engine.loop.reset();
+  }
+  exitTop() {
+    const t = this.stack.pop();
+    if (t)
+      try {
+        t.onExit();
+      } finally {
+        t.detach();
+      }
+  }
+  enqueue(t) {
+    const e = this.queue.then(t);
+    return this.queue = e.catch((s) => this.engine.reportError("scene", s)), e;
+  }
+}
+export {
+  i as SceneManager
+};

package/dist/events/EventBus.js

@@ -0,0 +1,41 @@
+class o {
+  constructor(e = (t, s) => console.error(`[events] ${String(t)} listener failed`, s)) {
+    this.onError = e;
+  }
+  onError;
+  listeners = /* @__PURE__ */ new Map();
+  /** Subscribes to `type`; returns the unsubscribe function. */
+  on(e, t) {
+    return this.listeners.set(e, [...this.listeners.get(e) ?? [], t]), () => this.off(e, t);
+  }
+  /** Subscribes for the next `type` only. */
+  once(e, t) {
+    const s = this.on(e, (r) => {
+      s(), t(r);
+    });
+    return s;
+  }
+  off(e, t) {
+    const s = this.listeners.get(e);
+    if (!s) return;
+    const r = s.filter((n) => n !== t);
+    r.length ? this.listeners.set(e, r) : this.listeners.delete(e);
+  }
+  emit(e, t) {
+    for (const s of this.listeners.get(e) ?? [])
+      try {
+        s(t);
+      } catch (r) {
+        this.onError(e, r);
+      }
+  }
+  listenerCount(e) {
+    return this.listeners.get(e)?.length ?? 0;
+  }
+  clear() {
+    this.listeners.clear();
+  }
+}
+export {
+  o as EventBus
+};