1681-engine 0.0.0-stage → 0.5.8

package/dist/engine/Scene.js

@@ -0,0 +1,79 @@
+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
+};
+//# sourceMappingURL=Scene.js.map

package/dist/engine/Scene.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scene.js","sources":["../../src/engine/Scene.ts"],"sourcesContent":["import { Container } from 'pixi.js';\nimport { World } from '../ecs/World';\nimport type { Engine } from './Engine';\n\n/** Input a scene can be told to forget its pending presses on (an `Actions`). */\nexport interface FlushableInput {\n  flush(): void;\n}\n\n/** A timer `Scene.delay` started; `remove` cancels it. */\nexport interface SceneTimer {\n  remove(): void;\n}\n\n/**\n * One screen of the game: a title, a level, a pause menu. A scene owns a `World` of entities and systems and a\n * `root` container in the engine's world layer; both are cleared when it leaves, so nothing it made outlives it.\n *\n * Override the hooks you need. `fixedUpdate` runs once per simulation step, `update` once per rendered frame, both\n * after the world's own systems of that phase.\n *\n * Two things a scene should hand the engine so they end with it: timers (`delay`, not `stage.time.delayedCall`, whose\n * timers belong to the stage and fire after the scene has gone) and its input (`useInput`, flushed when a scene pushed\n * over this one pops, so presses made in a pause menu are not read again by the level under it).\n *\n * Names taken: `world`, `root` and `hud` are the scene's own fields, so a subclass cannot declare a field of those\n * names for something else (a HUD class of the game's is best kept as `display`, `overlay`, …).\n */\nexport abstract class Scene {\n  readonly world = new World();\n  /** Everything the scene draws in the world goes under this (the camera moves it). */\n  readonly root = new Container({ sortableChildren: true });\n  /** Everything the scene draws on the screen (HUD) goes under this. */\n  readonly hud = new Container();\n  private bound: Engine | null = null;\n  private readonly timers = new Set<SceneTimer>();\n  private readonly inputs: FlushableInput[] = [];\n\n  /** The engine running this scene; only valid between `enter` and `exit`. */\n  get engine(): Engine {\n    if (!this.bound) throw new Error(`${this.constructor.name}: not running in an engine`);\n    return this.bound;\n  }\n\n  /** Called once when the scene becomes active. May be async: the scene starts updating when it resolves. */\n  onEnter(): void | Promise<void> {}\n  /** Called when the scene is removed. The world and containers are cleared after it returns. */\n  onExit(): void {}\n  /** Called when another scene is pushed over this one. */\n  onPause(): void {}\n  /** Called when the scene over this one is popped. */\n  onResume(): void {}\n  /** Once per simulation step, `dt` in seconds. */\n  fixedUpdate(_dt: number): void {}\n  /** Once per rendered frame, `dt` in seconds; `alpha` is the share of a step since the last one (0–1). */\n  update(_dt: number, _alpha: number): void {}\n\n  /**\n   * Calls `fn` after `ms` on the stage's clock, unless the scene has left by then: its timers are cancelled when it\n   * exits. Only valid while the scene is running (between `enter` and `exit`).\n   */\n  delay(ms: number, fn: () => void): SceneTimer {\n    const handle = this.engine.stage.time.delayedCall(ms, () => {\n      this.timers.delete(timer);\n      fn();\n    });\n    const timer: SceneTimer = {\n      remove: () => {\n        this.timers.delete(timer);\n        handle.remove();\n      },\n    };\n    this.timers.add(timer);\n    return timer;\n  }\n\n  /**\n   * Registers input the scene reads (an `Actions`) and returns it, so a field can be written in one line:\n   * `private readonly input = this.useInput(new Actions(keyboard, bindings));`. When a scene pushed over this one\n   * pops, every registered input is flushed before `onResume`, so a key pressed in the menu is not a press here.\n   */\n  useInput<T extends FlushableInput>(input: T): T {\n    this.inputs.push(input);\n    return input;\n  }\n\n  /** @internal Called by the scene manager before `onResume`. */\n  flushInput(): void {\n    for (const i of this.inputs) i.flush();\n  }\n\n  /** @internal Engine-side wiring; games call `engine.scenes`. */\n  attach(engine: Engine): void {\n    this.bound = engine;\n    engine.stage.world.addChild(this.root);\n    engine.stage.screen.addChild(this.hud);\n  }\n\n  /** @internal Clears what the scene made but keeps its containers, so the same scene may be entered again. */\n  detach(): void {\n    for (const t of [...this.timers]) t.remove();\n    this.world.clear();\n    for (const c of [this.root, this.hud]) {\n      for (const child of c.removeChildren()) child.destroy({ children: true });\n      c.removeFromParent();\n    }\n    this.bound = null;\n  }\n}\n"],"names":["Scene","World","Container","_dt","_alpha","ms","fn","handle","timer","input","i","engine","c","child"],"mappings":";;AA4BO,MAAeA,EAAM;AAAA,EACjB,QAAQ,IAAIC,EAAA;AAAA;AAAA,EAEZ,OAAO,IAAIC,EAAU,EAAE,kBAAkB,IAAM;AAAA;AAAA,EAE/C,MAAM,IAAIA,EAAA;AAAA,EACX,QAAuB;AAAA,EACd,6BAAa,IAAA;AAAA,EACb,SAA2B,CAAA;AAAA;AAAA,EAG5C,IAAI,SAAiB;AACnB,QAAI,CAAC,KAAK,MAAO,OAAM,IAAI,MAAM,GAAG,KAAK,YAAY,IAAI,4BAA4B;AACrF,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,UAAgC;AAAA,EAAC;AAAA;AAAA,EAEjC,SAAe;AAAA,EAAC;AAAA;AAAA,EAEhB,UAAgB;AAAA,EAAC;AAAA;AAAA,EAEjB,WAAiB;AAAA,EAAC;AAAA;AAAA,EAElB,YAAYC,GAAmB;AAAA,EAAC;AAAA;AAAA,EAEhC,OAAOA,GAAaC,GAAsB;AAAA,EAAC;AAAA;AAAA;AAAA;AAAA;AAAA,EAM3C,MAAMC,GAAYC,GAA4B;AAC5C,UAAMC,IAAS,KAAK,OAAO,MAAM,KAAK,YAAYF,GAAI,MAAM;AAC1D,WAAK,OAAO,OAAOG,CAAK,GACxBF,EAAA;AAAA,IACF,CAAC,GACKE,IAAoB;AAAA,MACxB,QAAQ,MAAM;AACZ,aAAK,OAAO,OAAOA,CAAK,GACxBD,EAAO,OAAA;AAAA,MACT;AAAA,IAAA;AAEF,gBAAK,OAAO,IAAIC,CAAK,GACdA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAmCC,GAAa;AAC9C,gBAAK,OAAO,KAAKA,CAAK,GACfA;AAAA,EACT;AAAA;AAAA,EAGA,aAAmB;AACjB,eAAWC,KAAK,KAAK,OAAQ,CAAAA,EAAE,MAAA;AAAA,EACjC;AAAA;AAAA,EAGA,OAAOC,GAAsB;AAC3B,SAAK,QAAQA,GACbA,EAAO,MAAM,MAAM,SAAS,KAAK,IAAI,GACrCA,EAAO,MAAM,OAAO,SAAS,KAAK,GAAG;AAAA,EACvC;AAAA;AAAA,EAGA,SAAe;AACb,eAAW,KAAK,CAAC,GAAG,KAAK,MAAM,KAAK,OAAA;AACpC,SAAK,MAAM,MAAA;AACX,eAAWC,KAAK,CAAC,KAAK,MAAM,KAAK,GAAG,GAAG;AACrC,iBAAWC,KAASD,EAAE,eAAA,KAAwB,QAAQ,EAAE,UAAU,IAAM;AACxE,MAAAA,EAAE,iBAAA;AAAA,IACJ;AACA,SAAK,QAAQ;AAAA,EACf;AACF;"}

