1681-engine 0.0.0-stage → 0.5.9

package/dist/core/Pointer.js

@@ -0,0 +1,80 @@
+import { isTouchUi as v } from "../platform/touch.js";
+import { isPointerLocked as m, requestPointerLock as d, exitPointerLock as a } from "../platform/pointerLock.js";
+function s(e) {
+  return e === 1 ? 4 : e === 2 ? 2 : e === 0 ? 1 : 0;
+}
+class c {
+  constructor(o) {
+    this.canvas = o;
+    const i = v(), n = (t, u, l) => {
+      const h = (r) => {
+        i && r instanceof PointerEvent && r.pointerType === "touch" || l(r);
+      };
+      t.addEventListener(u, h), this.cleanup.push(() => t.removeEventListener(u, h));
+    };
+    n(o, "pointerdown", (t) => {
+      this.track(t), !c.ignorePress?.(t) && (this.buttons |= s(t.button));
+    }), n(window, "pointermove", (t) => {
+      this.locked ? (this.moveX += t.movementX, this.moveY += t.movementY) : this.track(t), t.button >= 0 && (this.buttons = (t.buttons & s(t.button)) !== 0 ? this.buttons | s(t.button) : this.buttons & ~s(t.button));
+    }), n(window, "pointerup", (t) => {
+      this.buttons &= ~s(t.button);
+    }), n(window, "blur", () => {
+      this.buttons = 0;
+    }), n(o, "contextmenu", (t) => t.preventDefault());
+  }
+  canvas;
+  /**
+   * A press this returns true for is not counted as a held button (e.g. Shift + right-click opening a context menu
+   * instead of firing what the right button is bound to). Unset, every press counts.
+   */
+  static ignorePress = null;
+  /** Screen position relative to the canvas, in CSS pixels. */
+  x = 0;
+  y = 0;
+  worldX = 0;
+  worldY = 0;
+  buttons = 0;
+  /** Raw mouse travel (`movementX/Y`) summed since the last `takeMovement`, kept only while the pointer is locked. */
+  moveX = 0;
+  moveY = 0;
+  cleanup = [];
+  leftButtonDown() {
+    return (this.buttons & 1) !== 0;
+  }
+  rightButtonDown() {
+    return (this.buttons & 2) !== 0;
+  }
+  /** True while the canvas holds the pointer (`lock`). */
+  get locked() {
+    return m(this.canvas);
+  }
+  /**
+   * Locks the pointer to the canvas for mouse-look: the cursor hides and `takeMovement` returns how far the mouse went.
+   * Call from a press or key handler (browsers allow it only in a gesture); resolves whether the lock holds.
+   */
+  lock(o = {}) {
+    return this.moveX = this.moveY = 0, d(this.canvas, o);
+  }
+  unlock() {
+    this.locked && a();
+  }
+  /** The mouse travel (CSS pixels) since the last call while locked, then zeroed; read it once per step. */
+  takeMovement() {
+    const o = { x: this.moveX, y: this.moveY };
+    return this.moveX = this.moveY = 0, o;
+  }
+  updateWorldPoint(o) {
+    this.worldX = o.scrollX + this.x / o.zoom, this.worldY = o.scrollY + this.y / o.zoom;
+  }
+  destroy() {
+    for (const o of this.cleanup) o();
+    this.cleanup.length = 0;
+  }
+  track(o) {
+    const i = this.canvas.getBoundingClientRect();
+    this.x = o.clientX - i.left, this.y = o.clientY - i.top;
+  }
+}
+export {
+  c as Pointer
+};

package/dist/core/Rectangle.js

