pixi-effects 0.26.1 → 0.26.3

package/dist/{chunk-EABL3UKJ.cjs → chunk-A225HYSY.cjs}

@@ -394,19 +394,29 @@ function evaluateExpr(source, scope) {
 // src/expr/normalizeProps.ts
 function normalizeProps(input, scope, options = {}) {
   const skip = new Set(options.skipKeys ?? []);
-  return walk(input, scope, skip, null);
+  return walk(input, scope, skip, null, options);
 }
-function walk(value, scope, skip, currentKey) {
+var RELATIVE = /^\s*([+-])=([\s\S]*)$/;
+function walk(value, scope, skip, currentKey, options) {
   if (Array.isArray(value)) {
-    return value.map((v) => walk(v, scope, skip, currentKey));
+    return value.map((v) => walk(v, scope, skip, currentKey, options));
   }
   if (value !== null && typeof value === "object") {
     const out = {};
     for (const k of Object.keys(value)) {
-      out[k] = walk(value[k], scope, skip, k);
+      out[k] = walk(value[k], scope, skip, k, options);
     }
     return out;
   }
+  if (typeof value === "string" && !(currentKey !== null && skip.has(currentKey))) {
+    const rel = RELATIVE.exec(value);
+    if (rel) {
+      const n = evaluateExpr(rel[2].trim(), scope);
+      if (options.relative === "allow") return `${rel[1]}=${n}`;
+      console.warn(`pixi-effects: "${value.trim()}"${currentKey ? ` (${currentKey})` : ""} is a relative value (measured from where the layer is): it works in a keyframe's to / from / set, not in ${options.where ?? "an initial or a style"}; it is read as the number ${rel[1] === "-" ? -n : n}`);
+      return rel[1] === "-" ? -n : n;
+    }
+  }
   if (isExpr(value) && !(currentKey !== null && skip.has(currentKey))) {
     if (looksLikeColorString(value)) return value;
     return evaluateExpr(value, scope);
@@ -637,7 +647,7 @@ function applyKeyframes(timeline, target, keyframes, parentDuration, scope, skip
     const kf = normalizeKeyframe(raw, parentDuration);
     const at = offset + kf.at;
     if (kf.kind === "set") {
-      const resolved = normalizeProps(kf.set, scope, { skipKeys });
+      const resolved = normalizeProps(kf.set, scope, { skipKeys, relative: "allow" });
       const { rest, routed } = splitRouted(resolved, routers);
       for (const r of routed) timeline.set(r.target, { [r.prop]: r.value }, at);
       const { ownProps, filterProps } = partitionProps(rest);
@@ -648,7 +658,7 @@ function applyKeyframes(timeline, target, keyframes, parentDuration, scope, skip
         timeline.set(f, props, at);
       }
     } else if (kf.kind === "to") {
-      const resolved = normalizeProps(kf.to, scope, { skipKeys });
+      const resolved = normalizeProps(kf.to, scope, { skipKeys, relative: "allow" });
       const { rest, routed } = splitRouted(resolved, routers);
       for (const r of routed)
         timeline.to(r.target, { [r.prop]: r.value, duration: kf.duration, ease: kf.ease, ...kf.loop }, at);
@@ -661,7 +671,7 @@ function applyKeyframes(timeline, target, keyframes, parentDuration, scope, skip
         timeline.to(f, { ...props, duration: kf.duration, ease: kf.ease, ...kf.loop }, at);
       }
     } else if (kf.kind === "from") {
-      const resolved = normalizeProps(kf.from, scope, { skipKeys });
+      const resolved = normalizeProps(kf.from, scope, { skipKeys, relative: "allow" });
       const { rest, routed } = splitRouted(resolved, routers);
       for (const r of routed)
         timeline.from(r.target, { [r.prop]: r.value, duration: kf.duration, ease: kf.ease, ...kf.loop }, at);
@@ -674,8 +684,8 @@ function applyKeyframes(timeline, target, keyframes, parentDuration, scope, skip
         timeline.from(f, { ...props, duration: kf.duration, ease: kf.ease, ...kf.loop }, at);
       }
     } else {
-      const fromResolved = normalizeProps(kf.from, scope, { skipKeys });
-      const toResolved = normalizeProps(kf.to, scope, { skipKeys });
+      const fromResolved = normalizeProps(kf.from, scope, { skipKeys, where: "the from side of a from + to keyframe" });
+      const toResolved = normalizeProps(kf.to, scope, { skipKeys, relative: "allow" });
       const fromRouted = splitRouted(fromResolved, routers);
       const toRouted = splitRouted(toResolved, routers);
       const fromByKey = new Map(fromRouted.routed.map((r) => [r.key, r]));
@@ -725,7 +735,7 @@ function applyKeyframes(timeline, target, keyframes, parentDuration, scope, skip
 }
 function applyInitial(target, initial, scope, skipKeys = [], routers) {
   if (!initial) return;
-  const resolved = normalizeProps(initial, scope, { skipKeys });
+  const resolved = normalizeProps(initial, scope, { skipKeys, where: "initial" });
   const { rest, routed } = splitRouted(resolved, routers);
   for (const r of routed) gsap.gsap.set(r.target, { [r.prop]: r.value });
   const { ownProps, filterProps } = partitionProps(rest);
@@ -2986,7 +2996,7 @@ var AudioSequence = class extends Sequence {
     const raw = spec;
     if (raw.asset !== void 0) console.warn(`pixi-effects: ${who}: has both asset and music \u2014 the music plays; remove one`);
     if (raw.sfx !== void 0) console.warn(`pixi-effects: ${who}: has both sfx and music \u2014 the music plays; remove one`);
-    const { resolveMusic, renderMusic, musicLength, musicKey } = await import('./music-KB7YZLHP.cjs');
+    const { resolveMusic, renderMusic, musicLength, musicKey } = await import('./music-4O367SPR.cjs');
     const music = resolveMusic(spec.music, who);
     if (!music) return;
     const natural = musicLength(music);
@@ -3063,19 +3073,57 @@ var AudioSequence = class extends Sequence {
 };
 
 // src/core/FrameCache.ts
+var BUDGET_BYTES = 96 * 1024 * 1024;
+var MIN_HELD = 3;
+var JUMP_SECONDS = 1;
+var EPS = 1e-6;
+var LOW_BEHIND = 14;
+var MIN_HELD_TO_READ_BACK = 20;
+var MIN_HELD_TO_READ_START = 9;
+function reportDecodeError(err, time) {
+  const isTransient = err instanceof DOMException && (err.name === "EncodingError" || err.name === "NotSupportedError");
+  if (isTransient) console.debug("pixi-effects: transient video decode failure at", time, "s \u2014", err.name);
+  else console.warn("pixi-effects: video frame decode failed at", time, "s \u2014", err);
+}
 var FrameCache = class {
   sink;
   capacity;
   cache = /* @__PURE__ */ new Map();
   _pending = /* @__PURE__ */ new Map();
+  // Sequential mode (the sink has `samples()`): one decoder pass that runs forward as the movie asks for frame after frame.
+  _frames = [];
+  _cur = null;
+  _iter = null;
+  _next = null;
+  _held = 0;
+  _lock = Promise.resolve();
+  _lastTime = null;
+  _dir = 0;
+  _gen = 0;
+  _backBusy = false;
+  _backGen = 0;
+  _standbyBusy = false;
+  /** A second pass at the start of the file, ready for the moment a looping video comes round. */
+  _standby = null;
+  _duration;
+  _loop;
+  /** How often it had to wait for a decoder (`restarts`, `singles`) and how many reads ahead it made: for tests and for `check`. */
+  stats = { restarts: 0, singles: 0, prefetches: 0 };
   constructor(sink, options = {}) {
     this.sink = sink;
     this.capacity = options.capacity ?? 30;
+    this._duration = options.duration ?? null;
+    this._loop = !!options.loop;
+  }
+  /** How many decoded frames are held right now (the sequential reader's own list, plus the exact-time cache of the old path). */
+  get heldFrames() {
+    return this._frames.length + this.cache.size;
   }
   _key(time) {
     return Math.round(time * 1e6);
   }
   async getFrameAt(time) {
+    if (this.sink.samples) return this._enqueue(() => this._sequentialAt(time));
     const key = this._key(time);
     if (this.cache.has(key)) {
       const v = this.cache.get(key);
@@ -3113,14 +3161,287 @@ var FrameCache = class {
       sample.close?.();
       return frame;
     } catch (err) {
-      const isTransient = err instanceof DOMException && (err.name === "EncodingError" || err.name === "NotSupportedError");
-      if (isTransient) {
-        console.debug("pixi-effects: transient video decode failure at", time, "s \u2014", err.name);
-      } else {
-        console.warn("pixi-effects: video frame decode failed at", time, "s \u2014", err);
+      reportDecodeError(err, time);
+      return null;
+    }
+  }
+  // ── sequential mode ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+  /** Requests are answered one at a time, in the order they arrive: one pass cannot serve two places at once. */
+  _enqueue(fn) {
+    const run = this._lock.then(fn, fn);
+    this._lock = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  _covering(time) {
+    for (const e of this._frames) {
+      if (e.end === null ? e.req !== void 0 && Math.abs(e.req - time) < EPS : e.ts <= time + EPS && time < e.end - EPS) {
+        this._frames.splice(this._frames.indexOf(e), 1);
+        this._frames.push(e);
+        return e;
+      }
+    }
+    return null;
+  }
+  async _sequentialAt(time) {
+    const last = this._lastTime;
+    this._lastTime = time;
+    if (last !== null && Math.abs(time - last) <= JUMP_SECONDS) this._dir = time > last + EPS ? 1 : time < last - EPS ? -1 : this._dir;
+    let frame;
+    try {
+      frame = await this._serve(time, last);
+    } catch (err) {
+      reportDecodeError(err, time);
+      await this._closeIter();
+      return null;
+    }
+    this._maybeReadAhead(time);
+    return frame;
+  }
+  async _serve(time, last) {
+    const hit = this._covering(time);
+    if (hit) return hit.frame;
+    const sb = this._standby;
+    if (sb && time >= sb.cur.ts - EPS && time - sb.cur.ts <= JUMP_SECONDS && (!this._iter || !this._cur || this._cur.ts > time + JUMP_SECONDS)) return await this._adoptStandby(time);
+    if (last === null || Math.abs(time - last) > JUMP_SECONDS) return await this._single(time);
+    const cur = this._cur;
+    if (this._iter && cur && time >= cur.ts && time - cur.ts <= JUMP_SECONDS) return await this._advance(time);
+    const backwards = !!cur && time < cur.ts;
+    return await this._restart(time, backwards ? Math.max(0, time - Math.max(1, this._held - 1) / 30) : time);
+  }
+  // ── reading ahead ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+  _maybeReadAhead(time) {
+    if (this._held === 0) return;
+    if (this._dir === -1) {
+      this._dropStandby();
+      let behind = 0, passed = 0, earliest = Infinity;
+      for (const e of this._frames) {
+        if (e.ts < time - EPS) behind++;
+        else if (e.ts > time + EPS) passed++;
+        if (e.ts < earliest) earliest = e.ts;
+      }
+      if (this._held >= MIN_HELD_TO_READ_BACK && behind < LOW_BEHIND && passed >= 3 && earliest > EPS && !this._backBusy) void this._readBack(earliest, passed);
+    } else if (this._held >= MIN_HELD_TO_READ_START && this._dir === 1 && this._loop && this._duration !== null && time >= this._duration - JUMP_SECONDS && !this._standby && !this._standbyBusy) {
+      void this._readStart();
+    }
+  }
+  /** In the background: the window of frames before the earliest one held (reverse play comes to it next). */
+  async _readBack(earliest, room) {
+    this._backBusy = true;
+    this.stats.prefetches++;
+    const gen = this._gen, bg = this._backGen;
+    const want = Math.max(3, Math.min(Math.floor(this._held * 0.6), room));
+    let iter = null;
+    const got = [];
+    try {
+      iter = this.sink.samples(Math.max(0, earliest - want / 30));
+      for (; ; ) {
+        const r = await iter.next();
+        if (r.done) break;
+        if (gen !== this._gen || r.value.timestamp >= earliest - EPS) {
+          r.value.close?.();
+          break;
+        }
+        got.push(r.value);
+        if (bg !== this._backGen) break;
+      }
+      if (gen === this._gen && bg === this._backGen) {
+        for (let k = 0; k < got.length; k++) {
+          const s = got[k];
+          const frame = s.toVideoFrame();
+          this._keep({ ts: s.timestamp, end: got[k + 1]?.timestamp ?? earliest, frame }, frame);
+        }
+      }
+    } catch (err) {
+      reportDecodeError(err, earliest);
+    } finally {
+      for (const s of got) s.close?.();
+      this._backBusy = false;
+      try {
+        await iter?.return?.(void 0);
+      } catch {
+      }
+    }
+  }
+  /** In the background: the first frames of the file and a pass that stands behind them; held (pinned) until the loop comes round. */
+  async _readStart() {
+    this._standbyBusy = true;
+    this.stats.prefetches++;
+    const gen = this._gen;
+    const want = Math.max(3, Math.min(10, Math.floor(this._held / 3)));
+    let iter = null;
+    const got = [];
+    let keep = false;
+    try {
+      iter = this.sink.samples(0);
+      for (; got.length < want + 1; ) {
+        const r = await iter.next();
+        if (r.done) break;
+        if (gen !== this._gen) {
+          r.value.close?.();
+          break;
+        }
+        got.push(r.value);
+      }
+      if (gen === this._gen && got.length >= 2) {
+        const next = got.pop();
+        let cur = null;
+        got.forEach((s, k) => {
+          const frame = s.toVideoFrame();
+          s.close?.();
+          const entry = { ts: s.timestamp, end: (got[k + 1] ?? next).timestamp, frame, pinned: true };
+          this._keep(entry, frame);
+          cur = entry;
+        });
+        got.length = 0;
+        if (cur) {
+          this._standby = { iter, cur, next };
+          keep = true;
+        }
+      }
+    } catch (err) {
+      reportDecodeError(err, 0);
+    } finally {
+      for (const s of got) s.close?.();
+      this._standbyBusy = false;
+      if (!keep) {
+        try {
+          await iter?.return?.(void 0);
+        } catch {
+        }
       }
+    }
+  }
+  async _adoptStandby(time) {
+    const sb = this._standby;
+    this._standby = null;
+    await this._closeIter();
+    for (const e of this._frames) e.pinned = false;
+    this._iter = sb.iter;
+    this._next = sb.next;
+    this._cur = sb.cur;
+    return this._advance(time);
+  }
+  _dropStandby() {
+    const sb = this._standby;
+    if (!sb) return;
+    this._standby = null;
+    sb.next?.close?.();
+    for (const e of this._frames.filter((x) => x.pinned)) {
+      e.pinned = false;
+    }
+    void sb.iter.return?.(void 0);
+  }
+  /** One frame by itself (a seek): getSample, kept so that asking again for the same time costs nothing. The running pass, if any, is closed: it no longer follows the playhead. */
+  async _single(time) {
+    this.stats.singles++;
+    await this._closeIter();
+    this._cur = null;
+    const sample = await this.sink.getSample(time);
+    if (!sample) return null;
+    const frame = sample.toVideoFrame();
+    sample.close?.();
+    this._keep({ ts: sample.timestamp, end: null, frame, req: time }, frame);
+    return frame;
+  }
+  /** Start a pass at `time` (a seek and the frames of one group of pictures), keeping what is still held for a step back. */
+  async _restart(time, from = time) {
+    this.stats.restarts++;
+    this._backGen++;
+    await this._closeIter();
+    this._cur = null;
+    const iter = this.sink.samples(from);
+    this._iter = iter;
+    const first = await iter.next();
+    if (first.done) {
+      await this._closeIter();
       return null;
     }
+    if (first.value.timestamp > time + EPS) {
+      first.value.close?.();
+      await this._closeIter();
+      return null;
+    }
+    this._take(first.value);
+    return this._advance(time);
+  }
+  /** Run the pass forward until the frame that covers `time` is the current one; the next frame is read ahead (its start is where this one ends). */
+  async _advance(time) {
+    const cur = () => this._cur;
+    for (; ; ) {
+      if (!this._next) {
+        let r;
+        try {
+          r = await this._iter.next();
+        } catch (err) {
+          reportDecodeError(err, time);
+          await this._closeIter();
+          const prev = this._frames.length > 1 ? this._frames[this._frames.length - 2] : null;
+          const spacing = prev ? cur().ts - prev.ts : 1 / 24;
+          return time < cur().ts + spacing - EPS ? cur().frame : null;
+        }
+        if (r.done) {
+          cur().end = Infinity;
+          this._iter = null;
+          break;
+        }
+        this._next = r.value;
+      }
+      cur().end = this._next.timestamp;
+      if (this._next.timestamp <= time + EPS) {
+        const s = this._next;
+        this._next = null;
+        this._take(s);
+      } else break;
+    }
+    return cur().frame;
+  }
+  _take(sample) {
+    const frame = sample.toVideoFrame();
+    sample.close?.();
+    const entry = { ts: sample.timestamp, end: null, frame };
+    this._keep(entry, frame);
+    this._cur = entry;
+  }
+  /** Hold a frame (the first one sets how many fit: a byte budget, not a count) and close the oldest beyond that; the frame the pass stands on is never closed. */
+  _keep(entry, frame) {
+    if (this._held === 0) {
+      const bytes = frame.allocationSize?.() ?? frame.displayWidth * frame.displayHeight * 1.5;
+      this._held = Math.max(MIN_HELD, Math.min(this.capacity, Math.floor(BUDGET_BYTES / Math.max(1, bytes))));
+    }
+    this._frames.push(entry);
+    while (this._frames.length > this._held) {
+      const victim = this._victim(entry);
+      if (!victim) break;
+      this._frames.splice(this._frames.indexOf(victim), 1);
+      victim.frame.close?.();
+    }
+  }
+  /**
+   * The frame to let go: one the playhead has already passed (going forward those before it, going back those after it), the furthest
+   * behind first; when there is none, the one furthest ahead of the playhead (the last to be needed). Least recently used when the
+   * direction is not known. Frames of the standby (pinned) and the frame the pass stands on are never chosen.
+   */
+  _victim(except) {
+    const cand = this._frames.filter((e) => e !== this._cur && e !== except && !e.pinned);
+    if (cand.length === 0) return null;
+    if (this._dir === 0) return cand[0];
+    const at = this._lastTime ?? 0;
+    const passed = cand.filter((e) => this._dir === 1 ? e.ts < at - EPS : e.ts > at + EPS);
+    const farthest = (list, sign) => list.reduce((a, b) => sign * (b.ts - a.ts) > 0 ? b : a);
+    if (passed.length) return farthest(passed, this._dir === 1 ? -1 : 1);
+    return farthest(cand, this._dir === 1 ? 1 : -1);
+  }
+  async _closeIter() {
+    const iter = this._iter;
+    this._iter = null;
+    this._next?.close?.();
+    this._next = null;
+    if (iter) {
+      try {
+        await iter.return?.(void 0);
+      } catch {
+      }
+    }
   }
   _evictIfNeeded() {
     while (this.cache.size > this.capacity) {
@@ -3132,9 +3453,19 @@ var FrameCache = class {
     }
   }
   dispose() {
+    this._gen++;
+    this._dropStandby();
     for (const f of this.cache.values()) f?.close?.();
     this.cache.clear();
     this._pending.clear();
+    for (const e of this._frames) e.frame.close?.();
+    this._frames = [];
+    this._cur = null;
+    this._next?.close?.();
+    this._next = null;
+    const iter = this._iter;
+    this._iter = null;
+    void iter?.return?.(void 0);
   }
 };
 
@@ -3165,7 +3496,7 @@ var VideoSequence = class extends Sequence {
     this._sourceDuration = data.duration;
     this._remap = remapOf(this.spec, "currentTime", this._sourceDuration);
     this._audioBuffer = this.spec.audio !== false ? data.audioBuffer : null;
-    this._cache = new FrameCache(data.sink, { capacity: 30 });
+    this._cache = new FrameCache(data.sink, { capacity: 30, duration: data.duration, loop: !!this.spec.loop });
     const probeFrame = await this._cache.getFrameAt(0);
     const w = probeFrame?.displayWidth ?? 1920;
     const h = probeFrame?.displayHeight ?? 1080;
@@ -4365,7 +4696,7 @@ function resolveDim(v, scope) {
 var _CompositionSequence = null;
 async function getCompositionSequence() {
   if (!_CompositionSequence) {
-    _CompositionSequence = (await import('./Composition-THQPG4E5.cjs')).CompositionSequence;
+    _CompositionSequence = (await import('./Composition-EE3KEE2L.cjs')).CompositionSequence;
   }
   return _CompositionSequence;
 }
@@ -4450,5 +4781,5 @@ exports.registerSequenceType = registerSequenceType;
 exports.remapOf = remapOf;
 exports.resolveAt = resolveAt;
 exports.timeRemapOf = timeRemapOf;
-//# sourceMappingURL=chunk-EABL3UKJ.cjs.map
-//# sourceMappingURL=chunk-EABL3UKJ.cjs.map
+//# sourceMappingURL=chunk-A225HYSY.cjs.map
+//# sourceMappingURL=chunk-A225HYSY.cjs.map