package/dist/engine/SceneManager.js

@@ -0,0 +1,73 @@
+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
+};
+//# sourceMappingURL=SceneManager.js.map

package/dist/engine/SceneManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneManager.js","sources":["../../src/engine/SceneManager.ts"],"sourcesContent":["import type { Engine } from './Engine';\nimport type { Scene } from './Scene';\n\n/**\n * A stack of scenes. Only the top one updates; the ones under it are paused but still drawn (a pause menu over the\n * level). Changes are queued and applied one at a time, so a scene that replaces itself from inside its own update,\n * or an async `onEnter` still loading, never leaves two scenes half entered.\n *\n * The camera is the engine's, not a scene's: `replace` resets it (`Camera.reset`: no target, no bounds, the default\n * zoom) after the old scenes leave and before the new one enters, so a level's follow and bounds never hold over a\n * title screen. `push` and `pop` leave it as it is: the scene under a pause menu keeps its view. `pop` flushes the\n * resumed scene's input (`Scene.useInput`) before its `onResume`.\n */\nexport class SceneManager {\n  private readonly stack: Scene[] = [];\n  private queue: Promise<void> = Promise.resolve();\n  /** True while an async `onEnter` is running: nothing updates until it is done. */\n  private entering = false;\n\n  constructor(private readonly engine: Engine) {}\n\n  /** The scene that updates, if any. */\n  get current(): Scene | undefined {\n    return this.entering ? undefined : this.stack[this.stack.length - 1];\n  }\n\n  /** Every scene on the stack, bottom first. */\n  get all(): readonly Scene[] {\n    return this.stack;\n  }\n\n  /** Removes every scene and enters `scene`. */\n  replace(scene: Scene): Promise<void> {\n    return this.enqueue(async () => {\n      while (this.stack.length) this.exitTop();\n      this.engine.stage.cameras.main.reset();\n      await this.enter(scene);\n    });\n  }\n\n  /** Pauses the current scene and enters `scene` over it. */\n  push(scene: Scene): Promise<void> {\n    return this.enqueue(async () => {\n      this.stack[this.stack.length - 1]?.onPause();\n      await this.enter(scene);\n    });\n  }\n\n  /** Leaves the current scene and resumes the one under it. */\n  pop(): Promise<void> {\n    return this.enqueue(async () => {\n      if (!this.stack.length) return;\n      this.exitTop();\n      const under = this.stack[this.stack.length - 1];\n      if (!under) return;\n      under.flushInput();\n      under.onResume();\n    });\n  }\n\n  /** Leaves every scene (the engine is shutting down). */\n  clear(): Promise<void> {\n    return this.enqueue(async () => {\n      while (this.stack.length) this.exitTop();\n    });\n  }\n\n  private async enter(scene: Scene): Promise<void> {\n    if (this.stack.includes(scene)) throw new Error(`${scene.constructor.name} is already on the scene stack`);\n    scene.attach(this.engine);\n    this.stack.push(scene);\n    this.entering = true;\n    try {\n      await scene.onEnter();\n    } finally {\n      this.entering = false;\n    }\n    this.engine.loop.reset();\n  }\n\n  private exitTop(): void {\n    const scene = this.stack.pop();\n    if (!scene) return;\n    try {\n      scene.onExit();\n    } finally {\n      scene.detach();\n    }\n  }\n\n  private enqueue(job: () => Promise<void>): Promise<void> {\n    const run = this.queue.then(job);\n    // a failed change must not wedge every change after it\n    this.queue = run.catch((err) => this.engine.reportError('scene', err));\n    return run;\n  }\n}\n"],"names":["SceneManager","engine","scene","under","job","run","err"],"mappings":"AAaO,MAAMA,EAAa;AAAA,EAMxB,YAA6BC,GAAgB;AAAhB,SAAA,SAAAA;AAAA,EAAiB;AAAA,EAAjB;AAAA,EALZ,QAAiB,CAAA;AAAA,EAC1B,QAAuB,QAAQ,QAAA;AAAA;AAAA,EAE/B,WAAW;AAAA;AAAA,EAKnB,IAAI,UAA6B;AAC/B,WAAO,KAAK,WAAW,SAAY,KAAK,MAAM,KAAK,MAAM,SAAS,CAAC;AAAA,EACrE;AAAA;AAAA,EAGA,IAAI,MAAwB;AAC1B,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,QAAQC,GAA6B;AACnC,WAAO,KAAK,QAAQ,YAAY;AAC9B,aAAO,KAAK,MAAM,SAAQ,MAAK,QAAA;AAC/B,WAAK,OAAO,MAAM,QAAQ,KAAK,MAAA,GAC/B,MAAM,KAAK,MAAMA,CAAK;AAAA,IACxB,CAAC;AAAA,EACH;AAAA;AAAA,EAGA,KAAKA,GAA6B;AAChC,WAAO,KAAK,QAAQ,YAAY;AAC9B,WAAK,MAAM,KAAK,MAAM,SAAS,CAAC,GAAG,QAAA,GACnC,MAAM,KAAK,MAAMA,CAAK;AAAA,IACxB,CAAC;AAAA,EACH;AAAA;AAAA,EAGA,MAAqB;AACnB,WAAO,KAAK,QAAQ,YAAY;AAC9B,UAAI,CAAC,KAAK,MAAM,OAAQ;AACxB,WAAK,QAAA;AACL,YAAMC,IAAQ,KAAK,MAAM,KAAK,MAAM,SAAS,CAAC;AAC9C,MAAKA,MACLA,EAAM,WAAA,GACNA,EAAM,SAAA;AAAA,IACR,CAAC;AAAA,EACH;AAAA;AAAA,EAGA,QAAuB;AACrB,WAAO,KAAK,QAAQ,YAAY;AAC9B,aAAO,KAAK,MAAM,SAAQ,MAAK,QAAA;AAAA,IACjC,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,MAAMD,GAA6B;AAC/C,QAAI,KAAK,MAAM,SAASA,CAAK,EAAG,OAAM,IAAI,MAAM,GAAGA,EAAM,YAAY,IAAI,gCAAgC;AACzG,IAAAA,EAAM,OAAO,KAAK,MAAM,GACxB,KAAK,MAAM,KAAKA,CAAK,GACrB,KAAK,WAAW;AAChB,QAAI;AACF,YAAMA,EAAM,QAAA;AAAA,IACd,UAAA;AACE,WAAK,WAAW;AAAA,IAClB;AACA,SAAK,OAAO,KAAK,MAAA;AAAA,EACnB;AAAA,EAEQ,UAAgB;AACtB,UAAMA,IAAQ,KAAK,MAAM,IAAA;AACzB,QAAKA;AACL,UAAI;AACF,QAAAA,EAAM,OAAA;AAAA,MACR,UAAA;AACE,QAAAA,EAAM,OAAA;AAAA,MACR;AAAA,EACF;AAAA,EAEQ,QAAQE,GAAyC;AACvD,UAAMC,IAAM,KAAK,MAAM,KAAKD,CAAG;AAE/B,gBAAK,QAAQC,EAAI,MAAM,CAACC,MAAQ,KAAK,OAAO,YAAY,SAASA,CAAG,CAAC,GAC9DD;AAAA,EACT;AACF;"}

package/dist/events/EventBus.js

@@ -0,0 +1,42 @@
+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
+};
+//# sourceMappingURL=EventBus.js.map

package/dist/events/EventBus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventBus.js","sources":["../../src/events/EventBus.ts"],"sourcesContent":["/**\n * Typed observer: listeners subscribe per event name and run in subscription order.\n * `Events` maps each event name to its payload, e.g. `EventBus<{ enemyKilled: { id: number } }>`.\n *\n * A listener that throws does not stop the ones after it; the error is handed to `onError` (the console by default).\n */\nexport class EventBus<Events extends object> {\n  private readonly listeners = new Map<keyof Events, ((payload: never) => void)[]>();\n\n  constructor(private readonly onError: (type: keyof Events, err: unknown) => void = (type, err) => console.error(`[events] ${String(type)} listener failed`, err)) {}\n\n  /** Subscribes to `type`; returns the unsubscribe function. */\n  on<K extends keyof Events>(type: K, fn: (payload: Events[K]) => void): () => void {\n    this.listeners.set(type, [...(this.listeners.get(type) ?? []), fn]);\n    return () => this.off(type, fn);\n  }\n\n  /** Subscribes for the next `type` only. */\n  once<K extends keyof Events>(type: K, fn: (payload: Events[K]) => void): () => void {\n    const off = this.on(type, (payload) => {\n      off();\n      fn(payload);\n    });\n    return off;\n  }\n\n  off<K extends keyof Events>(type: K, fn: (payload: Events[K]) => void): void {\n    const list = this.listeners.get(type);\n    if (!list) return;\n    const left = list.filter((f) => f !== fn);\n    if (left.length) this.listeners.set(type, left);\n    else this.listeners.delete(type);\n  }\n\n  emit<K extends keyof Events>(type: K, payload: Events[K]): void {\n    // the list is replaced, never mutated, on every (un)subscribe: walking this one is safe while listeners change it\n    for (const fn of this.listeners.get(type) ?? []) {\n      try {\n        (fn as (payload: Events[K]) => void)(payload);\n      } catch (err) {\n        this.onError(type, err);\n      }\n    }\n  }\n\n  listenerCount(type: keyof Events): number {\n    return this.listeners.get(type)?.length ?? 0;\n  }\n\n  clear(): void {\n    this.listeners.clear();\n  }\n}\n"],"names":["EventBus","onError","type","err","fn","off","payload","list","left","f"],"mappings":"AAMO,MAAMA,EAAgC;AAAA,EAG3C,YAA6BC,IAAsD,CAACC,GAAMC,MAAQ,QAAQ,MAAM,YAAY,OAAOD,CAAI,CAAC,oBAAoBC,CAAG,GAAG;AAArI,SAAA,UAAAF;AAAA,EAAsI;AAAA,EAAtI;AAAA,EAFZ,gCAAgB,IAAA;AAAA;AAAA,EAKjC,GAA2BC,GAASE,GAA8C;AAChF,gBAAK,UAAU,IAAIF,GAAM,CAAC,GAAI,KAAK,UAAU,IAAIA,CAAI,KAAK,CAAA,GAAKE,CAAE,CAAC,GAC3D,MAAM,KAAK,IAAIF,GAAME,CAAE;AAAA,EAChC;AAAA;AAAA,EAGA,KAA6BF,GAASE,GAA8C;AAClF,UAAMC,IAAM,KAAK,GAAGH,GAAM,CAACI,MAAY;AACrC,MAAAD,EAAA,GACAD,EAAGE,CAAO;AAAA,IACZ,CAAC;AACD,WAAOD;AAAA,EACT;AAAA,EAEA,IAA4BH,GAASE,GAAwC;AAC3E,UAAMG,IAAO,KAAK,UAAU,IAAIL,CAAI;AACpC,QAAI,CAACK,EAAM;AACX,UAAMC,IAAOD,EAAK,OAAO,CAACE,MAAMA,MAAML,CAAE;AACxC,IAAII,EAAK,SAAQ,KAAK,UAAU,IAAIN,GAAMM,CAAI,IACzC,KAAK,UAAU,OAAON,CAAI;AAAA,EACjC;AAAA,EAEA,KAA6BA,GAASI,GAA0B;AAE9D,eAAWF,KAAM,KAAK,UAAU,IAAIF,CAAI,KAAK;AAC3C,UAAI;AACD,QAAAE,EAAoCE,CAAO;AAAA,MAC9C,SAASH,GAAK;AACZ,aAAK,QAAQD,GAAMC,CAAG;AAAA,MACxB;AAAA,EAEJ;AAAA,EAEA,cAAcD,GAA4B;AACxC,WAAO,KAAK,UAAU,IAAIA,CAAI,GAAG,UAAU;AAAA,EAC7C;AAAA,EAEA,QAAc;AACZ,SAAK,UAAU,MAAA;AAAA,EACjB;AACF;"}

package/dist/fx/FloatingText.js

@@ -0,0 +1,72 @@
+import { installLabelFont as k } from "../core/BitmapLabel.js";
+const d = (n) => `${n.size}|${n.color}`;
+class m {
+  constructor(t, s) {
+    this.stage = t, this.options = s, this.stroke = s.stroke ?? "#140e18", this.strokeWidth = s.strokeWidth ?? ((i) => Math.max(2, Math.round(i / 5))), this.resolution = s.resolution ?? 4, this.keep = s.keepPerStyle ?? 24;
+  }
+  stage;
+  options;
+  pools = /* @__PURE__ */ new Map();
+  stroke;
+  strokeWidth;
+  resolution;
+  keep;
+  /**
+   * Bakes the fonts of `styles`, one a task starting `delayMs` from now, so no frame pays for them all at once — ten
+   * at once froze a world's first frame half a second (each font measures and kerns every glyph). Returns a cancel.
+   */
+  warm(t, s = 1e3, i = 50) {
+    const o = [...t];
+    let r;
+    const e = () => {
+      const h = o.shift();
+      h && (this.install(h), r = setTimeout(e, i));
+    };
+    return r = setTimeout(e, s), () => clearTimeout(r);
+  }
+  /** Bakes one style's font now. */
+  install(t) {
+    k(this.options.fontFamily, t.size, t.color, this.stroke, this.strokeWidth(t.size), this.resolution, this.options.glyphs);
+  }
+  /** A label ready to animate: shown, opaque, unscaled, anchored at its bottom centre on (x, y). */
+  take(t, s, i, o) {
+    const r = this.pools.get(d(o));
+    let e = r?.pop();
+    for (; e && e.destroyed; ) e = r?.pop();
+    return e ? (e.setText(i), e.position.set(t, s), e.alpha = 1, e.setScale(1), e.visible = !0) : (e = this.stage.add.label(t, s, i, this.options.fontFamily, o.size, o.color, this.stroke, this.strokeWidth(o.size), this.resolution, this.options.glyphs).setOrigin(0.5, 1), this.options.parent && this.options.parent.addChild(e)), this.options.depth !== void 0 && e.setDepth(this.options.depth), e;
+  }
+  /** Hands a finished label back for reuse. */
+  release(t, s) {
+    if (t.destroyed) return;
+    const i = d(s);
+    let o = this.pools.get(i);
+    if (o || this.pools.set(i, o = []), o.length >= this.keep) {
+      t.destroy();
+      return;
+    }
+    t.visible = !1, o.push(t);
+  }
+  /** A label that pops, rises, fades and goes back to the pool by itself, on the stage's own tweens. */
+  float(t, s, i, o, r = {}) {
+    const { rise: e = 16, driftX: h = 0, pop: a = 1.4, popMs: c = 120, holdMs: f = 350, fadeMs: u = 500 } = r, l = this.take(t, s, i, o), p = this.stage.tweens;
+    return a !== 1 && (l.setScale(a), p.add({ targets: l, scale: 1, duration: c, ease: "Back.Out" })), p.add({
+      targets: l,
+      x: t + h,
+      y: s - e,
+      alpha: 0,
+      delay: f,
+      duration: u,
+      ease: "Sine.In",
+      onComplete: () => this.release(l, o)
+    }), l;
+  }
+  /** Destroys every pooled label (a scene ending); labels still out are the scene's to free. */
+  clear() {
+    for (const t of this.pools.values()) for (const s of t) s.destroyed || s.destroy();
+    this.pools.clear();
+  }
+}
+export {
+  m as FloatingText
+};
+//# sourceMappingURL=FloatingText.js.map

package/dist/fx/FloatingText.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloatingText.js","sources":["../../src/fx/FloatingText.ts"],"sourcesContent":["import { type BitmapLabel, installLabelFont } from '../core/BitmapLabel';\nimport type { Container } from 'pixi.js';\nimport type { Stage } from '../core/Stage';\n\n/** One look of floating text: a size and a fill colour. Each look is its own baked font. */\nexport interface FloatingTextStyle {\n  size: number;\n  color: string;\n}\n\nexport interface FloatingTextOptions {\n  /** A font already loaded (`document.fonts.load`), or the glyphs bake in the fallback. */\n  fontFamily: string;\n  /** Outline colour (default near-black). */\n  stroke?: string;\n  /** Outline width for a size (default a fifth of it, at least 2). */\n  strokeWidth?: (size: number) => number;\n  /** Rasterising resolution (default 4, crisp under a zoomed camera). */\n  resolution?: number;\n  /** Spent labels of one style kept for reuse; the rest are destroyed (default 24). */\n  keepPerStyle?: number;\n  /** Letters beyond ASCII the labels print (see `installLabelFont`), baked with each style's font. */\n  glyphs?: string;\n  /** Depth given to every label taken (default: left as made). */\n  depth?: number;\n  /**\n   * Where new labels are added (default the stage's world layer). Give a scene's `root` and the labels live and die\n   * with the scene: on the world layer they outlive it, and a label still floating when the scene changes stays.\n   */\n  parent?: Container;\n}\n\n/** How `float` moves a label: pops from `pop`× to 1, holds, then rises `rise` px while fading out. */\nexport interface FloatOptions {\n  rise?: number;\n  /** Sideways drift over the fade, px (pass a random one for a crowd of numbers that do not stack). */\n  driftX?: number;\n  pop?: number;\n  popMs?: number;\n  holdMs?: number;\n  fadeMs?: number;\n}\n\nconst keyOf = (s: FloatingTextStyle) => `${s.size}|${s.color}`;\n\n/**\n * Floating text — damage numbers, pickups, \"+1\" — drawn from bitmap fonts and reused rather than created and\n * destroyed each time: a crowded fight throws dozens a second, and as canvas text each one repainted a canvas at\n * resolution 4 and uploaded it. A label keeps its font, so spent ones are pooled per style and only their string\n * changes. Fonts are baked ahead (`warm`): a style first met mid-fight baked its glyph pages on that frame.\n */\nexport class FloatingText {\n  private readonly pools = new Map<string, BitmapLabel[]>();\n  private readonly stroke: string;\n  private readonly strokeWidth: (size: number) => number;\n  private readonly resolution: number;\n  private readonly keep: number;\n\n  constructor(\n    private readonly stage: Stage,\n    private readonly options: FloatingTextOptions,\n  ) {\n    this.stroke = options.stroke ?? '#140e18';\n    this.strokeWidth = options.strokeWidth ?? ((size) => Math.max(2, Math.round(size / 5)));\n    this.resolution = options.resolution ?? 4;\n    this.keep = options.keepPerStyle ?? 24;\n  }\n\n  /**\n   * Bakes the fonts of `styles`, one a task starting `delayMs` from now, so no frame pays for them all at once — ten\n   * at once froze a world's first frame half a second (each font measures and kerns every glyph). Returns a cancel.\n   */\n  warm(styles: readonly FloatingTextStyle[], delayMs = 1000, gapMs = 50): () => void {\n    const todo = [...styles];\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    const next = () => {\n      const s = todo.shift();\n      if (!s) return;\n      this.install(s);\n      timer = setTimeout(next, gapMs);\n    };\n    timer = setTimeout(next, delayMs);\n    return () => clearTimeout(timer);\n  }\n\n  /** Bakes one style's font now. */\n  install(style: FloatingTextStyle): void {\n    installLabelFont(this.options.fontFamily, style.size, style.color, this.stroke, this.strokeWidth(style.size), this.resolution, this.options.glyphs);\n  }\n\n  /** A label ready to animate: shown, opaque, unscaled, anchored at its bottom centre on (x, y). */\n  take(x: number, y: number, text: string, style: FloatingTextStyle): BitmapLabel {\n    const pool = this.pools.get(keyOf(style));\n    let t = pool?.pop();\n    while (t && t.destroyed) t = pool?.pop();\n    if (!t) {\n      t = this.stage.add\n        .label(x, y, text, this.options.fontFamily, style.size, style.color, this.stroke, this.strokeWidth(style.size), this.resolution, this.options.glyphs)\n        .setOrigin(0.5, 1);\n      // made on the world layer by the factory; moved under the game's own container when it named one\n      if (this.options.parent) this.options.parent.addChild(t);\n    } else {\n      t.setText(text);\n      t.position.set(x, y);\n      t.alpha = 1;\n      t.setScale(1);\n      t.visible = true;\n    }\n    if (this.options.depth !== undefined) t.setDepth(this.options.depth);\n    return t;\n  }\n\n  /** Hands a finished label back for reuse. */\n  release(t: BitmapLabel, style: FloatingTextStyle): void {\n    if (t.destroyed) return;\n    const key = keyOf(style);\n    let pool = this.pools.get(key);\n    if (!pool) this.pools.set(key, (pool = []));\n    if (pool.length >= this.keep) {\n      t.destroy();\n      return;\n    }\n    t.visible = false;\n    pool.push(t);\n  }\n\n  /** A label that pops, rises, fades and goes back to the pool by itself, on the stage's own tweens. */\n  float(x: number, y: number, text: string, style: FloatingTextStyle, options: FloatOptions = {}): BitmapLabel {\n    const { rise = 16, driftX = 0, pop = 1.4, popMs = 120, holdMs = 350, fadeMs = 500 } = options;\n    const t = this.take(x, y, text, style);\n    const tweens = this.stage.tweens;\n    if (pop !== 1) {\n      t.setScale(pop);\n      tweens.add({ targets: t, scale: 1, duration: popMs, ease: 'Back.Out' });\n    }\n    tweens.add({\n      targets: t,\n      x: x + driftX,\n      y: y - rise,\n      alpha: 0,\n      delay: holdMs,\n      duration: fadeMs,\n      ease: 'Sine.In',\n      onComplete: () => this.release(t, style),\n    });\n    return t;\n  }\n\n  /** Destroys every pooled label (a scene ending); labels still out are the scene's to free. */\n  clear(): void {\n    for (const pool of this.pools.values()) for (const t of pool) if (!t.destroyed) t.destroy();\n    this.pools.clear();\n  }\n}\n"],"names":["keyOf","s","FloatingText","stage","options","size","styles","delayMs","gapMs","todo","timer","next","style","installLabelFont","x","y","text","pool","t","key","rise","driftX","pop","popMs","holdMs","fadeMs","tweens"],"mappings":"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"}

package/dist/fx/hitStop.js

@@ -0,0 +1,28 @@
+function o(n, r) {
+  const t = Math.min(140, 40 + Math.max(0, n) * 400);
+  return Math.round(t + (r ? 40 : 0));
+}
+function e(n, r, t) {
+  return n ? t ? 2 : 1 : Math.min(3, 2 + (r > 0.2 ? 1 : 0) + (t ? 1 : 0));
+}
+const i = 120;
+function h(n, r) {
+  return r >= 1 || n <= 0 ? 0 : Math.round(n * (1 - r) * (1 - r));
+}
+const u = 400;
+function M(n, r, t) {
+  return t ? 0 : n ? r ? 60 : 0 : r ? 140 : 70;
+}
+function a(n) {
+  return n ? u : 0;
+}
+export {
+  u as HEAVY_FLASH_GAP_MS,
+  i as RECOIL_MS,
+  o as hitStopMs,
+  a as hurtFlashGapMs,
+  M as hurtFlashMs,
+  h as recoilAt,
+  e as recoilPx
+};
+//# sourceMappingURL=hitStop.js.map

package/dist/fx/hitStop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hitStop.js","sources":["../../src/fx/hitStop.ts"],"sourcesContent":["/*\n * How hard a landed blow feels. Pure, so the numbers\n * can be pinned: the freeze-frame grows with the share of the body's health the blow took, a crit holds longer, and the\n * body struck is knocked a pixel or three away from whoever struck it — less the bigger it is.\n */\n\n/** The freeze-frame of a blow (ms): 40 for a scratch, up to 140 for one that took a third of the body; a crit +40. */\nexport function hitStopMs(share: number, crit: boolean): number {\n  const base = Math.min(140, 40 + Math.max(0, share) * 400);\n  return Math.round(base + (crit ? 40 : 0));\n}\n\n/** How far the body struck recoils away from the blow (whole world px): a heavy body barely, a crit a pixel further. */\nexport function recoilPx(heavy: boolean, share: number, crit: boolean): number {\n  if (heavy) return crit ? 2 : 1;\n  return Math.min(3, 2 + (share > 0.2 ? 1 : 0) + (crit ? 1 : 0));\n}\n\n/** How long a recoil takes to settle back (ms). */\nexport const RECOIL_MS = 120;\n\n/** The recoil left at `t` (0 the blow, 1 settled): out at once, eased back, whole pixels only. */\nexport function recoilAt(px: number, t: number): number {\n  if (t >= 1 || px <= 0) return 0;\n  return Math.round(px * (1 - t) * (1 - t));\n}\n\n/** The least time between two white flashes on a heavy body (ms). */\nexport const HEAVY_FLASH_GAP_MS = 400;\n\n/**\n * How long the body struck flashes white (ms), 0 for none: 70, a crit of one's own 140 (the impact frame), nothing with\n * `reduce` (a \"reduce flashes\" setting). A heavy body (a boss, anything drawn large) flashes only for the local\n * player's own crit, 60 ms, `HEAVY_FLASH_GAP_MS` apart: a sheet covering most of the screen turning white on every\n * blow, beat and tick is a strobe. Sparks, numbers and the recoil still mark every blow.\n */\nexport function hurtFlashMs(heavy: boolean, impact: boolean, reduce: boolean): number {\n  if (reduce) return 0;\n  if (heavy) return impact ? 60 : 0;\n  return impact ? 140 : 70;\n}\n\n/** The gap a body keeps between two flashes (ms). */\nexport function hurtFlashGapMs(heavy: boolean): number {\n  return heavy ? HEAVY_FLASH_GAP_MS : 0;\n}\n"],"names":["hitStopMs","share","crit","base","recoilPx","heavy","RECOIL_MS","recoilAt","px","t","HEAVY_FLASH_GAP_MS","hurtFlashMs","impact","reduce","hurtFlashGapMs"],"mappings":"AAOO,SAASA,EAAUC,GAAeC,GAAuB;AAC9D,QAAMC,IAAO,KAAK,IAAI,KAAK,KAAK,KAAK,IAAI,GAAGF,CAAK,IAAI,GAAG;AACxD,SAAO,KAAK,MAAME,KAAQD,IAAO,KAAK,EAAE;AAC1C;AAGO,SAASE,EAASC,GAAgBJ,GAAeC,GAAuB;AAC7E,SAAIG,IAAcH,IAAO,IAAI,IACtB,KAAK,IAAI,GAAG,KAAKD,IAAQ,MAAM,IAAI,MAAMC,IAAO,IAAI,EAAE;AAC/D;AAGO,MAAMI,IAAY;AAGlB,SAASC,EAASC,GAAYC,GAAmB;AACtD,SAAIA,KAAK,KAAKD,KAAM,IAAU,IACvB,KAAK,MAAMA,KAAM,IAAIC,MAAM,IAAIA,EAAE;AAC1C;AAGO,MAAMC,IAAqB;AAQ3B,SAASC,EAAYN,GAAgBO,GAAiBC,GAAyB;AACpF,SAAIA,IAAe,IACfR,IAAcO,IAAS,KAAK,IACzBA,IAAS,MAAM;AACxB;AAGO,SAASE,EAAeT,GAAwB;AACrD,SAAOA,IAAQK,IAAqB;AACtC;"}

package/dist/fx/viewCull.js

@@ -0,0 +1,10 @@
+function u(o, e, n, t) {
+  const s = o.width, l = o.height;
+  if (!s || !l || !(o.zoom > 0)) return !0;
+  const r = o.scrollX ?? 0, h = o.scrollY ?? 0;
+  return e >= r - t && n >= h - t && e <= r + s / o.zoom + t && n <= h + l / o.zoom + t;
+}
+export {
+  u as inView
+};
+//# sourceMappingURL=viewCull.js.map

package/dist/fx/viewCull.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewCull.js","sources":["../../src/fx/viewCull.ts"],"sourcesContent":["/** What `inView` reads off the main camera (Camera's own fields; a fake stage may lack them). */\nexport interface CameraLike {\n  zoom: number;\n  scrollX?: number;\n  scrollY?: number;\n  width?: number;\n  height?: number;\n}\n\n/**\n * Whether the world point (x, y) lies within `margin` world pixels of the screen. Effects use it to skip painting what\n * nobody can see. A camera that has no size yet (a tool's fake stage, before the first resize) counts everything in.\n */\nexport function inView(cam: CameraLike, x: number, y: number, margin: number): boolean {\n  const w = cam.width;\n  const h = cam.height;\n  if (!w || !h || !(cam.zoom > 0)) return true;\n  const left = cam.scrollX ?? 0;\n  const top = cam.scrollY ?? 0;\n  return x >= left - margin && y >= top - margin && x <= left + w / cam.zoom + margin && y <= top + h / cam.zoom + margin;\n}\n"],"names":["inView","cam","x","y","margin","w","h","left","top"],"mappings":"AAaO,SAASA,EAAOC,GAAiBC,GAAWC,GAAWC,GAAyB;AACrF,QAAMC,IAAIJ,EAAI,OACRK,IAAIL,EAAI;AACd,MAAI,CAACI,KAAK,CAACC,KAAK,EAAEL,EAAI,OAAO,GAAI,QAAO;AACxC,QAAMM,IAAON,EAAI,WAAW,GACtBO,IAAMP,EAAI,WAAW;AAC3B,SAAOC,KAAKK,IAAOH,KAAUD,KAAKK,IAAMJ,KAAUF,KAAKK,IAAOF,IAAIJ,EAAI,OAAOG,KAAUD,KAAKK,IAAMF,IAAIL,EAAI,OAAOG;AACnH;"}

package/dist/i18n/Translator.js

@@ -0,0 +1,72 @@
+import { sourceText as n, formatMessage as o } from "./formatMessage.js";
+class c {
+  source;
+  lang;
+  catalogs = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  rules = /* @__PURE__ */ new Map();
+  reported = /* @__PURE__ */ new Set();
+  onMissing;
+  constructor(t = {}) {
+    this.source = t.source ?? "en", this.lang = t.language ?? this.source, this.onMissing = t.onMissing;
+  }
+  get language() {
+    return this.lang;
+  }
+  /** Languages with a catalog, plus the source. */
+  get languages() {
+    return [.../* @__PURE__ */ new Set([this.source, ...this.catalogs.keys()])];
+  }
+  /** Adds (or merges into) a language's catalog; subscribers hear of it when it is the language shown. */
+  addCatalog(t, e) {
+    const s = this.catalogs.get(t);
+    this.catalogs.set(t, s ? { ...s, ...e } : e), t === this.lang && this.notify();
+  }
+  setLanguage(t) {
+    t !== this.lang && (this.lang = t, this.notify());
+  }
+  /** Calls `fn` with the language after every switch; the returned function stops it. */
+  subscribe(t) {
+    return this.listeners.add(t), () => this.listeners.delete(t);
+  }
+  /** Whether the current language has its own line for `key`. */
+  has(t) {
+    return this.catalogs.get(this.lang)?.[t] !== void 0;
+  }
+  tr = (t, ...e) => {
+    const s = this.lookup(t);
+    let i;
+    return s === void 0 ? i = n(t) : typeof s == "string" ? i = s : i = s.other ?? n(t), o(i, e);
+  };
+  trn = (t, e, s, ...i) => {
+    const r = this.lookup(e), a = [s, ...i];
+    if (r === void 0) return o(n(this.category(this.source, s) === "one" ? t : e), a);
+    if (typeof r == "string") return o(r, a);
+    const l = r[this.category(this.lang, s)] ?? r.other ?? n(e);
+    return o(l, a);
+  };
+  lookup(t) {
+    const e = this.catalogs.get(this.lang)?.[t];
+    if (e === void 0 && this.lang !== this.source && this.onMissing) {
+      const s = `${this.lang}\0${t}`;
+      this.reported.has(s) || (this.reported.add(s), this.onMissing(t, this.lang));
+    }
+    return e;
+  }
+  category(t, e) {
+    let s = this.rules.get(t);
+    return s || (s = new Intl.PluralRules(t), this.rules.set(t, s)), s.select(e);
+  }
+  notify() {
+    for (const t of [...this.listeners])
+      try {
+        t(this.lang);
+      } catch (e) {
+        console.error("[i18n] a language listener failed", e);
+      }
+  }
+}
+export {
+  c as Translator
+};
+//# sourceMappingURL=Translator.js.map

package/dist/i18n/Translator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Translator.js","sources":["../../src/i18n/Translator.ts"],"sourcesContent":["import { formatMessage, sourceText } from './formatMessage';\n\n/** A translation that changes with a count, by the plural categories of the language (`one`, `few`, `many`, `other`…). */\nexport type PluralForms = Partial<Record<Intl.LDMLPluralRule, string>>;\n\n/** A language's translations, keyed by the English source (with its `|context`, if any). */\nexport type Catalog = Readonly<Record<string, string | PluralForms>>;\n\nexport interface TranslatorOptions {\n  /** The language strings are written in (default 'en'): shown as written, never reported missing. */\n  source?: string;\n  /** The language to start in (default the source). */\n  language?: string;\n  /** Told once per key and language of every string with no translation, for tooling or a log. */\n  onMissing?: (key: string, language: string) => void;\n}\n\n/**\n * Translation with the English source as the key: `tr('Open the gate')` shows the English until a catalog for the\n * current language has a line for it, so writing a new string never breaks the game, it only shows untranslated.\n *\n * - Placeholders are positional: `tr('{0} joined', name)`.\n * - The same English with two meanings gets a context after `|`: `tr('Close|window')`, `tr('Close|near')`. The\n *   context is a separate key for translators and never shown.\n * - Counts: `trn('{0} coin', '{0} coins', n)` picks a form by `Intl.PluralRules`; the key is the plural form, and\n *   a catalog may give every category its language has (`{ one, few, many, other }`). `{0}` is the count.\n * - `setLanguage` switches at once and tells subscribers, so a UI re-renders instead of reloading: read labels when\n *   they are shown, never once at import.\n *\n * `tr` and `trn` are bound, so they can be handed around (`const { tr } = translator`).\n */\nexport class Translator {\n  readonly source: string;\n  private lang: string;\n  private readonly catalogs = new Map<string, Catalog>();\n  private readonly listeners = new Set<(language: string) => void>();\n  private readonly rules = new Map<string, Intl.PluralRules>();\n  private readonly reported = new Set<string>();\n  private readonly onMissing: ((key: string, language: string) => void) | undefined;\n\n  constructor(options: TranslatorOptions = {}) {\n    this.source = options.source ?? 'en';\n    this.lang = options.language ?? this.source;\n    this.onMissing = options.onMissing;\n  }\n\n  get language(): string {\n    return this.lang;\n  }\n\n  /** Languages with a catalog, plus the source. */\n  get languages(): string[] {\n    return [...new Set([this.source, ...this.catalogs.keys()])];\n  }\n\n  /** Adds (or merges into) a language's catalog; subscribers hear of it when it is the language shown. */\n  addCatalog(language: string, catalog: Catalog): void {\n    const had = this.catalogs.get(language);\n    this.catalogs.set(language, had ? { ...had, ...catalog } : catalog);\n    if (language === this.lang) this.notify();\n  }\n\n  setLanguage(language: string): void {\n    if (language === this.lang) return;\n    this.lang = language;\n    this.notify();\n  }\n\n  /** Calls `fn` with the language after every switch; the returned function stops it. */\n  subscribe(fn: (language: string) => void): () => void {\n    this.listeners.add(fn);\n    return () => this.listeners.delete(fn);\n  }\n\n  /** Whether the current language has its own line for `key`. */\n  has(key: string): boolean {\n    return this.catalogs.get(this.lang)?.[key] !== undefined;\n  }\n\n  readonly tr = (key: string, ...args: unknown[]): string => {\n    const entry = this.lookup(key);\n    let text: string;\n    if (entry === undefined) text = sourceText(key);\n    else if (typeof entry === 'string') text = entry;\n    else text = entry.other ?? sourceText(key);\n    return formatMessage(text, args);\n  };\n\n  readonly trn = (one: string, other: string, count: number, ...args: unknown[]): string => {\n    const entry = this.lookup(other);\n    const all = [count, ...args];\n    if (entry === undefined) return formatMessage(sourceText(this.category(this.source, count) === 'one' ? one : other), all);\n    if (typeof entry === 'string') return formatMessage(entry, all);\n    const text = entry[this.category(this.lang, count)] ?? entry.other ?? sourceText(other);\n    return formatMessage(text, all);\n  };\n\n  private lookup(key: string): string | PluralForms | undefined {\n    const entry = this.catalogs.get(this.lang)?.[key];\n    if (entry === undefined && this.lang !== this.source && this.onMissing) {\n      const id = `${this.lang}\\u0000${key}`;\n      if (!this.reported.has(id)) {\n        this.reported.add(id);\n        this.onMissing(key, this.lang);\n      }\n    }\n    return entry;\n  }\n\n  private category(language: string, count: number): Intl.LDMLPluralRule {\n    let r = this.rules.get(language);\n    if (!r) {\n      r = new Intl.PluralRules(language);\n      this.rules.set(language, r);\n    }\n    return r.select(count);\n  }\n\n  private notify(): void {\n    for (const fn of [...this.listeners]) {\n      try {\n        fn(this.lang);\n      } catch (err) {\n        console.error('[i18n] a language listener failed', err);\n      }\n    }\n  }\n}\n"],"names":["Translator","options","language","catalog","had","fn","key","args","entry","text","sourceText","formatMessage","one","other","count","all","id","r","err"],"mappings":"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"}

package/dist/i18n/extractStrings.js

@@ -0,0 +1,58 @@
+function v(n, i = {}) {
+  const f = i.single ?? ["tr"], u = i.plural ?? ["trn"], o = [...f, ...u].map((l) => l.replace(/[$.*+?^()[\]{}|\\]/g, "\\$&"));
+  if (o.length === 0) return [];
+  const e = new RegExp(`(?<![\\w$])(${o.join("|")})\\s*\\(`, "g"), c = [];
+  let r = 1, t = 0;
+  for (const l of n.matchAll(e)) {
+    const s = l[1], a = h(n, l.index + l[0].length);
+    if (!a) continue;
+    for (; t < l.index; t++) n.charCodeAt(t) === 10 && r++;
+    if (!u.includes(s)) {
+      c.push({ key: a.value, fn: s, line: r });
+      continue;
+    }
+    let d = p(n, a.end);
+    if (n[d] !== ",") continue;
+    const g = h(n, d + 1);
+    g && c.push({ key: g.value, one: a.value, fn: s, line: r });
+  }
+  return c;
+}
+function p(n, i) {
+  for (; i < n.length && /\s/.test(n[i]); ) i++;
+  return i;
+}
+const m = { n: `
+`, t: "	", r: "\r", b: "\b", f: "\f", v: "\v", 0: "\0" };
+function h(n, i) {
+  const f = p(n, i), u = n[f];
+  if (u !== "'" && u !== '"' && u !== "`") return null;
+  let o = "";
+  for (let e = f + 1; e < n.length; e++) {
+    const c = n[e];
+    if (c === u) return { value: o, end: e + 1 };
+    if (u !== "`" && c === `
+` || u === "`" && c === "$" && n[e + 1] === "{") return null;
+    if (c !== "\\") {
+      o += c;
+      continue;
+    }
+    const r = n[++e];
+    if (r === void 0) return null;
+    if (r !== `
+`) {
+      if (r === "u" || r === "x") {
+        const t = r === "u" && n[e + 1] === "{", l = t ? n.slice(e + 2, n.indexOf("}", e)) : n.slice(e + 1, e + (r === "u" ? 5 : 3)), s = Number.parseInt(l, 16);
+        if (Number.isNaN(s)) return null;
+        o += String.fromCodePoint(s), e += t ? l.length + 2 : l.length;
+        continue;
+      }
+      o += m[r] ?? r;
+    }
+  }
+  return null;
+}
+export {
+  v as extractStrings
+};
+//# sourceMappingURL=extractStrings.js.map

package/dist/i18n/extractStrings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractStrings.js","sources":["../../src/i18n/extractStrings.ts"],"sourcesContent":["/** One translatable string found in source text. */\nexport interface ExtractedString {\n  /** The catalog key: the string as written, `|context` included. */\n  key: string;\n  /** For a plural call, the singular form written beside the key. */\n  one?: string;\n  /** The function it was passed to. */\n  fn: string;\n  /** 1-based line of the call. */\n  line: number;\n}\n\nexport interface ExtractOptions {\n  /** Functions whose first argument is a key (default `['tr']`). */\n  single?: readonly string[];\n  /** Functions called `(one, other, count…)`, keyed by `other` (default `['trn']`). */\n  plural?: readonly string[];\n}\n\n/**\n * Finds the strings passed to `tr('…')` (and `trn('…', '…', n)`) in a file's text, for a tool that lists keys\n * missing from a catalog or drops unused ones. A plain scanner, not a parser: it reads a string literal straight\n * after the call's parenthesis (quotes of any kind, escapes decoded) and skips a template literal with `${…}` in it\n * or a call whose key is not a literal, since neither can be a catalog key. A call inside a comment is still found.\n */\nexport function extractStrings(text: string, options: ExtractOptions = {}): ExtractedString[] {\n  const single = options.single ?? ['tr'];\n  const plural = options.plural ?? ['trn'];\n  const names = [...single, ...plural].map((n) => n.replace(/[$.*+?^()[\\]{}|\\\\]/g, '\\\\$&'));\n  if (names.length === 0) return [];\n  const call = new RegExp(`(?<![\\\\w$])(${names.join('|')})\\\\s*\\\\(`, 'g');\n  const out: ExtractedString[] = [];\n  let line = 1;\n  let scanned = 0;\n  for (const m of text.matchAll(call)) {\n    const fn = m[1]!;\n    const first = readString(text, m.index + m[0].length);\n    if (!first) continue;\n    for (; scanned < m.index; scanned++) if (text.charCodeAt(scanned) === 10) line++;\n    if (!plural.includes(fn)) {\n      out.push({ key: first.value, fn, line });\n      continue;\n    }\n    let i = skipSpace(text, first.end);\n    if (text[i] !== ',') continue;\n    const second = readString(text, i + 1);\n    if (second) out.push({ key: second.value, one: first.value, fn, line });\n  }\n  return out;\n}\n\nfunction skipSpace(text: string, i: number): number {\n  while (i < text.length && /\\s/.test(text[i]!)) i++;\n  return i;\n}\n\nconst ESCAPES: Record<string, string> = { n: '\\n', t: '\\t', r: '\\r', b: '\\b', f: '\\f', v: '\\v', '0': '\\0' };\n\n/** The string literal starting at `from` (after spaces), decoded, and the index after its closing quote. */\nfunction readString(text: string, from: number): { value: string; end: number } | null {\n  const start = skipSpace(text, from);\n  const quote = text[start];\n  if (quote !== \"'\" && quote !== '\"' && quote !== '`') return null;\n  let value = '';\n  for (let i = start + 1; i < text.length; i++) {\n    const c = text[i]!;\n    if (c === quote) return { value, end: i + 1 };\n    if (quote !== '`' && c === '\\n') return null;\n    if (quote === '`' && c === '$' && text[i + 1] === '{') return null;\n    if (c !== '\\\\') {\n      value += c;\n      continue;\n    }\n    const e = text[++i];\n    if (e === undefined) return null;\n    if (e === '\\n') continue; // a line continuation\n    if (e === 'u' || e === 'x') {\n      const braced = e === 'u' && text[i + 1] === '{';\n      const hex = braced ? text.slice(i + 2, text.indexOf('}', i)) : text.slice(i + 1, i + (e === 'u' ? 5 : 3));\n      const code = Number.parseInt(hex, 16);\n      if (Number.isNaN(code)) return null;\n      value += String.fromCodePoint(code);\n      i += braced ? hex.length + 2 : hex.length;\n      continue;\n    }\n    value += ESCAPES[e] ?? e;\n  }\n  return null;\n}\n"],"names":["extractStrings","text","options","single","plural","names","n","call","out","line","scanned","m","fn","first","readString","i","skipSpace","second","ESCAPES","from","start","quote","value","e","braced","hex","code"],"mappings":"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"}

package/dist/i18n/formatMessage.js

@@ -0,0 +1,19 @@
+const u = "|";
+function f(n) {
+  const r = n.lastIndexOf("|");
+  return r < 0 ? n : n.slice(0, r);
+}
+function c(n, r) {
+  return n.indexOf("{") < 0 && n.indexOf("}") < 0 ? n : n.replace(/\{\{|\}\}|\{(\d+)\}/g, (e, t) => {
+    if (e === "{{") return "{";
+    if (e === "}}") return "}";
+    const i = Number(t);
+    return i < r.length ? String(r[i]) : e;
+  });
+}
+export {
+  u as CONTEXT_MARK,
+  c as formatMessage,
+  f as sourceText
+};
+//# sourceMappingURL=formatMessage.js.map

package/dist/i18n/formatMessage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatMessage.js","sources":["../../src/i18n/formatMessage.ts"],"sourcesContent":["/** The separator between a source string and its context: `'Open|door'` and `'Open|file'` are two keys. */\nexport const CONTEXT_MARK = '|';\n\n/** The text a key shows untranslated: the source without its `|context`. */\nexport function sourceText(key: string): string {\n  const i = key.lastIndexOf(CONTEXT_MARK);\n  return i < 0 ? key : key.slice(0, i);\n}\n\n/**\n * Fills `{0}`, `{1}`… with `args`. A placeholder with no argument is left as written, so a missing argument shows\n * where it is instead of printing \"undefined\". `{{` and `}}` print a literal brace.\n */\nexport function formatMessage(text: string, args: readonly unknown[]): string {\n  if (text.indexOf('{') < 0 && text.indexOf('}') < 0) return text;\n  return text.replace(/\\{\\{|\\}\\}|\\{(\\d+)\\}/g, (m, index: string | undefined) => {\n    if (m === '{{') return '{';\n    if (m === '}}') return '}';\n    const i = Number(index);\n    return i < args.length ? String(args[i]) : m;\n  });\n}\n"],"names":["CONTEXT_MARK","sourceText","key","i","formatMessage","text","args","m","index"],"mappings":"AACO,MAAMA,IAAe;AAGrB,SAASC,EAAWC,GAAqB;AAC9C,QAAMC,IAAID,EAAI,YAAY,GAAY;AACtC,SAAOC,IAAI,IAAID,IAAMA,EAAI,MAAM,GAAGC,CAAC;AACrC;AAMO,SAASC,EAAcC,GAAcC,GAAkC;AAC5E,SAAID,EAAK,QAAQ,GAAG,IAAI,KAAKA,EAAK,QAAQ,GAAG,IAAI,IAAUA,IACpDA,EAAK,QAAQ,wBAAwB,CAACE,GAAGC,MAA8B;AAC5E,QAAID,MAAM,KAAM,QAAO;AACvB,QAAIA,MAAM,KAAM,QAAO;AACvB,UAAM,IAAI,OAAOC,CAAK;AACtB,WAAO,IAAIF,EAAK,SAAS,OAAOA,EAAK,CAAC,CAAC,IAAIC;AAAA,EAC7C,CAAC;AACH;"}