1681-engine 0.0.0-stage → 0.5.9

package/dist/save/SaveStore.js

@@ -0,0 +1,102 @@
+import { checksum as u } from "./checksum.js";
+import { MemoryBackend as f } from "./MemoryBackend.js";
+import { migrateSave as k, MigrationError as m } from "./migrateSave.js";
+import { WebStorageBackend as l } from "./WebStorageBackend.js";
+const a = ".bak";
+class S {
+  version;
+  backend;
+  prefix;
+  migrations;
+  backup;
+  now;
+  queues = /* @__PURE__ */ new Map();
+  constructor(e) {
+    if (!Number.isInteger(e.version) || e.version < 1) throw new Error("SaveStore: version must be a whole number from 1");
+    this.version = e.version, this.backend = e.backend ?? w(), this.prefix = e.prefix ?? "save:", this.migrations = e.migrations ?? {}, this.backup = e.backup ?? !0, this.now = e.now ?? Date.now;
+  }
+  /** Writes `data` to `slot` at the current version. Rejects when the backend does (a full disk, a quota). */
+  save(e, n, r = null) {
+    return this.queued(e, async () => {
+      const t = this.key(e), i = JSON.stringify(n);
+      if (i === void 0) throw new Error(`SaveStore: data for "${e}" is not JSON`);
+      const s = { slot: e, version: this.version, savedAt: this.now(), meta: r }, d = { format: "lantern-save", version: s.version, savedAt: s.savedAt, meta: r, checksum: u(i), data: n };
+      if (this.backup) {
+        const c = await this.backend.read(t);
+        c !== null && v(c) && await this.backend.write(t + a, c);
+      }
+      return await this.backend.write(t, JSON.stringify(d)), s;
+    });
+  }
+  /** Reads `slot`, brought to the current version. Never throws for a bad slot: the result says what went wrong. */
+  load(e) {
+    return this.queued(e, async () => {
+      const n = this.key(e), r = await this.open(e, await this.backend.read(n), !1);
+      if (r.ok || !this.backup || r.reason !== "corrupt") return r;
+      const t = await this.open(e, await this.backend.read(n + a), !0);
+      return t.ok ? t : r;
+    });
+  }
+  /** Removes a slot and its backup. */
+  delete(e) {
+    return this.queued(e, async () => {
+      const n = this.key(e);
+      await this.backend.remove(n), await this.backend.remove(n + a);
+    });
+  }
+  /** Every slot that reads, newest first, without migrating its data. A damaged slot is left out. */
+  async list() {
+    const e = await this.backend.keys(this.prefix), n = [];
+    for (const r of e) {
+      if (r.endsWith(a)) continue;
+      const t = await this.backend.read(r), i = t === null ? null : h(t);
+      i && v(t) && n.push({ slot: r.slice(this.prefix.length), version: i.version, savedAt: i.savedAt, meta: i.meta });
+    }
+    return n.sort((r, t) => t.savedAt - r.savedAt);
+  }
+  async open(e, n, r) {
+    if (n === null) return { ok: !1, slot: e, reason: r ? "corrupt" : "missing" };
+    const t = h(n);
+    if (!t || u(JSON.stringify(t.data)) !== t.checksum) return { ok: !1, slot: e, reason: "corrupt" };
+    try {
+      const i = k(t.data, t.version, this.version, this.migrations), s = { slot: e, version: t.version, savedAt: t.savedAt, meta: t.meta };
+      return { ok: !0, data: i, info: s, migrated: t.version !== this.version, fromBackup: r };
+    } catch (i) {
+      if (i instanceof m) return { ok: !1, slot: e, reason: i.reason, error: i };
+      throw i;
+    }
+  }
+  key(e) {
+    if (!e || e.endsWith(a)) throw new Error(`SaveStore: "${e}" is not a usable slot name`);
+    return this.prefix + e;
+  }
+  queued(e, n) {
+    const r = (this.queues.get(e) ?? Promise.resolve()).then(n), t = r.catch(() => {
+    });
+    return this.queues.set(e, t), t.then(() => {
+      this.queues.get(e) === t && this.queues.delete(e);
+    }), r;
+  }
+}
+function h(o) {
+  try {
+    const e = JSON.parse(o);
+    return !e || e.format !== "lantern-save" || typeof e.version != "number" || typeof e.checksum != "string" || !("data" in e) ? null : e;
+  } catch {
+    return null;
+  }
+}
+function v(o) {
+  const e = h(o);
+  return e !== null && u(JSON.stringify(e.data)) === e.checksum;
+}
+function w() {
+  try {
+    if (typeof globalThis.localStorage < "u") return new l(globalThis.localStorage);
+  } catch {
+  }
+  return new f();
+}
+export {
+  S as SaveStore
+};

