1681-engine 0.0.0-stage → 0.5.8

package/dist/core/TimelineChild.js

@@ -0,0 +1,84 @@
+import { writeProp as f, readProp as u } from "./tweenProps.js";
+class m {
+  constructor(s, t, i, e = [], h = [], a = [], r = [], n = null, o = null, l = null) {
+    this.kind = s, this.start = t, this.duration = i, this.targets = e, this.props = h, this.ends = a, this.givenFrom = r, this.ease = n, this.fn = o, this.nested = l;
+  }
+  kind;
+  start;
+  duration;
+  targets;
+  props;
+  ends;
+  givenFrom;
+  ease;
+  fn;
+  nested;
+  /** Every target × prop start value, captured once (`inited`). */
+  froms = [];
+  inited = !1;
+  /** Progress (tween) or own time (nested) last written; NaN before the first, so the first always writes. */
+  last = Number.NaN;
+  get end() {
+    return this.start + this.duration;
+  }
+  /**
+   * The playhead moved from `a` to `b` (the parent's own time, either way). Calls fire when `fire` is set and their
+   * time lies in the span with its start left out and its end kept — so a call met at the end of one frame does not
+   * fire again at the start of the next — unless `includeStart` keeps the start too (a run or a repeat beginning).
+   */
+  play(s, t, i, e) {
+    switch (this.kind) {
+      case "tween":
+        this.playTween(t);
+        break;
+      case "call":
+        i && this.fn && p(s, t, this.start, e) && this.fn();
+        break;
+      case "nested":
+        this.playNested(s, t, i, e);
+        break;
+    }
+  }
+  playTween(s) {
+    if (!this.inited) {
+      if (s < this.start) return;
+      this.capture();
+    }
+    let t;
+    if (this.duration > 0 ? t = Math.min(1, Math.max(0, (s - this.start) / this.duration)) : t = s >= this.start ? 1 : 0, t === this.last) return;
+    this.last = t;
+    const i = this.ease ? this.ease(t) : t, e = this.props, h = e.length, a = this.targets;
+    for (let r = 0; r < a.length; r++) {
+      const n = a[r];
+      if (n.destroyed !== !0)
+        for (let o = 0; o < h; o++) {
+          const l = this.froms[r * h + o];
+          f(n, e[o], l + (this.ends[o] - l) * i);
+        }
+    }
+  }
+  capture() {
+    this.inited = !0;
+    const s = this.props;
+    for (const t of this.targets)
+      for (let i = 0; i < s.length; i++) this.froms.push(this.givenFrom[i] ?? u(t, s[i]));
+  }
+  playNested(s, t, i, e) {
+    const h = this.nested;
+    if (!h) return;
+    if (!this.inited) {
+      if (t < this.start) return;
+      this.inited = !0;
+    }
+    const a = h.totalDuration, r = Math.min(a, Math.max(0, s - this.start)), n = Math.min(a, Math.max(0, t - this.start)), l = t >= s ? s < this.start || s === this.start && e : s > this.end || s === this.end && e;
+    r === n && n === this.last && !l || (this.last = n, h.playNested(r, n, i, l));
+  }
+}
+function p(d, s, t, i) {
+  return t === d ? i : s >= d ? t > d && t <= s : t < d && t >= s;
+}
+export {
+  m as TimelineChild,
+  p as crossed
+};
+//# sourceMappingURL=TimelineChild.js.map