@@ -0,0 +1,50 @@
+import { Graphics as s, Container as e } from "pixi.js";
+import { GameObject as l } from "./gameObject.js";
+class c extends l(e) {
+  constructor(t, i, r, h = 1) {
+    super(), this.w = t, this.h = i, this.color = r, this.fillAlpha = h, this.addChild(this.g), this.redraw();
+  }
+  w;
+  h;
+  color;
+  fillAlpha;
+  g = new s();
+  ox = 0.5;
+  oy = 0.5;
+  get originX() {
+    return this.ox;
+  }
+  get originY() {
+    return this.oy;
+  }
+  get rectWidth() {
+    return this.w;
+  }
+  get rectHeight() {
+    return this.h;
+  }
+  get fillColor() {
+    return this.color;
+  }
+  get fillOpacity() {
+    return this.fillAlpha;
+  }
+  setOrigin(t = 0.5, i = t) {
+    return this.ox = t, this.oy = i, this.redraw();
+  }
+  setFillStyle(t, i = 1) {
+    return this.color = t, this.fillAlpha = i, this.redraw();
+  }
+  setDisplaySize(t, i) {
+    return this.setScale(t / this.w, i / this.h);
+  }
+  resize(t, i) {
+    return this.w = t, this.h = i, this.redraw();
+  }
+  redraw() {
+    return this.g.clear().rect(-this.w * this.ox, -this.h * this.oy, this.w, this.h).fill({ color: this.color, alpha: this.fillAlpha }), this;
+  }
+}
+export {
+  c as Rectangle
+};

package/dist/core/Stage.js

@@ -0,0 +1,85 @@
+import { Container as r } from "pixi.js";
+import { Camera as n } from "./Camera.js";
+import { Clock as a } from "./Clock.js";
+import { ObjectFactory as o } from "./ObjectFactory.js";
+import { Pointer as c } from "./Pointer.js";
+import { Tweener as d } from "./Tweener.js";
+class h {
+  constructor(e, t) {
+    this.app = e, this.textures = t, e.stage.addChild(this.world, this.screen), this.cameras = { main: new n(this.world, this.screen) }, this.input = { activePointer: new c(e.canvas) }, this.time.onError = (i) => this.caught("timers", i), this.syncSize();
+  }
+  app;
+  textures;
+  /** Told of every fault a guarded step caught (error telemetry, if the game sets one). */
+  static onCaught = null;
+  world = new r({ sortableChildren: !0 });
+  screen = new r();
+  add = new o(this);
+  tweens = new d();
+  time = new a();
+  cameras;
+  input;
+  resizeListeners = [];
+  lastWidth = 0;
+  lastHeight = 0;
+  get width() {
+    return this.app.screen.width;
+  }
+  get height() {
+    return this.app.screen.height;
+  }
+  get fps() {
+    return this.app.ticker.FPS;
+  }
+  /** Calls `fn` whenever the window changes size; the returned function stops it (a per-map listener must). */
+  onResize(e) {
+    return this.resizeListeners.push(e), () => {
+      const t = this.resizeListeners.indexOf(e);
+      t >= 0 && this.resizeListeners.splice(t, 1);
+    };
+  }
+  /**
+   * One frame: game logic, then tweens and timers, then the camera. Pixi renders after. Each step is guarded: a
+   * ticker listener that throws never asks for the next animation frame, so one bad frame used to stop the world for
+   * good — the canvas frozen and no input reaching the server (seen on Android).
+   */
+  frame(e) {
+    const t = performance.now();
+    this.guard("resize", () => this.syncSize()), this.guard("update", () => this.update(t, e)), this.guard("tweens", () => this.tweens.update(e)), this.guard("timers", () => this.time.update(t)), this.guard("camera", () => this.cameras.main.apply(t));
+  }
+  reported = /* @__PURE__ */ new Set();
+  /**
+   * Runs one step of a frame and swallows what it throws, so the steps after it still run. Subclasses guard the parts
+   * of their own `update` too: a fault before the camera follows the player used to leave the view standing on one
+   * spot while the world went on.
+   */
+  guard(e, t) {
+    this.guarded(e, t, void 0);
+  }
+  /** `guard` for a step that answers something: `fallback` when it threw. */
+  guarded(e, t, i) {
+    try {
+      return t();
+    } catch (s) {
+      return this.caught(e, s), i;
+    }
+  }
+  /** What a guarded step threw: logged once per distinct error, or a fault repeating every frame floods the log at 60 a second. */
+  caught(e, t) {
+    const i = `${e}|${t instanceof Error ? t.message : String(t)}`;
+    this.reported.has(i) || (this.reported.add(i), console.error(`[frame] ${e} failed`, t), h.onCaught?.(`[frame] ${e}`, t));
+  }
+  destroy() {
+    this.tweens.clear(), this.time.clear(), this.input.activePointer.destroy(), this.world.destroy({ children: !0, context: !0 }), this.screen.destroy({ children: !0, context: !0 });
+  }
+  syncSize() {
+    const { width: e, height: t } = this.app.screen, i = this.cameras.main;
+    if (i.width = e, i.height = t, !(e === this.lastWidth && t === this.lastHeight)) {
+      this.lastWidth = e, this.lastHeight = t;
+      for (const s of [...this.resizeListeners]) s();
+    }
+  }
+}
+export {
+  h as Stage
+};