package/dist/save/WebStorageBackend.js

@@ -0,0 +1,26 @@
+class a {
+  constructor(e = globalThis.localStorage) {
+    if (this.storage = e, !e) throw new Error("WebStorageBackend: no Web Storage here; pass one or use another backend");
+  }
+  storage;
+  async read(e) {
+    return this.storage.getItem(e);
+  }
+  async write(e, t) {
+    this.storage.setItem(e, t);
+  }
+  async remove(e) {
+    this.storage.removeItem(e);
+  }
+  async keys(e) {
+    const t = [];
+    for (let r = 0; r < this.storage.length; r++) {
+      const s = this.storage.key(r);
+      s !== null && s.startsWith(e) && t.push(s);
+    }
+    return t;
+  }
+}
+export {
+  a as WebStorageBackend
+};

package/dist/save/checksum.js

@@ -0,0 +1,9 @@
+function h(e) {
+  let t = 2166136261;
+  for (let r = 0; r < e.length; r++)
+    t ^= e.charCodeAt(r), t = Math.imul(t, 16777619);
+  return (t >>> 0).toString(16).padStart(8, "0");
+}
+export {
+  h as checksum
+};

package/dist/save/migrateSave.js

@@ -0,0 +1,26 @@
+class o extends Error {
+  constructor(r, i, t, n) {
+    super(r, n), this.reason = i, this.fromVersion = t, this.name = "MigrationError";
+  }
+  reason;
+  fromVersion;
+}
+function v(s, r, i, t) {
+  if (!Number.isInteger(r) || r > i)
+    throw new o(`save version ${r} is newer than this build reads (${i})`, "too-new", r);
+  let n = s;
+  for (let e = r; e < i; e++) {
+    const a = t[e];
+    if (!a) throw new o(`no migration from save version ${e} to ${e + 1}`, "no-migration", r);
+    try {
+      n = a(n);
+    } catch (h) {
+      throw new o(`migration from save version ${e} failed`, "migration-failed", r, { cause: h });
+    }
+  }
+  return n;
+}
+export {
+  o as MigrationError,
+  v as migrateSave
+};

package/dist/settings.js

@@ -0,0 +1,26 @@
+const r = {
+  reducedFx: !1,
+  batterySaver: !1,
+  combatLights: !0,
+  sfxVolume: 0.8,
+  musicVolume: 0.6
+};
+let t = { ...r };
+const s = /* @__PURE__ */ new Set(), o = {
+  getState() {
+    return t;
+  },
+  set(e) {
+    t = { ...t, ...e };
+    for (const n of [...s]) n(t);
+  },
+  subscribe(e) {
+    return s.add(e), () => s.delete(e);
+  },
+  reset() {
+    o.set(r);
+  }
+};
+export {
+  o as engineSettings
+};

package/dist/tilemap/TilemapView.js