package/dist/core/TimelineChild.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimelineChild.js","sources":["../../src/core/TimelineChild.ts"],"sourcesContent":["import type { EaseFn } from './eases';\nimport type { TweenTarget } from './Tweener';\nimport { readProp, writeProp } from './tweenProps';\n\n/** What a nested timeline offers the timeline playing it. */\nexport interface NestedPlay {\n  readonly totalDuration: number;\n  /** Plays from `from` to `to` (its own time, ms); `includeStart` fires a call standing exactly at `from`. */\n  playNested(from: number, to: number, fire: boolean, includeStart: boolean): void;\n}\n\nexport type ChildKind = 'tween' | 'call' | 'gap' | 'nested';\n\n/**\n * One thing on a timeline: a tween, a call, an empty gap (`wait`) or a nested timeline, at `start` for `duration` ms.\n * A tween reads its start values the first time the playhead reaches it — not when it is added — so a tween that\n * follows another on the same property starts where that one ended, and keeps those values for seeking and reversing.\n */\nexport class TimelineChild {\n  /** Every target × prop start value, captured once (`inited`). */\n  private readonly froms: number[] = [];\n  private inited = false;\n  /** Progress (tween) or own time (nested) last written; NaN before the first, so the first always writes. */\n  private last = Number.NaN;\n\n  constructor(\n    readonly kind: ChildKind,\n    readonly start: number,\n    readonly duration: number,\n    readonly targets: readonly TweenTarget[] = [],\n    private readonly props: readonly string[] = [],\n    private readonly ends: readonly number[] = [],\n    /** A start value given as `{ from, to }`, per prop; undefined reads the target's own. */\n    private readonly givenFrom: readonly (number | undefined)[] = [],\n    private readonly ease: EaseFn | null = null,\n    private readonly fn: (() => void) | null = null,\n    private readonly nested: NestedPlay | null = null,\n  ) {}\n\n  get end(): number {\n    return this.start + this.duration;\n  }\n\n  /**\n   * The playhead moved from `a` to `b` (the parent's own time, either way). Calls fire when `fire` is set and their\n   * time lies in the span with its start left out and its end kept — so a call met at the end of one frame does not\n   * fire again at the start of the next — unless `includeStart` keeps the start too (a run or a repeat beginning).\n   */\n  play(a: number, b: number, fire: boolean, includeStart: boolean): void {\n    switch (this.kind) {\n      case 'tween':\n        this.playTween(b);\n        break;\n      case 'call':\n        if (fire && this.fn && crossed(a, b, this.start, includeStart)) this.fn();\n        break;\n      case 'nested':\n        this.playNested(a, b, fire, includeStart);\n        break;\n      case 'gap':\n        break;\n    }\n  }\n\n  private playTween(b: number): void {\n    if (!this.inited) {\n      if (b < this.start) return;\n      this.capture();\n    }\n    let p: number;\n    if (this.duration > 0) p = Math.min(1, Math.max(0, (b - this.start) / this.duration));\n    else p = b >= this.start ? 1 : 0;\n    if (p === this.last) return;\n    this.last = p;\n    const k = this.ease ? this.ease(p) : p;\n    const props = this.props;\n    const np = props.length;\n    const targets = this.targets;\n    for (let t = 0; t < targets.length; t++) {\n      const target = targets[t]!;\n      // a destroyed display object is skipped, as Tweener does: its owner freed it, nothing is left to move\n      if (target.destroyed === true) continue;\n      for (let i = 0; i < np; i++) {\n        const from = this.froms[t * np + i]!;\n        writeProp(target, props[i]!, from + (this.ends[i]! - from) * k);\n      }\n    }\n  }\n\n  private capture(): void {\n    this.inited = true;\n    const props = this.props;\n    for (const target of this.targets) {\n      for (let i = 0; i < props.length; i++) this.froms.push(this.givenFrom[i] ?? readProp(target, props[i]!));\n    }\n  }\n\n  private playNested(a: number, b: number, fire: boolean, includeStart: boolean): void {\n    const sub = this.nested;\n    if (!sub) return;\n    if (!this.inited) {\n      if (b < this.start) return;\n      this.inited = true;\n    }\n    const total = sub.totalDuration;\n    const la = Math.min(total, Math.max(0, a - this.start));\n    const lb = Math.min(total, Math.max(0, b - this.start));\n    // the nested timeline's own start point is \"crossed\" when the parent came from outside its span\n    const forward = b >= a;\n    const subInclude = forward ? a < this.start || (a === this.start && includeStart) : a > this.end || (a === this.end && includeStart);\n    if (la === lb && lb === this.last && !subInclude) return;\n    this.last = lb;\n    sub.playNested(la, lb, fire, subInclude);\n  }\n}\n\n/**\n * Whether a call at `at` lies in the span the playhead swept from `a` to `b`: the end kept, the start only when\n * `includeStart` says so.\n */\nexport function crossed(a: number, b: number, at: number, includeStart: boolean): boolean {\n  if (at === a) return includeStart;\n  return b >= a ? at > a && at <= b : at < a && at >= b;\n}\n"],"names":["TimelineChild","kind","start","duration","targets","props","ends","givenFrom","ease","fn","nested","a","b","fire","includeStart","crossed","p","k","np","t","target","i","from","writeProp","readProp","sub","total","la","lb","subInclude","at"],"mappings":"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"}

package/dist/core/Tweener.js

@@ -0,0 +1,136 @@
+import { easeByName as m } from "./eases.js";
+import { Timeline as y } from "./Timeline.js";
+import { readProp as w, writeProp as g } from "./tweenProps.js";
+const v = /* @__PURE__ */ new Set([
+  "targets",
+  "duration",
+  "delay",
+  "hold",
+  "yoyo",
+  "repeat",
+  "ease",
+  "props",
+  "onStart",
+  "onUpdate",
+  "onComplete"
+]);
+class k {
+  constructor(e, t) {
+    this.cfg = e, this.ends = t;
+    const s = e.targets;
+    this.targets = Array.isArray(s) ? s : [s];
+  }
+  cfg;
+  ends;
+  tracks = null;
+  elapsed = 0;
+  plays = 0;
+  removed = !1;
+  targets;
+  /**
+   * Every target is a destroyed display object: nothing is left to move. A forever tween (`repeat: -1`) on a sprite
+   * its owner freed used to stay in the list for good, holding the sprite, and the list grew with every map loaded.
+   * A plain object (a clock a callback reads) has no `destroyed` and is never taken for one. Only a forever tween is
+   * dropped this way: a finite one still runs out and calls its `onComplete`, which may clean up more than the sprite.
+   */
+  orphaned() {
+    if (this.cfg.repeat !== -1) return !1;
+    const e = this.targets;
+    if (e.length === 0) return !1;
+    for (const t of e) if (t.destroyed !== !0) return !1;
+    return !0;
+  }
+  remove() {
+    this.removed = !0;
+  }
+  stop() {
+    this.removed = !0;
+  }
+  /** Advances by `dt` ms; returns false once the tween is finished. */
+  step(e) {
+    if (this.removed) return !1;
+    if (this.orphaned())
+      return this.removed = !0, !1;
+    const t = this.cfg, s = t.delay ?? 0;
+    if (this.elapsed += e, this.elapsed < s) return !0;
+    if (!this.tracks) {
+      this.tracks = [];
+      for (const i of this.targets)
+        for (const [p, u] of Object.entries(this.ends)) this.tracks.push({ target: i, prop: p, from: w(i, p), to: u });
+      t.onStart?.();
+    }
+    const n = Math.max(1, t.duration ?? 1e3), a = t.yoyo ? t.hold ?? 0 : 0, o = t.yoyo ? n * 2 + a : n;
+    let r = this.elapsed - s - this.plays * o;
+    const f = t.repeat ?? 0;
+    let h = !1;
+    r >= o && (f === -1 || this.plays < f ? (this.plays++, r -= o) : (r = o, h = !0));
+    let l;
+    t.yoyo ? r <= n ? l = r / n : r <= n + a ? l = 1 : l = 1 - (r - n - a) / n : l = r / n;
+    const d = m(t.ease)(Math.min(1, Math.max(0, l)));
+    for (const i of this.tracks) i.target.destroyed || g(i.target, i.prop, i.from + (i.to - i.from) * d);
+    return t.onUpdate?.(), h ? (this.removed = !0, t.onComplete?.(), !1) : !0;
+  }
+}
+class O {
+  /** Global speed factor; hit-stop slows every tween at once. */
+  timeScale = 1;
+  tweens = [];
+  add(e) {
+    const t = { ...e.props ?? {} }, s = {};
+    for (const [o, r] of Object.entries(e))
+      if (!v.has(o)) {
+        if (typeof r == "number") t[o] = r;
+        else if (r && typeof r == "object" && "to" in r) {
+          const f = r;
+          t[o] = f.to, f.from !== void 0 && (s[o] = f.from);
+        }
+      }
+    const n = Array.isArray(e.targets) ? e.targets : [e.targets];
+    for (const o of n) for (const [r, f] of Object.entries(s)) o[r] = f;
+    const a = new k(e, t);
+    return this.tweens.push(a), a;
+  }
+  /**
+   * Steps `item` every frame from the next one on, at this manager's `timeScale`, until its `step` answers false or
+   * the manager is cleared (a stage's manager is cleared when the stage is destroyed).
+   */
+  run(e) {
+    return this.tweens.push(e), e;
+  }
+  /** A `Timeline` driven by this manager: it follows `timeScale` and stops with `clear`. */
+  timeline(e = {}) {
+    return new y({ ...e, tweens: this });
+  }
+  killTweensOf(e) {
+    const t = new Set(Array.isArray(e) ? e : [e]);
+    for (const s of this.tweens) s.targets.some((n) => t.has(n)) && s.remove();
+  }
+  update(e) {
+    const t = e * this.timeScale, s = this.tweens, n = s.length;
+    let a = 0;
+    for (let o = 0; o < n; o++) {
+      const r = s[o];
+      S(r, t) && (s[a++] = r);
+    }
+    if (this.tweens === s) {
+      for (let o = n; o < s.length; o++) s[a++] = s[o];
+      s.length = a;
+    }
+  }
+  clear() {
+    for (const e of this.tweens) e.remove();
+    this.tweens = [];
+  }
+}
+function S(c, e) {
+  try {
+    return c.step(e);
+  } catch (t) {
+    return console.error("[tween] dropped after an error", t), !1;
+  }
+}
+export {
+  k as Tween,
+  O as Tweener
+};
+//# sourceMappingURL=Tweener.js.map

package/dist/core/Tweener.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tweener.js","sources":["../../src/core/Tweener.ts"],"sourcesContent":["import { easeByName } from './eases';\nimport { Timeline, type TimelineOptions } from './Timeline';\nimport { readProp as read, writeProp as write } from './tweenProps';\n\nexport type TweenTarget = Record<string, unknown> & { destroyed?: boolean };\n\n/** Tween config in the shape the renderer has always used: numeric props at the top level or under `props`. */\nexport interface TweenConfig {\n  targets: object | object[];\n  duration?: number;\n  delay?: number;\n  /** Ms to stay at the end values before a yoyo plays back. */\n  hold?: number;\n  yoyo?: boolean;\n  /** Extra plays after the first (-1 = forever). */\n  repeat?: number;\n  ease?: string;\n  props?: Record<string, number>;\n  onStart?: () => void;\n  onUpdate?: () => void;\n  onComplete?: () => void;\n  [prop: string]: unknown;\n}\n\nconst RESERVED = new Set([\n  'targets', 'duration', 'delay', 'hold', 'yoyo', 'repeat', 'ease', 'props', 'onStart', 'onUpdate', 'onComplete',\n]);\n\ninterface Track {\n  target: TweenTarget;\n  prop: string;\n  from: number;\n  to: number;\n}\n\n/** One running tween; `remove()` stops it without calling onComplete. */\nexport class Tween {\n  private tracks: Track[] | null = null;\n  private elapsed = 0;\n  private plays = 0;\n  removed = false;\n  readonly targets: TweenTarget[];\n\n  constructor(\n    private readonly cfg: TweenConfig,\n    private readonly ends: Record<string, number>,\n  ) {\n    const t = cfg.targets;\n    this.targets = (Array.isArray(t) ? t : [t]) as TweenTarget[];\n  }\n\n  /**\n   * Every target is a destroyed display object: nothing is left to move. A forever tween (`repeat: -1`) on a sprite\n   * its owner freed used to stay in the list for good, holding the sprite, and the list grew with every map loaded.\n   * A plain object (a clock a callback reads) has no `destroyed` and is never taken for one. Only a forever tween is\n   * dropped this way: a finite one still runs out and calls its `onComplete`, which may clean up more than the sprite.\n   */\n  private orphaned(): boolean {\n    if (this.cfg.repeat !== -1) return false;\n    const ts = this.targets;\n    if (ts.length === 0) return false;\n    for (const t of ts) if (t.destroyed !== true) return false;\n    return true;\n  }\n\n  remove(): void {\n    this.removed = true;\n  }\n\n  stop(): void {\n    this.removed = true;\n  }\n\n  /** Advances by `dt` ms; returns false once the tween is finished. */\n  step(dt: number): boolean {\n    if (this.removed) return false;\n    if (this.orphaned()) {\n      this.removed = true;\n      return false;\n    }\n    const cfg = this.cfg;\n    const delay = cfg.delay ?? 0;\n    this.elapsed += dt;\n    if (this.elapsed < delay) return true;\n    if (!this.tracks) {\n      this.tracks = [];\n      for (const target of this.targets) {\n        for (const [prop, to] of Object.entries(this.ends)) this.tracks.push({ target, prop, from: read(target, prop), to });\n      }\n      cfg.onStart?.();\n    }\n    const duration = Math.max(1, cfg.duration ?? 1000);\n    const hold = cfg.yoyo ? cfg.hold ?? 0 : 0;\n    const cycle = cfg.yoyo ? duration * 2 + hold : duration;\n    let local = this.elapsed - delay - this.plays * cycle;\n    const repeat = cfg.repeat ?? 0;\n    let finished = false;\n    if (local >= cycle) {\n      if (repeat === -1 || this.plays < repeat) {\n        this.plays++;\n        local -= cycle;\n      } else {\n        local = cycle;\n        finished = true;\n      }\n    }\n    let p: number;\n    if (!cfg.yoyo) p = local / duration;\n    else if (local <= duration) p = local / duration;\n    else if (local <= duration + hold) p = 1;\n    else p = 1 - (local - duration - hold) / duration;\n    const k = easeByName(cfg.ease)(Math.min(1, Math.max(0, p)));\n    for (const t of this.tracks) if (!t.target.destroyed) write(t.target, t.prop, t.from + (t.to - t.from) * k);\n    cfg.onUpdate?.();\n    if (finished) {\n      this.removed = true;\n      cfg.onComplete?.();\n      return false;\n    }\n    return true;\n  }\n}\n\n/**\n * Anything the manager can step each frame: a `Tween`, or a `Timeline` it drives. `step` answers false once finished\n * (the manager then drops it); `remove` stops it for good; `targets` is what `killTweensOf` matches against.\n */\nexport interface Steppable {\n  step(dt: number): boolean;\n  remove(): void;\n  readonly targets: readonly object[];\n}\n\n/** Frame-driven tween manager (the renderer's replacement for Phaser's TweenManager). */\nexport class Tweener {\n  /** Global speed factor; hit-stop slows every tween at once. */\n  timeScale = 1;\n  private tweens: Steppable[] = [];\n\n  add(cfg: TweenConfig): Tween {\n    const ends: Record<string, number> = { ...(cfg.props ?? {}) };\n    const starts: Record<string, number> = {};\n    for (const [k, v] of Object.entries(cfg)) {\n      if (RESERVED.has(k)) continue;\n      if (typeof v === 'number') ends[k] = v;\n      else if (v && typeof v === 'object' && 'to' in v) {\n        const range = v as { from?: number; to: number };\n        ends[k] = range.to;\n        if (range.from !== undefined) starts[k] = range.from;\n      }\n    }\n    // `{ from, to }` jumps to `from` right away, before any delay\n    const targets = (Array.isArray(cfg.targets) ? cfg.targets : [cfg.targets]) as Record<string, unknown>[];\n    for (const t of targets) for (const [k, v] of Object.entries(starts)) t[k] = v;\n    const tween = new Tween(cfg, ends);\n    this.tweens.push(tween);\n    return tween;\n  }\n\n  /**\n   * Steps `item` every frame from the next one on, at this manager's `timeScale`, until its `step` answers false or\n   * the manager is cleared (a stage's manager is cleared when the stage is destroyed).\n   */\n  run<T extends Steppable>(item: T): T {\n    this.tweens.push(item);\n    return item;\n  }\n\n  /** A `Timeline` driven by this manager: it follows `timeScale` and stops with `clear`. */\n  timeline(options: Omit<TimelineOptions, 'tweens'> = {}): Timeline {\n    return new Timeline({ ...options, tweens: this });\n  }\n\n  killTweensOf(target: object | object[]): void {\n    const set = new Set(Array.isArray(target) ? target : [target]);\n    for (const t of this.tweens) if (t.targets.some((x) => set.has(x))) t.remove();\n  }\n\n  update(dt: number): void {\n    const scaled = dt * this.timeScale;\n    // tweens started from a callback run from the next frame on, like Phaser's\n    // compacted in place: the ones added meanwhile sit past `n` and keep their order after the survivors\n    const list = this.tweens;\n    const n = list.length;\n    let kept = 0;\n    for (let i = 0; i < n; i++) {\n      const t = list[i]!;\n      if (stepSafely(t, scaled)) list[kept++] = t;\n    }\n    // a callback that cleared the manager dropped this list, and every tween on it was removed\n    if (this.tweens !== list) return;\n    for (let i = n; i < list.length; i++) list[kept++] = list[i]!;\n    list.length = kept;\n  }\n\n  clear(): void {\n    for (const t of this.tweens) t.remove();\n    this.tweens = [];\n  }\n}\n\n/** A tween whose step or callback throws is dropped, so it neither throws every frame nor leaves the list half compacted. */\nfunction stepSafely(t: { step(dt: number): boolean }, dt: number): boolean {\n  try {\n    return t.step(dt);\n  } catch (err) {\n    console.error('[tween] dropped after an error', err);\n    return false;\n  }\n}\n"],"names":["RESERVED","Tween","cfg","ends","t","ts","dt","delay","target","prop","to","read","duration","hold","cycle","local","repeat","finished","p","k","easeByName","write","Tweener","starts","v","range","targets","tween","item","options","Timeline","set","x","scaled","list","kept","i","stepSafely","err"],"mappings":";;;AAwBA,MAAMA,wBAAe,IAAI;AAAA,EACvB;AAAA,EAAW;AAAA,EAAY;AAAA,EAAS;AAAA,EAAQ;AAAA,EAAQ;AAAA,EAAU;AAAA,EAAQ;AAAA,EAAS;AAAA,EAAW;AAAA,EAAY;AACpG,CAAC;AAUM,MAAMC,EAAM;AAAA,EAOjB,YACmBC,GACAC,GACjB;AAFiB,SAAA,MAAAD,GACA,KAAA,OAAAC;AAEjB,UAAMC,IAAIF,EAAI;AACd,SAAK,UAAW,MAAM,QAAQE,CAAC,IAAIA,IAAI,CAACA,CAAC;AAAA,EAC3C;AAAA,EALmB;AAAA,EACA;AAAA,EARX,SAAyB;AAAA,EACzB,UAAU;AAAA,EACV,QAAQ;AAAA,EAChB,UAAU;AAAA,EACD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBD,WAAoB;AAC1B,QAAI,KAAK,IAAI,WAAW,GAAI,QAAO;AACnC,UAAMC,IAAK,KAAK;AAChB,QAAIA,EAAG,WAAW,EAAG,QAAO;AAC5B,eAAW,KAAKA,EAAI,KAAI,EAAE,cAAc,GAAM,QAAO;AACrD,WAAO;AAAA,EACT;AAAA,EAEA,SAAe;AACb,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,OAAa;AACX,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA,EAGA,KAAKC,GAAqB;AACxB,QAAI,KAAK,QAAS,QAAO;AACzB,QAAI,KAAK;AACP,kBAAK,UAAU,IACR;AAET,UAAMJ,IAAM,KAAK,KACXK,IAAQL,EAAI,SAAS;AAE3B,QADA,KAAK,WAAWI,GACZ,KAAK,UAAUC,EAAO,QAAO;AACjC,QAAI,CAAC,KAAK,QAAQ;AAChB,WAAK,SAAS,CAAA;AACd,iBAAWC,KAAU,KAAK;AACxB,mBAAW,CAACC,GAAMC,CAAE,KAAK,OAAO,QAAQ,KAAK,IAAI,EAAG,MAAK,OAAO,KAAK,EAAE,QAAAF,GAAQ,MAAAC,GAAM,MAAME,EAAKH,GAAQC,CAAI,GAAG,IAAAC,GAAI;AAErH,MAAAR,EAAI,UAAA;AAAA,IACN;AACA,UAAMU,IAAW,KAAK,IAAI,GAAGV,EAAI,YAAY,GAAI,GAC3CW,IAAOX,EAAI,OAAOA,EAAI,QAAQ,IAAI,GAClCY,IAAQZ,EAAI,OAAOU,IAAW,IAAIC,IAAOD;AAC/C,QAAIG,IAAQ,KAAK,UAAUR,IAAQ,KAAK,QAAQO;AAChD,UAAME,IAASd,EAAI,UAAU;AAC7B,QAAIe,IAAW;AACf,IAAIF,KAASD,MACPE,MAAW,MAAM,KAAK,QAAQA,KAChC,KAAK,SACLD,KAASD,MAETC,IAAQD,GACRG,IAAW;AAGf,QAAIC;AACJ,IAAKhB,EAAI,OACAa,KAASH,IAAUM,IAAIH,IAAQH,IAC/BG,KAASH,IAAWC,IAAMK,IAAI,IAClCA,IAAI,KAAKH,IAAQH,IAAWC,KAAQD,IAH1BM,IAAIH,IAAQH;AAI3B,UAAMO,IAAIC,EAAWlB,EAAI,IAAI,EAAE,KAAK,IAAI,GAAG,KAAK,IAAI,GAAGgB,CAAC,CAAC,CAAC;AAC1D,eAAWd,KAAK,KAAK,QAAaA,EAAE,OAAO,aAAWiB,EAAMjB,EAAE,QAAQA,EAAE,MAAMA,EAAE,QAAQA,EAAE,KAAKA,EAAE,QAAQe,CAAC;AAE1G,WADAjB,EAAI,WAAA,GACAe,KACF,KAAK,UAAU,IACff,EAAI,aAAA,GACG,MAEF;AAAA,EACT;AACF;AAaO,MAAMoB,EAAQ;AAAA;AAAA,EAEnB,YAAY;AAAA,EACJ,SAAsB,CAAA;AAAA,EAE9B,IAAIpB,GAAyB;AAC3B,UAAMC,IAA+B,EAAE,GAAID,EAAI,SAAS,CAAA,EAAC,GACnDqB,IAAiC,CAAA;AACvC,eAAW,CAACJ,GAAGK,CAAC,KAAK,OAAO,QAAQtB,CAAG;AACrC,UAAI,CAAAF,EAAS,IAAImB,CAAC;AAClB,YAAI,OAAOK,KAAM,SAAU,CAAArB,EAAKgB,CAAC,IAAIK;AAAA,iBAC5BA,KAAK,OAAOA,KAAM,YAAY,QAAQA,GAAG;AAChD,gBAAMC,IAAQD;AACd,UAAArB,EAAKgB,CAAC,IAAIM,EAAM,IACZA,EAAM,SAAS,WAAWF,EAAOJ,CAAC,IAAIM,EAAM;AAAA,QAClD;AAAA;AAGF,UAAMC,IAAW,MAAM,QAAQxB,EAAI,OAAO,IAAIA,EAAI,UAAU,CAACA,EAAI,OAAO;AACxE,eAAWE,KAAKsB,EAAS,YAAW,CAACP,GAAGK,CAAC,KAAK,OAAO,QAAQD,CAAM,EAAG,CAAAnB,EAAEe,CAAC,IAAIK;AAC7E,UAAMG,IAAQ,IAAI1B,EAAMC,GAAKC,CAAI;AACjC,gBAAK,OAAO,KAAKwB,CAAK,GACfA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAyBC,GAAY;AACnC,gBAAK,OAAO,KAAKA,CAAI,GACdA;AAAA,EACT;AAAA;AAAA,EAGA,SAASC,IAA2C,IAAc;AAChE,WAAO,IAAIC,EAAS,EAAE,GAAGD,GAAS,QAAQ,MAAM;AAAA,EAClD;AAAA,EAEA,aAAarB,GAAiC;AAC5C,UAAMuB,IAAM,IAAI,IAAI,MAAM,QAAQvB,CAAM,IAAIA,IAAS,CAACA,CAAM,CAAC;AAC7D,eAAWJ,KAAK,KAAK,OAAQ,CAAIA,EAAE,QAAQ,KAAK,CAAC4B,MAAMD,EAAI,IAAIC,CAAC,CAAC,OAAK,OAAA;AAAA,EACxE;AAAA,EAEA,OAAO1B,GAAkB;AACvB,UAAM2B,IAAS3B,IAAK,KAAK,WAGnB4B,IAAO,KAAK,QACZ,IAAIA,EAAK;AACf,QAAIC,IAAO;AACX,aAASC,IAAI,GAAGA,IAAI,GAAGA,KAAK;AAC1B,YAAMhC,IAAI8B,EAAKE,CAAC;AAChB,MAAIC,EAAWjC,GAAG6B,CAAM,MAAGC,EAAKC,GAAM,IAAI/B;AAAA,IAC5C;AAEA,QAAI,KAAK,WAAW8B,GACpB;AAAA,eAASE,IAAI,GAAGA,IAAIF,EAAK,QAAQE,IAAK,CAAAF,EAAKC,GAAM,IAAID,EAAKE,CAAC;AAC3D,MAAAF,EAAK,SAASC;AAAA;AAAA,EAChB;AAAA,EAEA,QAAc;AACZ,eAAW/B,KAAK,KAAK,OAAQ,CAAAA,EAAE,OAAA;AAC/B,SAAK,SAAS,CAAA;AAAA,EAChB;AACF;AAGA,SAASiC,EAAWjC,GAAkCE,GAAqB;AACzE,MAAI;AACF,WAAOF,EAAE,KAAKE,CAAE;AAAA,EAClB,SAASgC,GAAK;AACZ,mBAAQ,MAAM,kCAAkCA,CAAG,GAC5C;AAAA,EACT;AACF;"}

package/dist/core/atlas.js

@@ -0,0 +1,38 @@
+import { ATLAS_PAGE_FULL as x, planAtlas as u } from "./atlasPlan.js";
+class H {
+  items = [];
+  add(n, s) {
+    this.items.push({ name: n, canvas: s });
+  }
+  addSheet(n, s, r, c) {
+    this.items.push({ name: n, canvas: s, frameWidth: r, frameHeight: c });
+  }
+  build(n, s, r = x) {
+    const c = this.items, d = u(c.map((a) => ({ w: a.canvas.width, h: a.canvas.height })), r), g = d.pages.map((a, t) => {
+      const e = document.createElement("canvas");
+      return e.width = a.width, e.height = a.height, { canvas: e, ctx: e.getContext("2d", { willReadFrequently: !0 }), key: t === 0 ? s : `${s}~${t}` };
+    });
+    c.forEach((a, t) => {
+      const e = d.places[t];
+      g[e.page].ctx.drawImage(a.canvas, e.x, e.y);
+    });
+    const i = n.addCanvas(s, g[0].canvas), p = g.map((a, t) => t === 0 ? i : n.addCanvas(a.key, a.canvas));
+    c.forEach((a, t) => {
+      const e = d.places[t], f = p[e.page], l = (o, m, h, $, w) => {
+        f.add(o, 0, m, h, $, w), e.page > 0 && i.adopt(o, f);
+      };
+      if (a.frameWidth && a.frameHeight) {
+        const o = Math.floor(a.canvas.width / a.frameWidth), m = Math.max(1, Math.floor(a.canvas.height / a.frameHeight));
+        for (let h = 0; h < o * m; h++)
+          l(`${a.name}#${h}`, e.x + h % o * a.frameWidth, e.y + Math.floor(h / o) * a.frameHeight, a.frameWidth, a.frameHeight);
+      } else
+        l(a.name, e.x, e.y, a.canvas.width, a.canvas.height);
+    });
+    const v = d.pages.map((a) => `${a.width}x${a.height}`).join(" + ");
+    console.info(`[atlas] ${s}: ${c.length} images packed into ${v}${d.pages.length > 1 ? ` (pages of ${r})` : ""}`);
+  }
+}
+export {
+  H as AtlasBuilder
+};
+//# sourceMappingURL=atlas.js.map

package/dist/core/atlas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas.js","sources":["../../src/core/atlas.ts"],"sourcesContent":["import type { TextureRegistry } from './TextureRegistry';\nimport { ATLAS_PAGE_FULL, planAtlas } from './atlasPlan';\n\ninterface AtlasItem {\n  name: string;\n  canvas: HTMLCanvasElement;\n  frameWidth?: number;\n  frameHeight?: number;\n}\n\n/**\n * Packs many small procedurally painted canvases into as few textures as the GPU allows, so Pixi can batch every\n * sprite of the world into very few draw calls. One page on every desktop (up to 8192 square); a device whose GPU\n * takes less gets pages of `limit` (`atlasPageLimit`, `planAtlas`). Every frame is registered under the one `key`\n * whichever page holds it — the pages after the first are textures of their own (`key~1`, `key~2`…) whose frames\n * the first page's texture adopts — so the world keeps asking for `atlas` and a frame name, and never knows.\n * Frame names: `name` for single images, `name#i` for sheet frames.\n */\nexport class AtlasBuilder {\n  private items: AtlasItem[] = [];\n\n  add(name: string, canvas: HTMLCanvasElement): void {\n    this.items.push({ name, canvas });\n  }\n\n  addSheet(name: string, canvas: HTMLCanvasElement, frameWidth: number, frameHeight: number): void {\n    this.items.push({ name, canvas, frameWidth, frameHeight });\n  }\n\n  build(textures: TextureRegistry, key: string, limit = ATLAS_PAGE_FULL): void {\n    const items = this.items;\n    const plan = planAtlas(items.map((it) => ({ w: it.canvas.width, h: it.canvas.height })), limit);\n    const pages = plan.pages.map((p, i) => {\n      const canvas = document.createElement('canvas');\n      canvas.width = p.width;\n      canvas.height = p.height;\n      // kept on the CPU (`willReadFrequently`): the atlas is drawn once, then read many times — the sway rigs' trunks,\n      // a death's evaporating pixels, a hit's white silhouette — and on a GPU canvas the first read pulled the whole\n      // page back, 300 ms on entering a new map (profiled)\n      return { canvas, ctx: canvas.getContext('2d', { willReadFrequently: true })!, key: i === 0 ? key : `${key}~${i}` };\n    });\n    items.forEach((it, i) => {\n      const at = plan.places[i]!;\n      pages[at.page]!.ctx.drawImage(it.canvas, at.x, at.y);\n    });\n    const first = textures.addCanvas(key, pages[0]!.canvas);\n    const texOf = pages.map((p, i) => (i === 0 ? first : textures.addCanvas(p.key, p.canvas)));\n    items.forEach((it, i) => {\n      const at = plan.places[i]!;\n      const page = texOf[at.page]!;\n      // a frame on a later page is also registered on the first, so `atlas` + its name finds it\n      const add = (name: string, x: number, y: number, w: number, h: number) => {\n        page.add(name, 0, x, y, w, h);\n        if (at.page > 0) first.adopt(name, page);\n      };\n      if (it.frameWidth && it.frameHeight) {\n        // a sheet may wrap into rows (`makeSheet`'s `maxWidth`, a very large creature's); frames are read row by row\n        const cols = Math.floor(it.canvas.width / it.frameWidth);\n        const rows = Math.max(1, Math.floor(it.canvas.height / it.frameHeight));\n        for (let f = 0; f < cols * rows; f++)\n          add(`${it.name}#${f}`, at.x + (f % cols) * it.frameWidth, at.y + Math.floor(f / cols) * it.frameHeight, it.frameWidth, it.frameHeight);\n      } else {\n        add(it.name, at.x, at.y, it.canvas.width, it.canvas.height);\n      }\n    });\n    const sizes = plan.pages.map((p) => `${p.width}x${p.height}`).join(' + ');\n    console.info(`[atlas] ${key}: ${items.length} images packed into ${sizes}${plan.pages.length > 1 ? ` (pages of ${limit})` : ''}`);\n  }\n}\n"],"names":["AtlasBuilder","name","canvas","frameWidth","frameHeight","textures","key","limit","ATLAS_PAGE_FULL","items","plan","planAtlas","it","pages","p","i","at","first","texOf","page","add","x","y","w","h","cols","rows","f","sizes"],"mappings":";AAkBO,MAAMA,EAAa;AAAA,EAChB,QAAqB,CAAA;AAAA,EAE7B,IAAIC,GAAcC,GAAiC;AACjD,SAAK,MAAM,KAAK,EAAE,MAAAD,GAAM,QAAAC,GAAQ;AAAA,EAClC;AAAA,EAEA,SAASD,GAAcC,GAA2BC,GAAoBC,GAA2B;AAC/F,SAAK,MAAM,KAAK,EAAE,MAAAH,GAAM,QAAAC,GAAQ,YAAAC,GAAY,aAAAC,GAAa;AAAA,EAC3D;AAAA,EAEA,MAAMC,GAA2BC,GAAaC,IAAQC,GAAuB;AAC3E,UAAMC,IAAQ,KAAK,OACbC,IAAOC,EAAUF,EAAM,IAAI,CAACG,OAAQ,EAAE,GAAGA,EAAG,OAAO,OAAO,GAAGA,EAAG,OAAO,OAAA,EAAS,GAAGL,CAAK,GACxFM,IAAQH,EAAK,MAAM,IAAI,CAACI,GAAGC,MAAM;AACrC,YAAMb,IAAS,SAAS,cAAc,QAAQ;AAC9C,aAAAA,EAAO,QAAQY,EAAE,OACjBZ,EAAO,SAASY,EAAE,QAIX,EAAE,QAAAZ,GAAQ,KAAKA,EAAO,WAAW,MAAM,EAAE,oBAAoB,GAAA,CAAM,GAAI,KAAKa,MAAM,IAAIT,IAAM,GAAGA,CAAG,IAAIS,CAAC,GAAA;AAAA,IAChH,CAAC;AACD,IAAAN,EAAM,QAAQ,CAACG,GAAIG,MAAM;AACvB,YAAMC,IAAKN,EAAK,OAAOK,CAAC;AACxB,MAAAF,EAAMG,EAAG,IAAI,EAAG,IAAI,UAAUJ,EAAG,QAAQI,EAAG,GAAGA,EAAG,CAAC;AAAA,IACrD,CAAC;AACD,UAAMC,IAAQZ,EAAS,UAAUC,GAAKO,EAAM,CAAC,EAAG,MAAM,GAChDK,IAAQL,EAAM,IAAI,CAACC,GAAGC,MAAOA,MAAM,IAAIE,IAAQZ,EAAS,UAAUS,EAAE,KAAKA,EAAE,MAAM,CAAE;AACzF,IAAAL,EAAM,QAAQ,CAACG,GAAIG,MAAM;AACvB,YAAMC,IAAKN,EAAK,OAAOK,CAAC,GAClBI,IAAOD,EAAMF,EAAG,IAAI,GAEpBI,IAAM,CAACnB,GAAcoB,GAAWC,GAAWC,GAAWC,MAAc;AACxE,QAAAL,EAAK,IAAIlB,GAAM,GAAGoB,GAAGC,GAAGC,GAAGC,CAAC,GACxBR,EAAG,OAAO,KAAGC,EAAM,MAAMhB,GAAMkB,CAAI;AAAA,MACzC;AACA,UAAIP,EAAG,cAAcA,EAAG,aAAa;AAEnC,cAAMa,IAAO,KAAK,MAAMb,EAAG,OAAO,QAAQA,EAAG,UAAU,GACjDc,IAAO,KAAK,IAAI,GAAG,KAAK,MAAMd,EAAG,OAAO,SAASA,EAAG,WAAW,CAAC;AACtE,iBAASe,IAAI,GAAGA,IAAIF,IAAOC,GAAMC;AAC/B,UAAAP,EAAI,GAAGR,EAAG,IAAI,IAAIe,CAAC,IAAIX,EAAG,IAAKW,IAAIF,IAAQb,EAAG,YAAYI,EAAG,IAAI,KAAK,MAAMW,IAAIF,CAAI,IAAIb,EAAG,aAAaA,EAAG,YAAYA,EAAG,WAAW;AAAA,MACzI;AACE,QAAAQ,EAAIR,EAAG,MAAMI,EAAG,GAAGA,EAAG,GAAGJ,EAAG,OAAO,OAAOA,EAAG,OAAO,MAAM;AAAA,IAE9D,CAAC;AACD,UAAMgB,IAAQlB,EAAK,MAAM,IAAI,CAACI,MAAM,GAAGA,EAAE,KAAK,IAAIA,EAAE,MAAM,EAAE,EAAE,KAAK,KAAK;AACxE,YAAQ,KAAK,WAAWR,CAAG,KAAKG,EAAM,MAAM,uBAAuBmB,CAAK,GAAGlB,EAAK,MAAM,SAAS,IAAI,cAAcH,CAAK,MAAM,EAAE,EAAE;AAAA,EAClI;AACF;"}

package/dist/core/atlasPlan.js

@@ -0,0 +1,22 @@
+const g = 2;
+const p = 8192;
+function w(t) {
+  return t === null || t >= 8192 ? 8192 : Math.min(4096, 2 ** Math.floor(Math.log2(Math.max(1, t))));
+}
+function D(t, _) {
+  const e = t.map((a, A) => A).sort((a, A) => t[A].h - t[a].h), P = t.reduce((a, A) => a + (A.w + 2) * (A.h + 2), 0), f = Math.max(1, ...t.map((a) => a.w + 2)), c = Math.min(_, Math.max(1024, 2 ** Math.ceil(Math.log2(Math.max(f, Math.sqrt(P)))))), l = new Array(t.length), M = [];
+  let r = 0, n = 0, h = 0, o = 0, L = c;
+  const S = () => M.push({ width: L, height: h + o });
+  for (const a of e) {
+    const A = t[a].w + 2, T = t[a].h + 2;
+    n > 0 && n + A > L && (n = 0, h += o, o = 0), h > 0 && h + T > _ && (S(), r++, n = 0, h = 0, o = 0, L = c), A > L && (L = A), l[a] = { page: r, x: n, y: h }, n += A, o = Math.max(o, T);
+  }
+  return t.length > 0 && S(), { pages: M, places: l };
+}
+export {
+  g as ATLAS_PAD,
+  p as ATLAS_PAGE_FULL,
+  w as atlasPageLimit,
+  D as planAtlas
+};
+//# sourceMappingURL=atlasPlan.js.map

package/dist/core/atlasPlan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlasPlan.js","sources":["../../src/core/atlasPlan.ts"],"sourcesContent":["/*\n * Where every image goes in the world atlas, kept pure (no canvas) so the packing decision is unit-tested. The\n * builder (`atlas.ts`) paints what this plans.\n */\n\nexport const ATLAS_PAD = 2;\nconst MIN_ATLAS_WIDTH = 1024;\n/** The page side every desktop GPU takes, and the one the atlas was built to before pages existed. */\nexport const ATLAS_PAGE_FULL = 8192;\n/** The page side on a GPU that reports less than `ATLAS_PAGE_FULL` (older iPhones and iPads: 4096). */\nconst ATLAS_PAGE_SMALL = 4096;\n\n/**\n * How big an atlas page may be on this device: 8192 wherever the GPU takes it (every desktop — unchanged), else\n * split at 4096, or at the largest power of two the GPU does take if that is smaller still. Unknown: 8192, as before.\n */\nexport function atlasPageLimit(maxTextureSize: number | null): number {\n  if (maxTextureSize === null || maxTextureSize >= ATLAS_PAGE_FULL) return ATLAS_PAGE_FULL;\n  return Math.min(ATLAS_PAGE_SMALL, 2 ** Math.floor(Math.log2(Math.max(1, maxTextureSize))));\n}\n\nexport interface AtlasSize {\n  w: number;\n  h: number;\n}\n\nexport interface AtlasPage {\n  width: number;\n  height: number;\n}\n\nexport interface AtlasPlan {\n  pages: AtlasPage[];\n  /** One per input, in input order: the page and the top-left corner. */\n  places: { page: number; x: number; y: number }[];\n}\n\n/**\n * Shelf-packs the images, tallest first, into pages no larger than `limit` on either side. The page width is the\n * power of two that fits the widest image and the square root of the total area (at least 1024), capped at `limit`;\n * a shelf that would run past `limit` starts a new page. With everything fitting under `limit` this is exactly the\n * single page the atlas always was. An image larger than `limit` itself is given a page of its own (the GPU will\n * refuse it, but nothing else is lost with it).\n */\nexport function planAtlas(sizes: readonly AtlasSize[], limit: number): AtlasPlan {\n  const order = sizes.map((_, i) => i).sort((a, b) => sizes[b]!.h - sizes[a]!.h);\n  const area = sizes.reduce((sum, s) => sum + (s.w + ATLAS_PAD) * (s.h + ATLAS_PAD), 0);\n  const widest = Math.max(1, ...sizes.map((s) => s.w + ATLAS_PAD));\n  const width = Math.min(limit, Math.max(MIN_ATLAS_WIDTH, 2 ** Math.ceil(Math.log2(Math.max(widest, Math.sqrt(area))))));\n  const places: AtlasPlan['places'] = new Array(sizes.length);\n  const pages: AtlasPage[] = [];\n  let page = 0;\n  let x = 0;\n  let y = 0;\n  let shelf = 0;\n  let pageWidth = width;\n  const close = () => pages.push({ width: pageWidth, height: y + shelf });\n  for (const i of order) {\n    const w = sizes[i]!.w + ATLAS_PAD;\n    const h = sizes[i]!.h + ATLAS_PAD;\n    if (x > 0 && x + w > pageWidth) {\n      x = 0;\n      y += shelf;\n      shelf = 0;\n    }\n    if (y > 0 && y + h > limit) {\n      close();\n      page++;\n      x = 0;\n      y = 0;\n      shelf = 0;\n      pageWidth = width;\n    }\n    // an image wider than the page (only past `limit`) widens its own page rather than overlapping the edge\n    if (w > pageWidth) pageWidth = w;\n    places[i] = { page, x, y };\n    x += w;\n    shelf = Math.max(shelf, h);\n  }\n  if (sizes.length > 0) close();\n  return { pages, places };\n}\n"],"names":["ATLAS_PAD","ATLAS_PAGE_FULL","atlasPageLimit","maxTextureSize","planAtlas","sizes","limit","order","_","i","b","area","sum","s","widest","width","places","pages","page","x","y","shelf","pageWidth","close","w","h"],"mappings":"AAKO,MAAMA,IAAY;AAGlB,MAAMC,IAAkB;AAQxB,SAASC,EAAeC,GAAuC;AACpE,SAAIA,MAAmB,QAAQA,KAAkB,OAAwB,OAClE,KAAK,IAAI,MAAkB,KAAK,KAAK,MAAM,KAAK,KAAK,KAAK,IAAI,GAAGA,CAAc,CAAC,CAAC,CAAC;AAC3F;AAyBO,SAASC,EAAUC,GAA6BC,GAA0B;AAC/E,QAAMC,IAAQF,EAAM,IAAI,CAACG,GAAGC,MAAMA,CAAC,EAAE,KAAK,CAAC,GAAGC,MAAML,EAAMK,CAAC,EAAG,IAAIL,EAAM,CAAC,EAAG,CAAC,GACvEM,IAAON,EAAM,OAAO,CAACO,GAAKC,MAAMD,KAAOC,EAAE,IAAI,MAAcA,EAAE,IAAI,IAAY,CAAC,GAC9EC,IAAS,KAAK,IAAI,GAAG,GAAGT,EAAM,IAAI,CAACQ,MAAMA,EAAE,IAAI,CAAS,CAAC,GACzDE,IAAQ,KAAK,IAAIT,GAAO,KAAK,IAAI,MAAiB,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAIQ,GAAQ,KAAK,KAAKH,CAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAC/GK,IAA8B,IAAI,MAAMX,EAAM,MAAM,GACpDY,IAAqB,CAAA;AAC3B,MAAIC,IAAO,GACPC,IAAI,GACJC,IAAI,GACJC,IAAQ,GACRC,IAAYP;AAChB,QAAMQ,IAAQ,MAAMN,EAAM,KAAK,EAAE,OAAOK,GAAW,QAAQF,IAAIC,GAAO;AACtE,aAAWZ,KAAKF,GAAO;AACrB,UAAMiB,IAAInB,EAAMI,CAAC,EAAG,IAAI,GAClBgB,IAAIpB,EAAMI,CAAC,EAAG,IAAI;AACxB,IAAIU,IAAI,KAAKA,IAAIK,IAAIF,MACnBH,IAAI,GACJC,KAAKC,GACLA,IAAQ,IAEND,IAAI,KAAKA,IAAIK,IAAInB,MACnBiB,EAAA,GACAL,KACAC,IAAI,GACJC,IAAI,GACJC,IAAQ,GACRC,IAAYP,IAGVS,IAAIF,MAAWA,IAAYE,IAC/BR,EAAOP,CAAC,IAAI,EAAE,MAAAS,GAAM,GAAAC,GAAG,GAAAC,EAAA,GACvBD,KAAKK,GACLH,IAAQ,KAAK,IAAIA,GAAOI,CAAC;AAAA,EAC3B;AACA,SAAIpB,EAAM,SAAS,KAAGkB,EAAA,GACf,EAAE,OAAAN,GAAO,QAAAD,EAAA;AAClB;"}

package/dist/core/eases.js

@@ -0,0 +1,21 @@
+const a = (n) => n, e = {
+  Linear: a,
+  "Quad.In": (n) => n * n,
+  "Quad.Out": (n) => n * (2 - n),
+  "Cubic.Out": (n) => 1 - Math.pow(1 - n, 3),
+  "Sine.In": (n) => 1 - Math.cos(n * Math.PI / 2),
+  "Sine.InOut": (n) => -(Math.cos(Math.PI * n) - 1) / 2,
+  "Back.Out": (n) => {
+    const u = n - 1;
+    return u * u * (2.70158 * u + 1.70158) + 1;
+  }
+};
+function o(n) {
+  if (!n) return e["Quad.Out"];
+  const t = e[n];
+  return t || console.warn(`[tween] unknown ease ${n}`), t ?? a;
+}
+export {
+  o as easeByName
+};
+//# sourceMappingURL=eases.js.map

package/dist/core/eases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eases.js","sources":["../../src/core/eases.ts"],"sourcesContent":["export type EaseFn = (t: number) => number;\n\nconst linear: EaseFn = (t) => t;\n\n/** Easing functions by the names tween configs use ('Cubic.Out', 'Back.Out', ...). */\nconst EASES: Record<string, EaseFn> = {\n  Linear: linear,\n  'Quad.In': (t) => t * t,\n  'Quad.Out': (t) => t * (2 - t),\n  'Cubic.Out': (t) => 1 - Math.pow(1 - t, 3),\n  'Sine.In': (t) => 1 - Math.cos((t * Math.PI) / 2),\n  'Sine.InOut': (t) => -(Math.cos(Math.PI * t) - 1) / 2,\n  'Back.Out': (t) => {\n    const s = 1.70158;\n    const u = t - 1;\n    return u * u * ((s + 1) * u + s) + 1;\n  },\n};\n\nexport function easeByName(name: string | undefined): EaseFn {\n  if (!name) return EASES['Quad.Out']!; // Phaser's default tween ease is Power1 = Quad.Out\n  const fn = EASES[name];\n  if (!fn) console.warn(`[tween] unknown ease ${name}`);\n  return fn ?? linear;\n}\n"],"names":["linear","t","EASES","easeByName","name","fn"],"mappings":"AAEA,MAAMA,IAAiB,CAACC,MAAMA,GAGxBC,IAAgC;AAAA,EACpC,QAAQF;AAAA,EACR,WAAW,CAACC,MAAMA,IAAIA;AAAA,EACtB,YAAY,CAACA,MAAMA,KAAK,IAAIA;AAAA,EAC5B,aAAa,CAACA,MAAM,IAAI,KAAK,IAAI,IAAIA,GAAG,CAAC;AAAA,EACzC,WAAW,CAACA,MAAM,IAAI,KAAK,IAAKA,IAAI,KAAK,KAAM,CAAC;AAAA,EAChD,cAAc,CAACA,MAAM,EAAE,KAAK,IAAI,KAAK,KAAKA,CAAC,IAAI,KAAK;AAAA,EACpD,YAAY,CAACA,MAAM;AAEjB,UAAM,IAAIA,IAAI;AACd,WAAO,IAAI,KAAM,UAAS,IAAI,WAAK;AAAA,EACrC;AACF;AAEO,SAASE,EAAWC,GAAkC;AAC3D,MAAI,CAACA,EAAM,QAAOF,EAAM,UAAU;AAClC,QAAMG,IAAKH,EAAME,CAAI;AACrB,SAAKC,KAAI,QAAQ,KAAK,wBAAwBD,CAAI,EAAE,GAC7CC,KAAML;AACf;"}

package/dist/core/gameObject.js

@@ -0,0 +1,115 @@
+import { ColorMatrixFilter as n } from "pixi.js";
+const e = /* @__PURE__ */ new Map();
+function a(i) {
+  let t = e.get(i);
+  if (t) return t;
+  const s = new n();
+  s.antialias = "off";
+  const l = (i >> 16 & 255) / 255, r = (i >> 8 & 255) / 255, h = (i & 255) / 255;
+  return s.matrix = [0, 0, 0, 0, l, 0, 0, 0, 0, r, 0, 0, 0, 0, h, 0, 0, 0, 1, 0], e.set(i, t = [s]), t;
+}
+function u(i) {
+  return class extends i {
+    scene;
+    sx = 1;
+    sy = 1;
+    fx = !1;
+    fy = !1;
+    /** The colour this object is filled with (`setTintFill`), or null. */
+    solidFillColor = null;
+    /** False once destroyed. */
+    get active() {
+      return !this.destroyed;
+    }
+    get depth() {
+      return this.zIndex;
+    }
+    set depth(t) {
+      this.zIndex = t;
+    }
+    get scaleX() {
+      return this.sx;
+    }
+    set scaleX(t) {
+      this.sx = t, this.applyScale();
+    }
+    get scaleY() {
+      return this.sy;
+    }
+    set scaleY(t) {
+      this.sy = t, this.applyScale();
+    }
+    get flipX() {
+      return this.fx;
+    }
+    set flipX(t) {
+      this.fx = t, this.applyScale();
+    }
+    get flipY() {
+      return this.fy;
+    }
+    set flipY(t) {
+      this.fy = t, this.applyScale();
+    }
+    applyScale() {
+      this.destroyed || this.scale.set(this.sx * (this.fx ? -1 : 1), this.sy * (this.fy ? -1 : 1));
+    }
+    setScale(t, s = t) {
+      return this.sx = t, this.sy = s, this.applyScale(), this;
+    }
+    setFlipX(t) {
+      return this.flipX = t, this;
+    }
+    setFlipY(t) {
+      return this.flipY = t, this;
+    }
+    setFlip(t, s) {
+      return this.fx = t, this.fy = s, this.applyScale(), this;
+    }
+    setDepth(t) {
+      return this.zIndex = t, this;
+    }
+    setAlpha(t = 1) {
+      return this.alpha = t, this;
+    }
+    setVisible(t) {
+      return this.visible = t, this;
+    }
+    setPosition(t = 0, s = t) {
+      return this.position.set(t, s), this;
+    }
+    setRotation(t = 0) {
+      return this.rotation = t, this;
+    }
+    setAngle(t = 0) {
+      return this.angle = t, this;
+    }
+    setBlendMode(t) {
+      return this.blendMode = t, this;
+    }
+    setTint(t = 16777215) {
+      return this.clearFill(), this.tint = t, this;
+    }
+    /** Paints every opaque pixel in one solid colour (hit flash, silhouettes). */
+    setTintFill(t) {
+      return this.tint = 16777215, this.solidFillColor === t ? this : (this.solidFillColor = t, this.filters = a(t), this);
+    }
+    clearTint() {
+      return this.clearFill(), this.tint = 16777215, this;
+    }
+    clearFill() {
+      this.solidFillColor !== null && (this.filters = null, this.solidFillColor = null);
+    }
+    /** 0 pins the object to the screen instead of the world (full-screen flashes). */
+    setScrollFactor(t) {
+      return t === 0 && this.scene.screen.addChild(this), this;
+    }
+    destroy() {
+      this.destroyed || (this.solidFillColor !== null && (this.filters = null), this.solidFillColor = null, super.destroy({ children: !0, context: !0 }));
+    }
+  };
+}
+export {
+  u as GameObject
+};
+//# sourceMappingURL=gameObject.js.map

package/dist/core/gameObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gameObject.js","sources":["../../src/core/gameObject.ts"],"sourcesContent":["import { ColorMatrixFilter, type BLEND_MODES, type Container } from 'pixi.js';\nimport type { Stage } from './Stage';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Ctor<T> = new (...args: any[]) => T;\n\n/**\n * One solid-fill filter list per colour, shared by every object filled with it (a hit flash, a silhouette): a filter\n * made and destroyed on every hit of every body was garbage and shader state a blow. Kept for good —\n * a handful of colours are ever used.\n */\nconst FILLS = new Map<number, ColorMatrixFilter[]>();\n\nfunction fillFilters(color: number): ColorMatrixFilter[] {\n  let list = FILLS.get(color);\n  if (list) return list;\n  const f = new ColorMatrixFilter();\n  f.antialias = 'off';\n  const r = ((color >> 16) & 0xff) / 255;\n  const g = ((color >> 8) & 0xff) / 255;\n  const b = (color & 0xff) / 255;\n  f.matrix = [0, 0, 0, 0, r, 0, 0, 0, 0, g, 0, 0, 0, 0, b, 0, 0, 0, 1, 0];\n  FILLS.set(color, (list = [f]));\n  return list;\n}\n\n/** What `GameObject` adds to a Pixi display object. */\nexport interface GameObjectMembers {\n  scene: Stage;\n  /** False once destroyed. */\n  readonly active: boolean;\n  /** The draw order in the world layer (`zIndex`): bigger is in front. */\n  depth: number;\n  /** Scale without the flip: stays positive on a mirrored sprite. */\n  scaleX: number;\n  scaleY: number;\n  flipX: boolean;\n  flipY: boolean;\n  setScale(x: number, y?: number): this;\n  setFlipX(v: boolean): this;\n  setFlipY(v: boolean): this;\n  setFlip(x: boolean, y: boolean): this;\n  setDepth(d: number): this;\n  setAlpha(a?: number): this;\n  setVisible(v: boolean): this;\n  setPosition(x?: number, y?: number): this;\n  setRotation(r?: number): this;\n  setAngle(a?: number): this;\n  setBlendMode(mode: BLEND_MODES): this;\n  setTint(color?: number): this;\n  /** Paints every opaque pixel in one solid colour (hit flash, silhouettes). */\n  setTintFill(color: number): this;\n  clearTint(): this;\n  /** 0 pins the object to the screen instead of the world. */\n  setScrollFactor(f: number): this;\n  destroy(): void;\n}\n\n/**\n * The chainable setters the world code was written against (setDepth, setAlpha, setTintFill...), added onto a Pixi\n * display object. Scale is kept apart from flipping, so `scaleX` stays positive on a mirrored sprite as it did\n * before, and a tween on scale cannot undo a flip.\n */\nexport function GameObject<TBase extends Ctor<Container>>(Base: TBase): TBase & Ctor<GameObjectMembers> {\n  return class extends Base {\n    scene!: Stage;\n    private sx = 1;\n    private sy = 1;\n    private fx = false;\n    private fy = false;\n    /** The colour this object is filled with (`setTintFill`), or null. */\n    private solidFillColor: number | null = null;\n\n    /** False once destroyed. */\n    get active(): boolean {\n      return !this.destroyed;\n    }\n\n    get depth(): number {\n      return this.zIndex;\n    }\n\n    set depth(d: number) {\n      this.zIndex = d;\n    }\n\n    get scaleX(): number {\n      return this.sx;\n    }\n\n    set scaleX(v: number) {\n      this.sx = v;\n      this.applyScale();\n    }\n\n    get scaleY(): number {\n      return this.sy;\n    }\n\n    set scaleY(v: number) {\n      this.sy = v;\n      this.applyScale();\n    }\n\n    get flipX(): boolean {\n      return this.fx;\n    }\n\n    set flipX(v: boolean) {\n      this.fx = v;\n      this.applyScale();\n    }\n\n    get flipY(): boolean {\n      return this.fy;\n    }\n\n    set flipY(v: boolean) {\n      this.fy = v;\n      this.applyScale();\n    }\n\n    private applyScale(): void {\n      if (!this.destroyed) this.scale.set(this.sx * (this.fx ? -1 : 1), this.sy * (this.fy ? -1 : 1));\n    }\n\n    setScale(x: number, y = x): this {\n      this.sx = x;\n      this.sy = y;\n      this.applyScale();\n      return this;\n    }\n\n    setFlipX(v: boolean): this {\n      this.flipX = v;\n      return this;\n    }\n\n    setFlipY(v: boolean): this {\n      this.flipY = v;\n      return this;\n    }\n\n    setFlip(x: boolean, y: boolean): this {\n      this.fx = x;\n      this.fy = y;\n      this.applyScale();\n      return this;\n    }\n\n    setDepth(d: number): this {\n      this.zIndex = d;\n      return this;\n    }\n\n    setAlpha(a = 1): this {\n      this.alpha = a;\n      return this;\n    }\n\n    setVisible(v: boolean): this {\n      this.visible = v;\n      return this;\n    }\n\n    setPosition(x = 0, y = x): this {\n      this.position.set(x, y);\n      return this;\n    }\n\n    setRotation(r = 0): this {\n      this.rotation = r;\n      return this;\n    }\n\n    setAngle(a = 0): this {\n      this.angle = a;\n      return this;\n    }\n\n    setBlendMode(mode: BLEND_MODES): this {\n      this.blendMode = mode;\n      return this;\n    }\n\n    setTint(color = 0xffffff): this {\n      this.clearFill();\n      this.tint = color;\n      return this;\n    }\n\n    /** Paints every opaque pixel in one solid colour (hit flash, silhouettes). */\n    setTintFill(color: number): this {\n      this.tint = 0xffffff;\n      if (this.solidFillColor === color) return this;\n      this.solidFillColor = color;\n      this.filters = fillFilters(color);\n      return this;\n    }\n\n    clearTint(): this {\n      this.clearFill();\n      this.tint = 0xffffff;\n      return this;\n    }\n\n    private clearFill(): void {\n      if (this.solidFillColor === null) return;\n      this.filters = null;\n      this.solidFillColor = null;\n    }\n\n    /** 0 pins the object to the screen instead of the world (full-screen flashes). */\n    setScrollFactor(f: number): this {\n      if (f === 0) this.scene.screen.addChild(this);\n      return this;\n    }\n\n    override destroy(): void {\n      if (this.destroyed) return;\n      // the fill filters are shared (`FILLS`): let go of them, never destroy them\n      if (this.solidFillColor !== null) this.filters = null;\n      this.solidFillColor = null;\n      // `context`: a Pixi Graphics destroyed with options keeps its GraphicsContext — and that context's GPU buffers —\n      // until Pixi's own GC sweeps it a minute or more later. Every effect layer is a Graphics, so a crowded fight left\n      // hundreds a second on the GPU, and a phone that ran out dropped the WebGL context (the world rebuilt, seconds\n      // frozen, the socket timed out).\n      super.destroy({ children: true, context: true });\n    }\n  };\n}\n"],"names":["FILLS","fillFilters","color","list","f","ColorMatrixFilter","r","g","b","GameObject","Base","d","v","x","y","a","mode"],"mappings":";AAWA,MAAMA,wBAAY,IAAA;AAElB,SAASC,EAAYC,GAAoC;AACvD,MAAIC,IAAOH,EAAM,IAAIE,CAAK;AAC1B,MAAIC,EAAM,QAAOA;AACjB,QAAMC,IAAI,IAAIC,EAAA;AACd,EAAAD,EAAE,YAAY;AACd,QAAME,KAAMJ,KAAS,KAAM,OAAQ,KAC7BK,KAAML,KAAS,IAAK,OAAQ,KAC5BM,KAAKN,IAAQ,OAAQ;AAC3B,SAAAE,EAAE,SAAS,CAAC,GAAG,GAAG,GAAG,GAAGE,GAAG,GAAG,GAAG,GAAG,GAAGC,GAAG,GAAG,GAAG,GAAG,GAAGC,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,GACtER,EAAM,IAAIE,GAAQC,IAAO,CAACC,CAAC,CAAE,GACtBD;AACT;AAuCO,SAASM,EAA0CC,GAA8C;AACtG,SAAO,cAAcA,EAAK;AAAA,IACxB;AAAA,IACQ,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA;AAAA,IAEL,iBAAgC;AAAA;AAAA,IAGxC,IAAI,SAAkB;AACpB,aAAO,CAAC,KAAK;AAAA,IACf;AAAA,IAEA,IAAI,QAAgB;AAClB,aAAO,KAAK;AAAA,IACd;AAAA,IAEA,IAAI,MAAMC,GAAW;AACnB,WAAK,SAASA;AAAA,IAChB;AAAA,IAEA,IAAI,SAAiB;AACnB,aAAO,KAAK;AAAA,IACd;AAAA,IAEA,IAAI,OAAOC,GAAW;AACpB,WAAK,KAAKA,GACV,KAAK,WAAA;AAAA,IACP;AAAA,IAEA,IAAI,SAAiB;AACnB,aAAO,KAAK;AAAA,IACd;AAAA,IAEA,IAAI,OAAOA,GAAW;AACpB,WAAK,KAAKA,GACV,KAAK,WAAA;AAAA,IACP;AAAA,IAEA,IAAI,QAAiB;AACnB,aAAO,KAAK;AAAA,IACd;AAAA,IAEA,IAAI,MAAMA,GAAY;AACpB,WAAK,KAAKA,GACV,KAAK,WAAA;AAAA,IACP;AAAA,IAEA,IAAI,QAAiB;AACnB,aAAO,KAAK;AAAA,IACd;AAAA,IAEA,IAAI,MAAMA,GAAY;AACpB,WAAK,KAAKA,GACV,KAAK,WAAA;AAAA,IACP;AAAA,IAEQ,aAAmB;AACzB,MAAK,KAAK,aAAW,KAAK,MAAM,IAAI,KAAK,MAAM,KAAK,KAAK,KAAK,IAAI,KAAK,MAAM,KAAK,KAAK,KAAK,EAAE;AAAA,IAChG;AAAA,IAEA,SAASC,GAAWC,IAAID,GAAS;AAC/B,kBAAK,KAAKA,GACV,KAAK,KAAKC,GACV,KAAK,WAAA,GACE;AAAA,IACT;AAAA,IAEA,SAASF,GAAkB;AACzB,kBAAK,QAAQA,GACN;AAAA,IACT;AAAA,IAEA,SAASA,GAAkB;AACzB,kBAAK,QAAQA,GACN;AAAA,IACT;AAAA,IAEA,QAAQC,GAAYC,GAAkB;AACpC,kBAAK,KAAKD,GACV,KAAK,KAAKC,GACV,KAAK,WAAA,GACE;AAAA,IACT;AAAA,IAEA,SAASH,GAAiB;AACxB,kBAAK,SAASA,GACP;AAAA,IACT;AAAA,IAEA,SAASI,IAAI,GAAS;AACpB,kBAAK,QAAQA,GACN;AAAA,IACT;AAAA,IAEA,WAAWH,GAAkB;AAC3B,kBAAK,UAAUA,GACR;AAAA,IACT;AAAA,IAEA,YAAYC,IAAI,GAAGC,IAAID,GAAS;AAC9B,kBAAK,SAAS,IAAIA,GAAGC,CAAC,GACf;AAAA,IACT;AAAA,IAEA,YAAYR,IAAI,GAAS;AACvB,kBAAK,WAAWA,GACT;AAAA,IACT;AAAA,IAEA,SAASS,IAAI,GAAS;AACpB,kBAAK,QAAQA,GACN;AAAA,IACT;AAAA,IAEA,aAAaC,GAAyB;AACpC,kBAAK,YAAYA,GACV;AAAA,IACT;AAAA,IAEA,QAAQd,IAAQ,UAAgB;AAC9B,kBAAK,UAAA,GACL,KAAK,OAAOA,GACL;AAAA,IACT;AAAA;AAAA,IAGA,YAAYA,GAAqB;AAE/B,aADA,KAAK,OAAO,UACR,KAAK,mBAAmBA,IAAc,QAC1C,KAAK,iBAAiBA,GACtB,KAAK,UAAUD,EAAYC,CAAK,GACzB;AAAA,IACT;AAAA,IAEA,YAAkB;AAChB,kBAAK,UAAA,GACL,KAAK,OAAO,UACL;AAAA,IACT;AAAA,IAEQ,YAAkB;AACxB,MAAI,KAAK,mBAAmB,SAC5B,KAAK,UAAU,MACf,KAAK,iBAAiB;AAAA,IACxB;AAAA;AAAA,IAGA,gBAAgBE,GAAiB;AAC/B,aAAIA,MAAM,KAAG,KAAK,MAAM,OAAO,SAAS,IAAI,GACrC;AAAA,IACT;AAAA,IAES,UAAgB;AACvB,MAAI,KAAK,cAEL,KAAK,mBAAmB,SAAM,KAAK,UAAU,OACjD,KAAK,iBAAiB,MAKtB,MAAM,QAAQ,EAAE,UAAU,IAAM,SAAS,IAAM;AAAA,IACjD;AAAA,EAAA;AAEJ;"}

package/dist/core/pixiPatches.js

@@ -0,0 +1,18 @@
+import { BatchTextureArray as n } from "pixi.js";
+let i = !1;
+function l() {
+  if (i) return !0;
+  const e = n.prototype, r = new n();
+  return !(typeof e.clear == "function" && typeof r.ids == "object" && Array.isArray(r.textures) && typeof r.count == "number") || !/ids\[[^\]]+\]\s*=\s*null/.test(String(e.clear)) ? !1 : (e.clear = function() {
+    const c = this.ids, o = this.textures;
+    for (let t = 0; t < this.count; t++) {
+      const s = o[t];
+      o[t] = null, s && delete c[s.uid];
+    }
+    this.count = 0;
+  }, i = !0, !0);
+}
+export {
+  l as patchPixi
+};
+//# sourceMappingURL=pixiPatches.js.map

package/dist/core/pixiPatches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pixiPatches.js","sources":["../../src/core/pixiPatches.ts"],"sourcesContent":["import { BatchTextureArray } from 'pixi.js';\n\nlet patched = false;\n\n/**\n * Pixi 8's `BatchTextureArray.clear` sets `ids[source.uid] = null` instead of deleting the key, and its batches are\n * pooled, so every pooled batch keeps one key for every texture source ever drawn through it — about 70% of what a\n * fight's heap grew by in an hour (Pixi 8.21.0). The replacement deletes the key, which reads the\n * same to Pixi (`checkAndUpdateTexture` treats null and a missing key alike). Applied once, and only while `clear`\n * still has the shape it was written against, so a Pixi that fixed or changed it is left alone.\n */\nexport function patchPixi(): boolean {\n  if (patched) return true;\n  const proto = BatchTextureArray.prototype as unknown as { clear: () => void };\n  const probe = new BatchTextureArray() as unknown as { ids: unknown; textures: unknown; count: unknown };\n  const shaped = typeof proto.clear === 'function' && typeof probe.ids === 'object' && Array.isArray(probe.textures) && typeof probe.count === 'number';\n  if (!shaped || !/ids\\[[^\\]]+\\]\\s*=\\s*null/.test(String(proto.clear))) return false;\n  proto.clear = function clear(this: { ids: Record<number, number | null>; textures: ({ uid: number } | null)[]; count: number }): void {\n    const ids = this.ids;\n    const textures = this.textures;\n    for (let i = 0; i < this.count; i++) {\n      const t = textures[i];\n      textures[i] = null;\n      if (t) delete ids[t.uid];\n    }\n    this.count = 0;\n  };\n  patched = true;\n  return true;\n}\n"],"names":["patched","patchPixi","proto","BatchTextureArray","probe","ids","textures","i","t"],"mappings":";AAEA,IAAIA,IAAU;AASP,SAASC,IAAqB;AACnC,MAAID,EAAS,QAAO;AACpB,QAAME,IAAQC,EAAkB,WAC1BC,IAAQ,IAAID,EAAA;AAElB,SAAI,EADW,OAAOD,EAAM,SAAU,cAAc,OAAOE,EAAM,OAAQ,YAAY,MAAM,QAAQA,EAAM,QAAQ,KAAK,OAAOA,EAAM,SAAU,aAC9H,CAAC,2BAA2B,KAAK,OAAOF,EAAM,KAAK,CAAC,IAAU,MAC7EA,EAAM,QAAQ,WAAwH;AACpI,UAAMG,IAAM,KAAK,KACXC,IAAW,KAAK;AACtB,aAASC,IAAI,GAAGA,IAAI,KAAK,OAAOA,KAAK;AACnC,YAAMC,IAAIF,EAASC,CAAC;AACpB,MAAAD,EAASC,CAAC,IAAI,MACVC,KAAG,OAAOH,EAAIG,EAAE,GAAG;AAAA,IACzB;AACA,SAAK,QAAQ;AAAA,EACf,GACAR,IAAU,IACH;AACT;"}

package/dist/core/timelinePlace.js

@@ -0,0 +1,24 @@
+const f = /^(.*?)(?:([+-])=(\d+(?:\.\d+)?))?$/, i = /^\d+(?:\.\d+)?$/;
+function b(s, e) {
+  if (s === void 0) return e.fallback;
+  if (typeof s == "number") return Math.max(0, s);
+  const a = s.trim();
+  if (i.test(a)) return Number(a);
+  const n = f.exec(a);
+  if (!n) return e.fallback;
+  const t = n[1] ?? "";
+  let l;
+  if (t === "") l = e.fallback;
+  else if (t === "<") l = e.lastStart;
+  else if (t === ">") l = e.lastEnd;
+  else {
+    const r = e.labels.get(t);
+    r === void 0 ? (e.labels.set(t, e.end), l = e.end) : l = r;
+  }
+  const o = n[3] === void 0 ? 0 : Number(n[3]) * (n[2] === "-" ? -1 : 1);
+  return Math.max(0, l + o);
+}
+export {
+  b as placeAt
+};
+//# sourceMappingURL=timelinePlace.js.map

package/dist/core/timelinePlace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timelinePlace.js","sources":["../../src/core/timelinePlace.ts"],"sourcesContent":["/**\n * Where a child goes on a timeline: a time in ms from its start, or a string —\n * `'<'` the start of the child added last, `'>'` its end, `'+=200'` / `'-=100'` 200 ms after / 100 ms before the\n * default place (the timeline's end, or a `parallel` group's start), `'intro'` a label, and any of `'<'`, `'>'` or a\n * label followed by `+=n` / `-=n`. A string of digits is a time.\n */\nexport type TimelinePosition = number | string;\n\n/** What a position is measured against; `labels` is written to when a position names a label not yet set. */\nexport interface PlaceContext {\n  /** Where a child goes when no position is given: the timeline's end, or the open `parallel` group's start. */\n  fallback: number;\n  /** The end of the timeline as built so far: where a label first named in a position is set. */\n  end: number;\n  lastStart: number;\n  lastEnd: number;\n  labels: Map<string, number>;\n}\n\nconst SHAPE = /^(.*?)(?:([+-])=(\\d+(?:\\.\\d+)?))?$/;\nconst DIGITS = /^\\d+(?:\\.\\d+)?$/;\n\n/**\n * The start time (ms, never below 0) `at` names. A label not set yet is set at the timeline's end, the way GSAP does,\n * so `to(a, …, { at: 'hit' })` both places the child and names the spot for the children after it.\n */\nexport function placeAt(at: TimelinePosition | undefined, ctx: PlaceContext): number {\n  if (at === undefined) return ctx.fallback;\n  if (typeof at === 'number') return Math.max(0, at);\n  const text = at.trim();\n  if (DIGITS.test(text)) return Number(text);\n  const m = SHAPE.exec(text);\n  // the pattern matches any string (both parts may be empty), so this is only for the type checker\n  if (!m) return ctx.fallback;\n  const anchor = m[1] ?? '';\n  let base: number;\n  if (anchor === '') base = ctx.fallback;\n  else if (anchor === '<') base = ctx.lastStart;\n  else if (anchor === '>') base = ctx.lastEnd;\n  else {\n    const label = ctx.labels.get(anchor);\n    if (label === undefined) {\n      ctx.labels.set(anchor, ctx.end);\n      base = ctx.end;\n    } else base = label;\n  }\n  const amount = m[3] === undefined ? 0 : Number(m[3]) * (m[2] === '-' ? -1 : 1);\n  return Math.max(0, base + amount);\n}\n"],"names":["SHAPE","DIGITS","placeAt","at","ctx","text","m","anchor","base","label","amount"],"mappings":"AAmBA,MAAMA,IAAQ,sCACRC,IAAS;AAMR,SAASC,EAAQC,GAAkCC,GAA2B;AACnF,MAAID,MAAO,OAAW,QAAOC,EAAI;AACjC,MAAI,OAAOD,KAAO,iBAAiB,KAAK,IAAI,GAAGA,CAAE;AACjD,QAAME,IAAOF,EAAG,KAAA;AAChB,MAAIF,EAAO,KAAKI,CAAI,EAAG,QAAO,OAAOA,CAAI;AACzC,QAAMC,IAAIN,EAAM,KAAKK,CAAI;AAEzB,MAAI,CAACC,EAAG,QAAOF,EAAI;AACnB,QAAMG,IAASD,EAAE,CAAC,KAAK;AACvB,MAAIE;AACJ,MAAID,MAAW,GAAI,CAAAC,IAAOJ,EAAI;AAAA,WACrBG,MAAW,IAAK,CAAAC,IAAOJ,EAAI;AAAA,WAC3BG,MAAW,IAAK,CAAAC,IAAOJ,EAAI;AAAA,OAC/B;AACH,UAAMK,IAAQL,EAAI,OAAO,IAAIG,CAAM;AACnC,IAAIE,MAAU,UACZL,EAAI,OAAO,IAAIG,GAAQH,EAAI,GAAG,GAC9BI,IAAOJ,EAAI,OACNI,IAAOC;AAAA,EAChB;AACA,QAAMC,IAASJ,EAAE,CAAC,MAAM,SAAY,IAAI,OAAOA,EAAE,CAAC,CAAC,KAAKA,EAAE,CAAC,MAAM,MAAM,KAAK;AAC5E,SAAO,KAAK,IAAI,GAAGE,IAAOE,CAAM;AAClC;"}

package/dist/core/tweenProps.js

@@ -0,0 +1,12 @@
+function s(c, n) {
+  const e = n === "scale" ? c.scaleX : c[n];
+  return typeof e == "number" ? e : 0;
+}
+function o(c, n, e) {
+  n === "scale" ? (c.scaleX = e, c.scaleY = e) : c[n] = e;
+}
+export {
+  s as readProp,
+  o as writeProp
+};
+//# sourceMappingURL=tweenProps.js.map

package/dist/core/tweenProps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tweenProps.js","sources":["../../src/core/tweenProps.ts"],"sourcesContent":["import type { TweenTarget } from './Tweener';\n\n/**\n * How a tween reads and writes one property, shared by `Tweener` and `Timeline` so both treat `scale` the same way:\n * one number written to `scaleX` and `scaleY`, the shape every display object here exposes.\n */\nexport function readProp(target: TweenTarget, prop: string): number {\n  const v = prop === 'scale' ? target['scaleX'] : target[prop];\n  return typeof v === 'number' ? v : 0;\n}\n\nexport function writeProp(target: TweenTarget, prop: string, value: number): void {\n  if (prop === 'scale') {\n    target['scaleX'] = value;\n    target['scaleY'] = value;\n  } else target[prop] = value;\n}\n"],"names":["readProp","target","prop","v","writeProp","value"],"mappings":"AAMO,SAASA,EAASC,GAAqBC,GAAsB;AAClE,QAAMC,IAAID,MAAS,UAAUD,EAAO,SAAYA,EAAOC,CAAI;AAC3D,SAAO,OAAOC,KAAM,WAAWA,IAAI;AACrC;AAEO,SAASC,EAAUH,GAAqBC,GAAcG,GAAqB;AAChF,EAAIH,MAAS,WACXD,EAAO,SAAYI,GACnBJ,EAAO,SAAYI,KACdJ,EAAOC,CAAI,IAAIG;AACxB;"}