package/dist/core/Text.js

@@ -0,0 +1,21 @@
+import { Text as e } from "pixi.js";
+import { GameObject as f } from "./gameObject.js";
+class d extends f(e) {
+  constructor(o, t, n, i) {
+    const r = {
+      fontFamily: i.fontFamily ?? "monospace",
+      fontSize: typeof i.fontSize == "string" ? parseFloat(i.fontSize) : i.fontSize,
+      fill: i.color ?? "#ffffff"
+    };
+    i.stroke && (r.stroke = { color: i.stroke, width: i.strokeThickness ?? 1, join: "round" }), i.align && (r.align = i.align), i.lineSpacing !== void 0 && (r.leading = i.lineSpacing), i.wordWrapWidth !== void 0 && (r.wordWrap = !0, r.wordWrapWidth = i.wordWrapWidth), super({ text: n, resolution: i.resolution ?? 1, style: r }), this.position.set(o, t);
+  }
+  setOrigin(o = 0.5, t = o) {
+    return this.anchor.set(o, t), this;
+  }
+  setText(o) {
+    return this.text = o, this;
+  }
+}
+export {
+  d as Text
+};

package/dist/core/TextureRegistry.js

@@ -0,0 +1,141 @@
+import { CanvasSource as f, Texture as d, Rectangle as u } from "pixi.js";
+class v {
+  constructor(t, s) {
+    this.key = t, this.canvas = s, this.source = new f({ resource: s, scaleMode: "nearest" }), this.whole = new d({ source: this.source });
+  }
+  key;
+  canvas;
+  frames = /* @__PURE__ */ new Map();
+  source;
+  whole;
+  get width() {
+    return this.canvas.width;
+  }
+  get height() {
+    return this.canvas.height;
+  }
+  get context() {
+    return this.canvas.getContext("2d");
+  }
+  /** Adds a frame cut from the canvas (`_source` kept for the old call shape). */
+  add(t, s, e, a, n, i) {
+    this.frames.get(t)?.destroy(), this.frames.set(t, new d({ source: this.source, frame: new u(e, a, n, i) }));
+  }
+  /**
+   * Adds a packed frame cut from `page` (this texture's canvas by default): trimmed frames keep their untrimmed size
+   * (`orig`) so they line up when drawn, and frames the packer turned are turned back (Pixi's `rotate: 2`).
+   */
+  addPacked(t, s = this) {
+    this.frames.get(t.name)?.destroy();
+    const e = new d({
+      source: s.source,
+      frame: new u(t.x, t.y, t.w, t.h),
+      orig: new u(0, 0, t.sourceW, t.sourceH),
+      ...t.trim ? { trim: new u(t.trim.x, t.trim.y, t.trim.w, t.trim.h) } : {},
+      rotate: t.rotated ? 2 : 0,
+      ...t.anchor ? { defaultAnchor: t.anchor } : {}
+    });
+    this.frames.set(t.name, e);
+  }
+  /**
+   * Registers under this texture a frame that lives on another one (an atlas page after the first), so the frame is
+   * found by this texture's key. A texture of its own over the other page's source: each side frees its own.
+   */
+  adopt(t, s) {
+    const e = s.frames.get(t);
+    e && (this.frames.get(t)?.destroy(), this.frames.set(t, new d({ source: s.source, frame: e.frame.clone() })));
+  }
+  refresh() {
+    this.source.update();
+  }
+  destroy() {
+    for (const t of this.frames.values()) t.destroy();
+    this.frames.clear(), this.whole.destroy(), this.source.destroy();
+  }
+}
+class m {
+  textures = /* @__PURE__ */ new Map();
+  /** Textures repainted or freed while in use (a rig body, its hand): a copy of one must snapshot it first. */
+  live = /* @__PURE__ */ new Set();
+  missing = /* @__PURE__ */ new Set();
+  snapshots = 0;
+  markLive(t) {
+    this.live.add(t);
+  }
+  isLive(t) {
+    return this.live.has(t);
+  }
+  /** A new texture holding frame `frame` of `key` as it is painted right now; returns its key (one frame, '0'). */
+  snapshot(t, s) {
+    const e = this.get(t, s), { x: a, y: n, width: i, height: r } = e.frame, h = document.createElement("canvas");
+    h.width = i, h.height = r;
+    const o = this.textures.get(t)?.canvas;
+    o && h.getContext("2d").drawImage(o, a, n, i, r, 0, 0, i, r);
+    const c = `${t}#still${++this.snapshots}`;
+    return this.addCanvas(c, h).add("0", 0, 0, 0, i, r), c;
+  }
+  /**
+   * `snapshot` into a texture kept for reuse (`into`): its canvas is repainted in place and uploaded again, and only
+   * made anew when the frame's size changes. Frame '0' is the copy.
+   */
+  snapshotInto(t, s, e) {
+    const a = this.get(t, s), { x: n, y: i, width: r, height: h } = a.frame;
+    let o = this.textures.get(e);
+    if (!o || o.width !== r || o.height !== h) {
+      const g = document.createElement("canvas");
+      g.width = r, g.height = h, o = this.addCanvas(e, g), o.add("0", 0, 0, 0, r, h);
+    }
+    const c = o.context;
+    c.clearRect(0, 0, r, h);
+    const w = this.textures.get(t)?.canvas;
+    w && c.drawImage(w, n, i, r, h, 0, 0, r, h), o.refresh();
+  }
+  exists(t) {
+    return this.textures.has(t);
+  }
+  addCanvas(t, s) {
+    this.remove(t);
+    const e = new v(t, s);
+    return this.textures.set(t, e), e;
+  }
+  /** A canvas cut into equal frames named 0, 1, 2... left to right, then row by row. */
+  addSpriteSheet(t, s, e) {
+    const a = this.addCanvas(t, s), n = Math.floor(s.width / e.frameWidth), i = Math.floor(s.height / e.frameHeight);
+    for (let r = 0; r < n * i; r++)
+      a.add(String(r), 0, r % n * e.frameWidth, Math.floor(r / n) * e.frameHeight, e.frameWidth, e.frameHeight);
+    return a;
+  }
+  /**
+   * A packed atlas (TexturePacker JSON, `AssetLoader.atlas`): the first page under `key`, the others as `key~1`,
+   * `key~2`… like `AtlasBuilder`'s pages, and every frame of every page found under `key` by its name.
+   */
+  addAtlas(t, s) {
+    if (s.length === 0) throw new Error(`TextureRegistry: atlas "${t}" has no pages`);
+    for (let a = 1; this.textures.has(`${t}~${a}`); a++)
+      this.remove(`${t}~${a}`);
+    const e = this.addCanvas(t, s[0].canvas);
+    return s.forEach((a, n) => {
+      const i = n === 0 ? e : this.addCanvas(`${t}~${n}`, a.canvas);
+      for (const r of a.frames)
+        i !== e && i.addPacked(r), e.addPacked(r, i);
+    }), e;
+  }
+  createCanvas(t, s, e) {
+    const a = document.createElement("canvas");
+    return a.width = s, a.height = e, this.addCanvas(t, a);
+  }
+  remove(t) {
+    this.textures.get(t)?.destroy(), this.textures.delete(t), this.live.delete(t);
+  }
+  get(t, s) {
+    const e = this.textures.get(t);
+    return e ? s === void 0 || s === "" ? e.whole : e.frames.get(String(s)) ?? this.warn(`${t}/${s}`) : this.warn(t);
+  }
+  warn(t) {
+    return this.missing.has(t) || (this.missing.add(t), console.warn(`[textures] missing ${t}`)), d.EMPTY;
+  }
+}
+export {
+  v as CanvasTexture,
+  m as TextureRegistry
+};