@@ -0,0 +1,68 @@
+import { Container as M, Sprite as P } from "pixi.js";
+import { tileAt as F, tileRect as H, FLIP_D as V, FLIP_H as $, FLIP_V as L } from "./tiled.js";
+let S = 0;
+class T {
+  constructor(s, i, e = {}) {
+    this.stage = s, this.map = i;
+    const p = e.textureFor ?? ((t) => t.name), r = Math.max(1, e.chunkTiles ?? 32), m = e.baseDepth ?? -1e6, w = e.layers ? new Set(e.layers) : null, c = i.layers.filter((t) => t.kind === "tiles" && (w ? w.has(t.name) : t.visible)), f = e.parent ?? s.world;
+    c.forEach((t, y) => {
+      const x = typeof t.properties.depth == "number" ? t.properties.depth : m + y, l = new M();
+      l.zIndex = x, l.alpha = t.opacity, l.position.set(t.offsetX, t.offsetY), this.layers.set(t.name, l), f.addChild(l);
+      for (let n = 0; n < i.height; n += r)
+        for (let a = 0; a < i.width; a += r) {
+          const o = Math.min(r, i.width - a), d = Math.min(r, i.height - n);
+          this.paintChunk(t, l, a, n, o, d, p);
+        }
+    });
+  }
+  stage;
+  map;
+  /** One container per drawn tile layer, by name, each at its own depth among the bodies. */
+  layers = /* @__PURE__ */ new Map();
+  chunks = [];
+  id = S++;
+  /** Shows only the chunks in the camera's view (plus a margin in world px). Call once a frame. */
+  update(s = 32) {
+    const i = this.stage.cameras.main.worldView;
+    for (const e of this.chunks)
+      e.sprite.visible = e.x < i.right + s && e.x + e.w > i.x - s && e.y < i.bottom + s && e.y + e.h > i.y - s;
+  }
+  /** World size of the map in px. */
+  get widthPx() {
+    return this.map.width * this.map.tileWidth;
+  }
+  get heightPx() {
+    return this.map.height * this.map.tileHeight;
+  }
+  destroy() {
+    for (const s of this.chunks) this.stage.textures.remove(s.key);
+    this.chunks.length = 0;
+    for (const s of this.layers.values()) s.destroy({ children: !0 });
+    this.layers.clear();
+  }
+  paintChunk(s, i, e, p, r, m, w) {
+    const { map: c } = this, f = c.tileWidth, t = c.tileHeight;
+    let y = !1;
+    const x = `tilemap:${this.id}:${s.name}:${e},${p}`, n = Math.max(t, ...c.tilesets.map((u) => u.tileHeight)) - t, a = this.stage.textures.createCanvas(x, r * f, m * t + n), o = a.context;
+    o.imageSmoothingEnabled = !1;
+    for (let u = 0; u < m; u++)
+      for (let k = 0; k < r; k++) {
+        const v = s.data[(p + u) * c.width + (e + k)], g = F(c, v);
+        if (!g) continue;
+        const b = this.stage.textures.exists(w(g.tileset)) ? this.stage.textures.get(w(g.tileset)).source.resource : null;
+        if (!b) continue;
+        const h = H(g.tileset, g.local), C = k * f, I = n + (u + 1) * t - h.h;
+        o.save(), o.translate(C + h.w / 2, I + h.h / 2), v & V && o.transform(0, 1, 1, 0, 0, 0), o.scale(v & $ ? -1 : 1, v & L ? -1 : 1), o.drawImage(b, h.x, h.y, h.w, h.h, -h.w / 2, -h.h / 2, h.w, h.h), o.restore(), y = !0;
+      }
+    if (!y) {
+      this.stage.textures.remove(x);
+      return;
+    }
+    a.refresh();
+    const d = new P(a.whole);
+    d.position.set(e * f, p * t - n), i.addChild(d), this.chunks.push({ sprite: d, x: d.x + s.offsetX, y: d.y + s.offsetY, w: r * f, h: m * t + n, key: x });
+  }
+}
+export {
+  T as TilemapView
+};

package/dist/tilemap/collision.js

@@ -0,0 +1,24 @@
+import { createCollisionGrid as c } from "../net/movement.js";
+import { gidOf as h, tileAt as y } from "./tiled.js";
+function w(i, s = {}) {
+  if (i.tileWidth !== i.tileHeight) throw new Error(`Tiled map: collision needs square tiles, not ${i.tileWidth}x${i.tileHeight}`);
+  const l = s.solid ?? (i.layers.some((e) => e.kind === "tiles" && e.name === "collision") ? "collision" : { property: "solid" }), o = i.width * i.height, r = new Uint8Array(o);
+  if (typeof l == "string") {
+    const e = i.layers.find((t) => t.kind === "tiles" && t.name === l);
+    if (!e || e.kind !== "tiles") throw new Error(`Tiled map: no tile layer named "${l}"`);
+    for (let t = 0; t < o; t++) h(e.data[t]) !== 0 && (r[t] = 1);
+  } else
+    for (const e of i.layers)
+      if (e.kind === "tiles")
+        for (let t = 0; t < o; t++) {
+          const n = y(i, e.data[t]);
+          n && n.tileset.tileProperties.get(n.local)?.[l.property] === !0 && (r[t] = 1);
+        }
+  let d = "";
+  for (let e = 0; e < o; e++) d += r[e] ? "1" : "0";
+  const { solid: g, ...f } = s;
+  return c(i.width, i.height, i.tileWidth, d, f);
+}
+export {
+  w as collisionFromTiled
+};

