pixi-effects 0.26.2 → 0.26.3

package/dist/{chunk-WPXDRSGN.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);
@@ -3067,6 +3077,9 @@ 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);
@@ -3085,9 +3098,22 @@ var FrameCache = class {
   _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() {
@@ -3157,24 +3183,157 @@ var FrameCache = class {
     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 {
-      const last = this._lastTime;
-      this._lastTime = time;
-      const hit = this._covering(time);
-      if (hit) return hit.frame;
-      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 - this._held / 30) : time);
+      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);
@@ -3186,6 +3345,8 @@ var FrameCache = class {
   }
   /** 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);
@@ -3249,12 +3410,27 @@ var FrameCache = class {
     }
     this._frames.push(entry);
     while (this._frames.length > this._held) {
-      const oldest = this._frames.find((e) => e !== this._cur && e !== entry);
-      if (!oldest) break;
-      this._frames.splice(this._frames.indexOf(oldest), 1);
-      oldest.frame.close?.();
+      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;
@@ -3277,6 +3453,8 @@ var FrameCache = class {
     }
   }
   dispose() {
+    this._gen++;
+    this._dropStandby();
     for (const f of this.cache.values()) f?.close?.();
     this.cache.clear();
     this._pending.clear();
@@ -3318,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;
@@ -4518,7 +4696,7 @@ function resolveDim(v, scope) {
 var _CompositionSequence = null;
 async function getCompositionSequence() {
   if (!_CompositionSequence) {
-    _CompositionSequence = (await import('./Composition-HM4YT5L7.cjs')).CompositionSequence;
+    _CompositionSequence = (await import('./Composition-EE3KEE2L.cjs')).CompositionSequence;
   }
   return _CompositionSequence;
 }
@@ -4603,5 +4781,5 @@ exports.registerSequenceType = registerSequenceType;
 exports.remapOf = remapOf;
 exports.resolveAt = resolveAt;
 exports.timeRemapOf = timeRemapOf;
-//# sourceMappingURL=chunk-WPXDRSGN.cjs.map
-//# sourceMappingURL=chunk-WPXDRSGN.cjs.map
+//# sourceMappingURL=chunk-A225HYSY.cjs.map
+//# sourceMappingURL=chunk-A225HYSY.cjs.map