package/dist/core/Timeline.js

@@ -0,0 +1,210 @@
+import { TimelineBuilder as p } from "./TimelineBuilder.js";
+class c extends p {
+  timeScale;
+  repeat;
+  yoyo;
+  repeatDelay;
+  /** A timeline holds no targets of its own for `Tweener.killTweensOf`: stop it with `kill()`. */
+  targets = [];
+  options;
+  time = 0;
+  paused;
+  reversed = !1;
+  done = !1;
+  killed = !1;
+  /** In its manager's list: set again by anything that brings a finished timeline back to life. */
+  listed = !1;
+  /** The next render starts the run: a call standing at its first point fires. */
+  fresh = !0;
+  nestedIn = null;
+  resolveFinished = () => {
+  };
+  finishedPromise;
+  settled = !1;
+  /** Scratch for `locate`, so moving the playhead allocates nothing. */
+  locCycle = 0;
+  locLocal = 0;
+  constructor(t = {}) {
+    super(), this.options = t, this.repeat = t.repeat ?? 0, this.yoyo = t.yoyo ?? !1, this.repeatDelay = Math.max(0, t.repeatDelay ?? 0), this.timeScale = t.timeScale ?? 1, this.paused = t.paused ?? !1, this.finishedPromise = this.newPromise(), this.relist();
+  }
+  adopt(t) {
+    if (!(t instanceof c) || t === this || t.nestedIn) throw new Error("Timeline.add: a timeline is played by one parent at most, never itself");
+    if (!Number.isFinite(t.totalDuration)) throw new Error("Timeline.add: a timeline that repeats forever cannot be nested");
+    return t.nestedIn = this, t;
+  }
+  // ── playing ───────────────────────────────────────────────────────────────────────────────────────────────────
+  /** Every play and the delays between them, ms; Infinity when it repeats forever. */
+  get totalDuration() {
+    return this.repeat === -1 ? 1 / 0 : this.duration * (this.repeat + 1) + this.repeatDelay * this.repeat;
+  }
+  /** Where the playhead stands, ms from the start of the first play. */
+  get currentTime() {
+    return this.time;
+  }
+  /** 0–1 over the whole run (over the current play when it repeats forever). */
+  get progress() {
+    const t = this.totalDuration;
+    if (Number.isFinite(t)) return t > 0 ? this.time / t : 1;
+    const e = this.duration;
+    return e <= 0 ? 1 : (this.locate(this.time, t), this.locLocal / e);
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  get isReversed() {
+    return this.reversed;
+  }
+  /** Still has somewhere to go: not completed, not killed. */
+  get isActive() {
+    return !this.done && !this.killed;
+  }
+  /** Resolves when the timeline completes (or is killed, so nothing awaits it forever). A restart makes a new one. */
+  get finished() {
+    return this.finishedPromise;
+  }
+  /** Advances by `dt` ms (× `timeScale`): how a timeline with no manager is played. */
+  update(t) {
+    this.tick(t);
+  }
+  /** @internal The manager's step: false once there is nothing left to play. */
+  step(t) {
+    this.listed = !1;
+    const e = this.tick(t);
+    return this.listed = e, e;
+  }
+  pause() {
+    return this.paused = !0, this;
+  }
+  /** Carries on the way it was going. */
+  resume() {
+    return this.paused = !1, this.wake(), this;
+  }
+  /** Plays forward from where it stands. */
+  play() {
+    return this.reversed = !1, this.resume();
+  }
+  /** Turns round and plays toward the start (or forward again, if it was reversed). */
+  reverse() {
+    return this.reversed = !this.reversed, this.resume();
+  }
+  /**
+   * Jumps to `to` (ms or a label) and shows it there. Calls on the way are skipped unless `fireCalls`; the playing
+   * state is kept, so a paused timeline stays paused.
+   */
+  seek(t, e = !1) {
+    const s = this.totalDuration, r = typeof t == "number" ? t : this.labels.get(t);
+    if (r === void 0) throw new Error(`Timeline.seek: no label "${t}"`);
+    const i = Math.min(s, Math.max(0, r));
+    return this.render(this.time, i, e, this.fresh && e), this.time = i, this.fresh = !1, this.wake(), this;
+  }
+  /** Back to the start, playing forward, with a new `finished` if the old one was settled. */
+  restart() {
+    return this.render(this.time, 0, !1, !1), this.time = 0, this.reversed = !1, this.paused = !1, this.fresh = !0, this.settled && (this.finishedPromise = this.newPromise()), this.wake(), this;
+  }
+  /** Stops for good where it stands (nothing is put back) and settles `finished`. */
+  kill() {
+    this.killed = !0, this.settle();
+  }
+  /** @internal The manager's name for `kill` (`Tweener.clear`, a stage destroyed). */
+  remove() {
+    this.kill();
+  }
+  /** @internal Played by a parent: its own time and calls, as one span. */
+  playNested(t, e, s, r) {
+    this.render(t, e, s, r), this.time = e, this.options.onUpdate?.(this), e >= this.totalDuration && t < e && this.options.onComplete?.(this);
+  }
+  // ── inside ────────────────────────────────────────────────────────────────────────────────────────────────────
+  tick(t) {
+    if (this.killed || this.nestedIn || this.done) return !1;
+    if (this.paused) return !0;
+    const e = this.totalDuration, s = this.time, r = t * this.timeScale;
+    let i = this.reversed ? s - r : s + r;
+    return i > e && (i = e), i < 0 && (i = 0), (i !== s || this.fresh) && (this.render(s, i, !0, this.fresh), this.time = i, this.fresh = !1, this.options.onUpdate?.(this)), this.killed ? !1 : (this.reversed ? i <= 0 : i >= e) ? (this.done = !0, this.options.onComplete?.(this), this.settle(), !1) : !0;
+  }
+  /** Moves the playhead from `from` to `to` (total time), play by play. */
+  render(t, e, s, r) {
+    const i = this.duration, a = this.totalDuration, h = i + this.repeatDelay;
+    if (this.repeat === 0 || h <= 0) {
+      this.playCycle(0, Math.min(i, Math.max(0, t)), Math.min(i, Math.max(0, e)), s, r);
+      return;
+    }
+    this.locate(t, a);
+    const o = this.locCycle, d = this.locLocal;
+    this.locate(e, a);
+    const n = this.locCycle, u = this.locLocal;
+    if (o === n) {
+      this.playCycle(o, d, u, s, r);
+      return;
+    }
+    const f = !this.yoyo;
+    if (n > o) {
+      this.playCycle(o, d, i, s, r);
+      for (let l = Math.max(o + 1, n - 1); l <= n; l++) {
+        if (this.nextPlay()) return;
+        this.playCycle(l, 0, l === n ? u : i, s, f);
+      }
+    } else {
+      this.playCycle(o, d, 0, s, r);
+      for (let l = Math.min(o - 1, n + 1); l >= n; l--) {
+        if (this.nextPlay()) return;
+        this.playCycle(l, i, l === n ? u : 0, s, f);
+      }
+    }
+  }
+  /** A play boundary: `onRepeat`, and a forever timeline whose every target is gone ends here. Answers "stop". */
+  nextPlay() {
+    return this.repeat === -1 && this.orphaned() ? (this.kill(), !0) : (this.options.onRepeat?.(this), this.killed);
+  }
+  playCycle(t, e, s, r, i) {
+    if (this.yoyo && t % 2 === 1) {
+      const h = this.duration;
+      e = h - e, s = h - s;
+    }
+    const a = this.children;
+    if (s >= e) for (let h = 0; h < a.length; h++) a[h].play(e, s, r, i);
+    else for (let h = a.length - 1; h >= 0; h--) a[h].play(e, s, r, i);
+  }
+  /** Total time → play and time within it, into `locCycle` / `locLocal`. */
+  locate(t, e) {
+    const s = this.duration;
+    if (t >= e) {
+      this.locCycle = this.repeat, this.locLocal = s;
+      return;
+    }
+    const r = s + this.repeatDelay, i = Math.floor(t / r);
+    this.locCycle = i, this.locLocal = Math.min(s, t - i * r);
+  }
+  /**
+   * Every tween's every target is a destroyed display object. Checked only when a forever timeline turns round, as
+   * `Tween` drops a forever tween whose sprites were freed: otherwise it would hold them for good.
+   */
+  orphaned() {
+    let t = !1;
+    for (const e of this.children)
+      if (e.kind === "tween")
+        for (const s of e.targets) {
+          if (s.destroyed !== !0) return !1;
+          t = !0;
+        }
+    return t;
+  }
+  /** Brought back to life (reversed, sought, restarted, resumed): its manager steps it again. */
+  wake() {
+    this.killed || (this.done = !1, this.relist());
+  }
+  relist() {
+    const t = this.options.tweens;
+    !t || this.listed || this.killed || this.nestedIn || (this.listed = !0, t.run(this));
+  }
+  settle() {
+    this.settled || (this.settled = !0, this.resolveFinished());
+  }
+  newPromise() {
+    return this.settled = !1, new Promise((t) => {
+      this.resolveFinished = t;
+    });
+  }
+}
+export {
+  c as Timeline
+};

package/dist/core/TimelineBuilder.js

@@ -0,0 +1,72 @@
+import { easeByName as d } from "./eases.js";
+import { placeAt as m } from "./timelinePlace.js";
+import { TimelineChild as i } from "./TimelineChild.js";
+class x {
+  /** Sorted by start; equal starts keep the order they were added in. */
+  children = [];
+  labels = /* @__PURE__ */ new Map();
+  /** The longest child's end, kept as children are added rather than summed every frame. */
+  length = 0;
+  lastStart = 0;
+  lastEnd = 0;
+  group = null;
+  /** One play, ms (the longest child's end). */
+  get duration() {
+    return this.length;
+  }
+  /** Tweens the numeric `props` of `targets` (one object or several), after what came before unless `at` says. */
+  to(t, e, s = {}) {
+    const n = Array.isArray(t) ? [...t] : [t], a = [], l = [], h = [];
+    for (const [p, r] of Object.entries(e))
+      a.push(p), typeof r == "number" ? (l.push(r), h.push(void 0)) : (l.push(r.to), h.push(r.from));
+    const o = typeof s.ease == "function" ? s.ease : d(s.ease), u = Math.max(0, s.duration ?? 1e3), c = this.place(s.at);
+    return this.insert(new i("tween", c, u, n, a, l, h, o));
+  }
+  /** Calls `fn` when the playhead passes `at` (default: the end so far), going either way. */
+  call(t, e) {
+    return this.insert(new i("call", this.place(e), 0, [], [], [], [], null, t));
+  }
+  /** `ms` of nothing: the next child starts that much later, and a wait at the end makes the timeline longer. */
+  wait(t) {
+    return this.insert(new i("gap", this.place(void 0), Math.max(0, t)));
+  }
+  /** Names a point (default: the end so far), for positions and `seek`. */
+  label(t, e) {
+    return this.labels.set(t, this.place(e)), this;
+  }
+  /** Where a label stands, if it is set. */
+  labelTime(t) {
+    return this.labels.get(t);
+  }
+  /**
+   * Everything `build` adds starts together, at `at` (default: the end so far); a position inside is measured from
+   * the group's start. What follows the group starts at its longest child's end.
+   */
+  parallel(t, e) {
+    const s = this.group, n = this.place(e), a = { start: n, end: n };
+    this.group = a;
+    try {
+      t(this);
+    } finally {
+      this.group = s, s && (s.end = Math.max(s.end, a.end)), this.lastStart = n, this.lastEnd = a.end;
+    }
+    return this;
+  }
+  /** Plays another timeline (built, not repeating forever) as one child of this one; it is no longer stepped alone. */
+  add(t, e) {
+    const s = this.adopt(t), n = this.place(e);
+    return this.insert(new i("nested", n, s.totalDuration, [], [], [], [], null, null, s));
+  }
+  place(t) {
+    const e = this.length, s = { fallback: this.group ? this.group.start : e, end: e, lastStart: this.lastStart, lastEnd: this.lastEnd, labels: this.labels };
+    return m(t, s);
+  }
+  insert(t) {
+    let e = this.children.length;
+    for (; e > 0 && this.children[e - 1].start > t.start; ) e--;
+    return this.children.splice(e, 0, t), this.length = Math.max(this.length, t.end), this.lastStart = t.start, this.lastEnd = t.end, this.group && (this.group.end = Math.max(this.group.end, t.end)), this;
+  }
+}
+export {
+  x as TimelineBuilder
+};