package/dist/tilemap/tiled.js

@@ -0,0 +1,137 @@
+const b = 2147483648, w = 1073741824, A = 536870912;
+const g = (e) => e & 536870911;
+function j(e, t) {
+  const i = g(t);
+  if (i === 0) return null;
+  let n = null;
+  for (const r of e.tilesets) r.firstGid <= i && (!n || r.firstGid > n.firstGid) && (n = r);
+  return !n || i - n.firstGid >= n.tileCount ? null : { tileset: n, local: i - n.firstGid };
+}
+function x(e, t) {
+  const i = t % e.columns, n = Math.floor(t / e.columns);
+  return { x: e.margin + i * (e.tileWidth + e.spacing), y: e.margin + n * (e.tileHeight + e.spacing), w: e.tileWidth, h: e.tileHeight };
+}
+function $(e, t) {
+  return e.layers.find((i) => i.name === t);
+}
+function N(e, t) {
+  const i = [];
+  for (const n of e.layers) if (n.kind === "objects")
+    for (const r of n.objects) (t === void 0 || r.type === t) && i.push(r);
+  return i;
+}
+class a extends Error {
+  constructor(t) {
+    super(`Tiled map: ${t}`);
+  }
+}
+function l(e) {
+  const t = {};
+  if (!Array.isArray(e)) return t;
+  for (const i of e) i && typeof i.name == "string" && ["string", "number", "boolean"].includes(typeof i.value) && (t[i.name] = i.value);
+  return t;
+}
+function o(e, t) {
+  if (typeof e != "number" || !Number.isFinite(e)) throw new a(`${t} must be a number`);
+  return e;
+}
+function d(e) {
+  if (typeof atob == "function") {
+    const t = atob(e.trim()), i = new Uint8Array(t.length);
+    for (let n = 0; n < t.length; n++) i[n] = t.charCodeAt(n);
+    return i;
+  }
+  return new Uint8Array(globalThis.Buffer.from(e, "base64"));
+}
+function h(e, t) {
+  if (e.compression) throw new a(`layer "${e.name}" is ${e.compression}-compressed; save it as CSV or uncompressed base64`);
+  let i;
+  if (e.encoding === "base64") {
+    const n = d(String(e.data));
+    if (n.length !== t * 4) throw new a(`layer "${e.name}" holds ${n.length / 4} cells, not ${t}`);
+    const r = new DataView(n.buffer, n.byteOffset, n.byteLength);
+    i = new Uint32Array(t);
+    for (let s = 0; s < t; s++) i[s] = r.getUint32(s * 4, !0);
+  } else {
+    if (!Array.isArray(e.data) || e.data.length !== t) throw new a(`layer "${e.name}" must hold ${t} cells`);
+    i = Uint32Array.from(e.data);
+  }
+  return i;
+}
+function m(e) {
+  const t = {
+    id: o(e.id, "object id"),
+    name: String(e.name ?? ""),
+    type: String(e.type ?? e.class ?? ""),
+    x: o(e.x, "object x"),
+    y: o(e.y, "object y"),
+    width: Number(e.width ?? 0),
+    height: Number(e.height ?? 0),
+    rotation: Number(e.rotation ?? 0),
+    point: e.point === !0,
+    ellipse: e.ellipse === !0,
+    properties: l(e.properties)
+  };
+  return typeof e.gid == "number" && (t.gid = e.gid), Array.isArray(e.polygon) && (t.polygon = e.polygon.map((i) => ({ x: o(i.x, "polygon x"), y: o(i.y, "polygon y") }))), t;
+}
+function u(e, t, i, n = { visible: !0, opacity: 1, x: 0, y: 0 }) {
+  if (Array.isArray(e))
+    for (const r of e) {
+      const s = n.visible && r.visible !== !1, c = n.opacity * (typeof r.opacity == "number" ? r.opacity : 1), f = n.x + Number(r.offsetx ?? 0), p = n.y + Number(r.offsety ?? 0);
+      r.type === "tilelayer" ? i.push({ kind: "tiles", name: String(r.name ?? ""), data: h(r, t.width * t.height), visible: s, opacity: c, offsetX: f, offsetY: p, properties: l(r.properties) }) : r.type === "objectgroup" ? i.push({ kind: "objects", name: String(r.name ?? ""), objects: (r.objects ?? []).map(m), visible: s, properties: l(r.properties) }) : r.type === "group" && u(r.layers, t, i, { visible: s, opacity: c, x: f, y: p });
+    }
+}
+function y(e) {
+  if (typeof e.source == "string") throw new a(`tileset "${e.source}" is external; embed it in the map (Map → Embed Tilesets)`);
+  if (typeof e.image != "string") throw new a(`tileset "${e.name}" is a collection of images; use a single-image tileset`);
+  const t = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+  for (const n of e.tiles ?? []) {
+    const r = o(n.id, "tile id");
+    n.properties && t.set(r, l(n.properties)), Array.isArray(n.animation) && i.set(r, n.animation.map((s) => ({ tileId: o(s.tileid, "animation tileid"), duration: o(s.duration, "animation duration") })));
+  }
+  return {
+    name: String(e.name ?? ""),
+    firstGid: o(e.firstgid, "tileset firstgid"),
+    image: e.image,
+    imageWidth: o(e.imagewidth, "tileset imagewidth"),
+    imageHeight: o(e.imageheight, "tileset imageheight"),
+    tileWidth: o(e.tilewidth, "tileset tilewidth"),
+    tileHeight: o(e.tileheight, "tileset tileheight"),
+    columns: o(e.columns, "tileset columns"),
+    tileCount: o(e.tilecount, "tileset tilecount"),
+    margin: Number(e.margin ?? 0),
+    spacing: Number(e.spacing ?? 0),
+    tileProperties: t,
+    animations: i,
+    properties: l(e.properties)
+  };
+}
+function S(e) {
+  const t = e;
+  if (!t || typeof t != "object") throw new a("not a JSON object");
+  if (t.infinite) throw new a("infinite maps are not supported; uncheck Map → Map Properties → Infinite");
+  if (t.orientation && t.orientation !== "orthogonal") throw new a(`${t.orientation} maps are not supported, only orthogonal`);
+  const i = o(t.width, "width"), n = o(t.height, "height"), r = [];
+  u(t.layers, { width: i, height: n }, r);
+  const s = {
+    width: i,
+    height: n,
+    tileWidth: o(t.tilewidth, "tilewidth"),
+    tileHeight: o(t.tileheight, "tileheight"),
+    layers: r,
+    tilesets: (t.tilesets ?? []).map(y),
+    properties: l(t.properties)
+  };
+  return typeof t.backgroundcolor == "string" && (s.backgroundColor = t.backgroundcolor), s;
+}
+export {
+  A as FLIP_D,
+  b as FLIP_H,
+  w as FLIP_V,
+  g as gidOf,
+  $ as layerByName,
+  N as objectsOf,
+  S as parseTiled,
+  j as tileAt,
+  x as tileRect
+};

package/dist/transitions/CrossfadeTransition.js

@@ -0,0 +1,23 @@
+import { RenderTexture as s, Sprite as i } from "pixi.js";
+import { tweenDone as n } from "./tweenDone.js";
+class h {
+  constructor(t = {}) {
+    this.options = t;
+  }
+  options;
+  still = null;
+  texture = null;
+  async cover(t) {
+    const { app: e } = t, r = s.create({ width: e.screen.width, height: e.screen.height, resolution: e.renderer.resolution });
+    e.renderer.render({ container: e.stage, target: r }), this.texture = r, this.still = new i(r), t.layer.addChild(this.still);
+  }
+  async reveal(t) {
+    this.still && await n(t.stage, { targets: this.still, alpha: 0, duration: this.options.duration ?? 400, ease: "Sine.InOut" });
+  }
+  dispose() {
+    this.still?.destroy(), this.still = null, this.texture?.destroy(!0), this.texture = null;
+  }
+}
+export {
+  h as CrossfadeTransition
+};

package/dist/transitions/DitherWipeTransition.js

@@ -0,0 +1,69 @@
+import { Container as b, TilingSprite as y, Texture as z, CanvasSource as C } from "pixi.js";
+import { DITHER_LEVELS as g, wipeLevel as M, ditherCovered as R } from "./ditherMask.js";
+import { tweenDone as S } from "./tweenDone.js";
+let d = null;
+function f() {
+  if (d) return d;
+  d = [];
+  for (let u = 0; u <= g; u++) {
+    const t = document.createElement("canvas");
+    t.width = 4, t.height = 4;
+    const n = t.getContext("2d");
+    n.fillStyle = "#ffffff";
+    for (let o = 0; o < 4; o++) for (let e = 0; e < 4; e++) R(u, e, o) && n.fillRect(e, o, 1, 1);
+    d.push(new z({ source: new C({ resource: t, scaleMode: "nearest" }) }));
+  }
+  return d;
+}
+class L {
+  constructor(t = {}) {
+    this.options = t;
+  }
+  options;
+  bands = [];
+  root = null;
+  stopResize = null;
+  state = { p: 0 };
+  reversed = !1;
+  async cover(t) {
+    this.root = new b(), t.layer.addChild(this.root), this.layout(t), this.stopResize = t.stage.onResize(() => this.layout(t)), this.state.p = 0, this.reversed = !1, await this.run(t, 1);
+  }
+  async reveal(t) {
+    this.root && (this.reversed = !0, await this.run(t, 0));
+  }
+  dispose() {
+    this.stopResize?.(), this.stopResize = null, this.root?.destroy({ children: !0 }), this.root = null, this.bands.length = 0;
+  }
+  run(t, n) {
+    return S(t.stage, {
+      targets: this.state,
+      p: n,
+      duration: this.options.duration ?? 450,
+      ease: "Linear",
+      onUpdate: () => this.paint()
+    });
+  }
+  layout(t) {
+    const n = this.root;
+    for (const h of n.removeChildren()) h.destroy();
+    this.bands.length = 0;
+    const o = Math.max(1, Math.round(this.options.cell ?? t.stage.cameras.main.zoom)), e = o * 4, r = t.stage.width, i = t.stage.height, s = this.options.direction ?? "right", a = s === "left" || s === "right", p = s === "none" ? 0 : a ? r : i, c = s === "none" ? 0 : Math.max(e, Math.ceil(p / 32 / e) * e), v = s === "none" ? 1 : Math.ceil(p / c);
+    for (let h = 0; h < v; h++) {
+      const m = s === "none" || !a ? r : c, w = s === "none" || a ? i : c, l = new y({ texture: f()[0], width: m, height: w });
+      l.tileScale.set(o, o), s !== "none" && (a ? l.x = h * c : l.y = h * c), l.tint = this.options.color ?? 0, n.addChild(l), this.bands.push(l);
+    }
+    this.paint();
+  }
+  paint() {
+    const t = this.options.direction ?? "right", n = t === "none" ? 1 : this.options.softness ?? 0.35, o = f(), e = this.bands.length;
+    for (let r = 0; r < e; r++) {
+      let i = t === "none" ? 0.5 : (r + 0.5) / e;
+      (t === "left" || t === "up") && (i = 1 - i), this.reversed && (i = 1 - i);
+      const s = t === "none" ? Math.round(this.state.p * g) : M(this.state.p, i, n), a = this.bands[r];
+      a.visible = s > 0, a.texture = o[s];
+    }
+  }
+}
+export {
+  L as DitherWipeTransition
+};

package/dist/transitions/FadeTransition.js

@@ -0,0 +1,33 @@
+import { Sprite as o, Texture as a } from "pixi.js";
+import { tweenDone as i } from "./tweenDone.js";
+class l {
+  constructor(t = {}) {
+    this.options = t;
+  }
+  options;
+  sheet = null;
+  stopResize = null;
+  async cover(t) {
+    const e = new o(a.WHITE);
+    e.tint = this.options.color ?? 0, e.alpha = 0, this.sheet = e, t.layer.addChild(e);
+    const s = () => {
+      e.width = t.stage.width, e.height = t.stage.height;
+    };
+    s(), this.stopResize = t.stage.onResize(s), await i(t.stage, { targets: e, alpha: 1, duration: this.options.duration ?? 300, ease: "Sine.InOut" });
+  }
+  async reveal(t) {
+    this.sheet && await i(t.stage, {
+      targets: this.sheet,
+      alpha: 0,
+      delay: this.options.hold ?? 0,
+      duration: this.options.duration ?? 300,
+      ease: "Sine.InOut"
+    });
+  }
+  dispose() {
+    this.stopResize?.(), this.stopResize = null, this.sheet?.destroy(), this.sheet = null;
+  }
+}
+export {
+  l as FadeTransition
+};

package/dist/transitions/Letterbox.js

@@ -0,0 +1,41 @@
+import { Container as h, Sprite as i, Texture as o } from "pixi.js";
+import { tweenDone as r } from "./tweenDone.js";
+class l {
+  constructor(t, s = {}) {
+    this.stage = t, this.options = s;
+    for (const e of [this.top, this.bottom]) e.tint = s.color ?? 0;
+    this.view.addChild(this.top, this.bottom), this.view.visible = !1, t.screen.addChild(this.view), this.stopResize = t.onResize(() => this.layout()), this.layout();
+  }
+  stage;
+  options;
+  view = new h();
+  top = new i(o.WHITE);
+  bottom = new i(o.WHITE);
+  /** 0 hidden, 1 fully in. */
+  state = { k: 0 };
+  stopResize;
+  /** Whether the bars are (partly) in. */
+  get shown() {
+    return this.state.k > 0;
+  }
+  /** Slides the bars in over `ms` (0: at once). */
+  show(t = 400) {
+    return this.to(1, t);
+  }
+  hide(t = 400) {
+    return this.to(0, t);
+  }
+  destroy() {
+    this.stage.tweens.killTweensOf(this.state), this.stopResize(), this.view.destroy({ children: !0 });
+  }
+  to(t, s) {
+    return this.stage.tweens.killTweensOf(this.state), s <= 0 ? (this.state.k = t, this.layout(), Promise.resolve()) : r(this.stage, { targets: this.state, k: t, duration: s, ease: "Sine.InOut", onUpdate: () => this.layout() });
+  }
+  layout() {
+    const t = this.stage.width, s = this.stage.height, e = Math.round(s * (this.options.share ?? 0.12) * this.state.k);
+    this.view.visible = e > 0, this.top.width = t, this.top.height = e, this.bottom.width = t, this.bottom.height = e, this.bottom.y = s - e;
+  }
+}
+export {
+  l as Letterbox
+};

package/dist/transitions/ditherMask.js

@@ -0,0 +1,14 @@
+const s = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5], f = 16;
+function a(t, n, o) {
+  return s[(o & 3) * 4 + (n & 3)] < t;
+}
+function i(t, n, o) {
+  const r = Math.max(1e-3, o), e = (t * (1 + r) - n) / r, c = e <= 0 ? 0 : e >= 1 ? 1 : e;
+  return Math.round(c * f);
+}
+export {
+  s as BAYER4,
+  f as DITHER_LEVELS,
+  a as ditherCovered,
+  i as wipeLevel
+};

package/dist/transitions/transitionTo.js

@@ -0,0 +1,27 @@
+import { Container as l } from "pixi.js";
+const c = /* @__PURE__ */ new WeakMap();
+function f(t, a, e, s = "replace") {
+  const o = (c.get(t) ?? Promise.resolve()).then(() => i(t, a, e, s)), p = o.catch(() => {
+  });
+  return c.set(t, p), p.then(() => {
+    c.get(t) === p && c.delete(t);
+  }), o;
+}
+async function i(t, a, e, s) {
+  const r = new l();
+  t.app.stage.addChild(r);
+  const o = { stage: t.stage, app: t.app, layer: r };
+  try {
+    if (await e.cover(o), s === "pop") await t.scenes.pop();
+    else {
+      if (!a) throw new Error(`transitionTo: '${s}' needs a scene`);
+      await (s === "push" ? t.scenes.push(a) : t.scenes.replace(a));
+    }
+    await e.reveal(o);
+  } finally {
+    e.dispose(), r.destroy({ children: !0 });
+  }
+}
+export {
+  f as transitionTo
+};

package/dist/transitions/tweenDone.js

@@ -0,0 +1,14 @@
+function r(n, e) {
+  return new Promise((o) => {
+    const t = e.onComplete;
+    n.tweens.add({
+      ...e,
+      onComplete: () => {
+        t?.(), o();
+      }
+    });
+  });
+}
+export {
+  r as tweenDone
+};