pixi-effects 0.19.0 → 0.20.0

package/dist/Presenter.js

@@ -1,4 +1,4 @@
-import { warnUnknownOptions } from './chunk-DKGG7WD4.js';
+import { warnUnknownOptions } from './chunk-MNM56B3X.js';
 
 // src/Presenter.ts
 var OPTION_KEYS = ["canvas", "keyboard", "clickToAdvance", "swipe", "indicator", "autoAdvance", "loop", "accent", "onExit"];

package/dist/{chunk-YRXTKOV5.js → chunk-DQHXVNOI.js}

@@ -1,4 +1,4 @@
-import { suggestName, warnUnknownOptions } from './chunk-DKGG7WD4.js';
+import { suggestName, warnUnknownOptions } from './chunk-MNM56B3X.js';
 import * as PIXI from 'pixi.js';
 import { Rectangle, Container, GraphicsPath, Graphics, Assets, Texture, Sprite, FillGradient, Text, Filter, GlProgram, defaultFilterVert, GpuProgram, UniformGroup, Color } from 'pixi.js';
 import { gsap } from 'gsap';
@@ -396,6 +396,58 @@ function looksLikeColorString(s) {
   if (s.charCodeAt(0) === 35) return true;
   return /^(rgb|hsl|oklab|oklch|lab|lch)\b/i.test(s);
 }
+function cubicBezierEase(x1, y1, x2, y2) {
+  const cx = 3 * x1, bx = 3 * (x2 - x1) - cx, ax = 1 - cx - bx;
+  const cy = 3 * y1, by = 3 * (y2 - y1) - cy, ay = 1 - cy - by;
+  const X = (t) => ((ax * t + bx) * t + cx) * t;
+  const Y = (t) => ((ay * t + by) * t + cy) * t;
+  const dX = (t) => (3 * ax * t + 2 * bx) * t + cx;
+  return (p) => {
+    if (p <= 0) return 0;
+    if (p >= 1) return 1;
+    let t = p;
+    for (let i = 0; i < 8; i++) {
+      const err = X(t) - p;
+      if (Math.abs(err) < 1e-9) return Y(t);
+      const d = dX(t);
+      if (Math.abs(d) < 1e-6) break;
+      t -= err / d;
+    }
+    let lo = 0, hi = 1;
+    t = p;
+    for (let i = 0; i < 60; i++) {
+      const x = X(t);
+      if (Math.abs(x - p) < 1e-10) break;
+      if (x < p) lo = t;
+      else hi = t;
+      t = (lo + hi) / 2;
+    }
+    return Y(t);
+  };
+}
+var NUM = String.raw`\s*(-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)\s*`;
+var RE = new RegExp(`^\\s*cubic-bezier\\(${NUM},${NUM},${NUM},${NUM}\\)\\s*$`, "i");
+function cubicBezierProblem(name) {
+  const m = RE.exec(name);
+  if (!m) return 'expected "cubic-bezier(x1, y1, x2, y2)" with four numbers, like CSS';
+  const x1 = Number(m[1]), x2 = Number(m[3]);
+  if (x1 < 0 || x1 > 1 || x2 < 0 || x2 > 1) return "x1 and x2 must be between 0 and 1 (y1 and y2 may overshoot)";
+  return null;
+}
+var registered2 = false;
+function registerCubicBezierEase() {
+  if (registered2) return;
+  registered2 = true;
+  const base = ((p) => p);
+  base.config = (x1, y1, x2, y2) => {
+    const bad = [x1, y1, x2, y2].some((v) => typeof v !== "number" || !Number.isFinite(v)) || x1 < 0 || x1 > 1 || x2 < 0 || x2 > 1;
+    return bad ? (p) => p : cubicBezierEase(x1, y1, x2, y2);
+  };
+  gsap.registerEase("cubic-bezier", base);
+}
+registerCubicBezierEase();
+
+// src/core/ease.ts
 var FAMILIES = ["power1", "power2", "power3", "power4", "back", "elastic", "bounce", "circ", "expo", "sine"];
 var EASE_NAMES = ["none", ...FAMILIES.flatMap((f) => [`${f}.in`, `${f}.out`, `${f}.inOut`])];
 var warned = /* @__PURE__ */ new Set();
@@ -408,6 +460,13 @@ function checkEase(ease, where) {
     console.warn(`pixi-effects: ${where}: unknown ease "${ease}" \u2014 ${problem}. GSAP would run it as its default ease, power1.out.`);
     return;
   }
+  if (/^\s*cubic-bezier/i.test(ease)) {
+    const problem = cubicBezierProblem(ease);
+    if (!problem || warned.has(ease)) return;
+    warned.add(ease);
+    console.warn(`pixi-effects: ${where}: unknown ease "${ease}" \u2014 ${problem}. It runs as 'none' (a straight line).`);
+    return;
+  }
   const found = gsap.parseEase(ease);
   if (typeof found === "function") return;
   if (warned.has(ease)) return;
@@ -1082,7 +1141,7 @@ var GrainFilter = class extends Filter {
   }
   /** The movie calls this with the time (s) of the frame it is about to draw: the grain is new every 1/fps s. */
   setTime(t) {
-    this.u.uFrame = this._fps > 0 ? Math.floor(t * this._fps + 1e-6) : 0;
+    this.u.uFrame = this._fps > 0 ? Math.floor(t * this._fps + 1e-3) : 0;
   }
 };
 
@@ -1297,13 +1356,21 @@ var Sequence = class {
   pathRouters() {
     return {};
   }
+  /**
+   * The `initial` and `keyframes` that go onto the display object. A layer whose `time` runs a clock (video, composition) takes `time`
+   * out of them: it is not a property of the display object.
+   */
+  displayProps() {
+    return { initial: this.spec.initial, keyframes: this.spec.keyframes };
+  }
   bindTimeline(timeline, offset = 0) {
     if (!this.target) return;
     const scope = this.scope();
     const routers = this.pathRouters();
     const startTime = offset + this.at;
-    applyInitial(this.target, this.spec.initial, scope, [], routers);
-    applyKeyframes(timeline, this.target, this.spec.keyframes, this.duration, scope, [], startTime, routers);
+    const { initial, keyframes } = this.displayProps();
+    applyInitial(this.target, initial, scope, [], routers);
+    applyKeyframes(timeline, this.target, keyframes, this.duration, scope, [], startTime, routers);
     const endTime = startTime + this.duration;
     this.absoluteStart = startTime;
     if (this.keepHidden) return;
@@ -1356,11 +1423,11 @@ function collectPropKeys(spec) {
 
 // src/core/layerKeys.ts
 var COMMON = ["type", "name", "parent", "at", "duration", "initial", "keyframes", "filters", "filterArea", "mask", "maskInverted", "blendMode", "threeD", "hideBehindCamera"];
-var VIDEO = [...COMMON, "asset", "loop", "audio", "volume"];
+var VIDEO = [...COMMON, "asset", "loop", "audio", "volume", "speed"];
 var IMAGE = [...COMMON, "asset", "colorSpace"];
 var TEXT = [...COMMON, "text", "format", "style", "colorSpace", "fillGradient"];
-var AUDIO = [...COMMON, "volume", "asset", "loop", "sfx", "music"];
-var COMPOSITION = [...COMMON, "width", "height", "sequences", "transitions"];
+var AUDIO = [...COMMON, "volume", "asset", "loop", "sfx", "music", "speed"];
+var COMPOSITION = [...COMMON, "width", "height", "sequences", "transitions", "speed"];
 var CAMERA = [...COMMON];
 var NULL = [...COMMON];
 var SHAPE = [...COMMON, "shape", "fillGradient", "colorSpace", "strokeCap", "strokeJoin"];
@@ -1450,6 +1517,7 @@ var PROP_KEYS = /* @__PURE__ */ new Set([
   "visibleChars",
   "text",
   "volume",
+  "time",
   // camera
   "lookAtX",
   "lookAtY",
@@ -1526,12 +1594,54 @@ function lintText(spec, warn = defaultWarn) {
     warn(`pixi-effects: ${describeLayer(spec)}: \`value\` is set or animated but the text has no {value} placeholder, so nothing shows it. Use text: '{value}' (or e.g. '{value} users').`);
   }
 }
+var REMAPPABLE = /* @__PURE__ */ new Set(["video", "audio", "composition"]);
+var REMAP_NAMES = /* @__PURE__ */ new Set(["time", "timeRemap", "reverse"]);
+var TIME_BAGS = ["set", "to", "from"];
+function lintRemap(spec, warn) {
+  const s = spec;
+  const who = describeLayer(spec);
+  const kfs = s.keyframes ?? [];
+  const bags = [s.initial, ...kfs.flatMap((kf) => TIME_BAGS.map((b) => kf[b]))];
+  const timeInInitial = !!s.initial && s.initial.time !== void 0;
+  const timeInKeyframes = kfs.some((kf) => TIME_BAGS.some((b) => kf[b] && kf[b].time !== void 0));
+  const timed = timeInInitial || timeInKeyframes;
+  if (bags.some((bag) => bag && bag.speed !== void 0)) {
+    warn(`pixi-effects: ${who}: speed is a fixed setting, not an animatable property: write it on the layer (speed: 2); to change the speed over time, animate time (keyframes: [{ at: 0, from: { time: 0 }, to: { time: 4 }, duration: 2, ease: 'power2.in' }])`);
+  }
+  if (!REMAPPABLE.has(spec.type)) {
+    if (timed) warn(`pixi-effects: ${who}: "time" only works on video, audio and composition layers; put this layer in a composition and remap that (it is ignored here)`);
+    return;
+  }
+  if (s.reverse !== void 0) warn(`pixi-effects: ${who}: "reverse" is not a key: write speed: -1 to play backward`);
+  if (s.timeRemap !== void 0) warn(`pixi-effects: ${who}: "timeRemap" is not a key: animate time in keyframes (from / to / set), or write speed`);
+  if (s.time !== void 0) warn(`pixi-effects: ${who}: "time" belongs in initial or keyframes (initial: { time: 2 }), not on the layer`);
+  if (spec.type === "audio" && (s.sfx !== void 0 || s.music !== void 0) && (s.speed !== void 0 || timed)) {
+    warn(`pixi-effects: ${who}: speed and time do not apply to a synthesised sound (sfx, music); change an sfx's pitch with pitch (semitones), or put it in a composition and remap that`);
+    return;
+  }
+  if (s.speed !== void 0 && (typeof s.speed !== "number" || !Number.isFinite(s.speed) || s.speed === 0)) {
+    warn(`pixi-effects: ${who}: speed ${JSON.stringify(s.speed)} cannot be used: write a number other than 0 (negative plays backward); to hold a moment, key time to the same value twice`);
+  }
+  if (s.speed !== void 0 && timeInKeyframes) {
+    warn(`pixi-effects: ${who}: speed and keyframed time are both set; time wins and speed is ignored. Use one of them`);
+  }
+  if (timeInInitial && typeof s.initial.time !== "number") {
+    warn(`pixi-effects: ${who}: initial.time must be a number of seconds, got ${JSON.stringify(s.initial.time)}`);
+  }
+  kfs.forEach((kf, i) => {
+    for (const b of TIME_BAGS) {
+      const v = kf[b]?.time;
+      if (v !== void 0 && typeof v !== "number" && typeof v !== "string") warn(`pixi-effects: ${who}: keyframes[${i}].${b}.time must be a number of seconds, got ${JSON.stringify(v)}`);
+    }
+  });
+}
 function lintKeys(spec, warn = defaultWarn) {
   const who = describeLayer(spec);
   const valid = layerKeys(spec);
   if (valid) {
     for (const key of Object.keys(spec)) {
       if (valid.includes(key) || spec[key] === void 0) continue;
+      if (REMAPPABLE.has(spec.type) && REMAP_NAMES.has(key)) continue;
       const guess = suggestName(key, valid.filter((k) => k !== "type"));
       const owners = kindsWithKey(key);
       const belongs = owners.length ? ` (it belongs to ${owners.slice(0, 3).join(", ")})` : "";
@@ -1539,12 +1649,13 @@ function lintKeys(spec, warn = defaultWarn) {
       warn(`pixi-effects: ${who}: "${key}" is not a ${kindName(spec)} key${hint}. Valid keys: ${valid.join(", ")}`);
     }
   }
+  lintRemap(spec, warn);
   const said = /* @__PURE__ */ new Set();
   const bags = [spec.initial, ...(spec.keyframes ?? []).flatMap((kf) => [kf.set, kf.to, kf.from])];
   for (const bag of bags) {
     for (const key of Object.keys(bag ?? {})) {
       if (bag[key] === void 0) continue;
-      if (PROP_KEYS.has(key) || key.includes(".") || /^gradient/i.test(key) || said.has(key)) continue;
+      if (PROP_KEYS.has(key) || key.includes(".") || /^gradient/i.test(key) || said.has(key) || key === "speed") continue;
       said.add(key);
       const guess = suggestName(key, [...PROP_KEYS]);
       warn(`pixi-effects: ${who}: "${key}" is not an animatable property${guess ? ` \u2014 did you mean "${guess}"?` : ""} (in initial, set, to or from). See the cheatsheet for the properties of this kind of layer`);
@@ -1558,6 +1669,116 @@ function lintKeys(spec, warn = defaultWarn) {
     }
   }
 }
+var BAGS = ["set", "to", "from"];
+function timeRemapOf(spec, prop = "time") {
+  const hasInitial = !!spec.initial && "time" in spec.initial;
+  const hasKf = (spec.keyframes ?? []).some((kf) => BAGS.some((b) => kf[b] && "time" in kf[b]));
+  const speed = typeof spec.speed === "number" && Number.isFinite(spec.speed) && spec.speed !== 0 ? spec.speed : void 0;
+  if (!hasInitial && !hasKf && speed === void 0) return null;
+  const timeKfs = [];
+  const restKfs = [];
+  for (const kf of spec.keyframes ?? []) {
+    const t = { ...kf }, r = { ...kf };
+    let touched = false, left = false;
+    for (const b of BAGS) {
+      const bag = kf[b];
+      if (!bag) {
+        delete t[b];
+        delete r[b];
+        continue;
+      }
+      const { time, ...others } = bag;
+      if ("time" in bag) {
+        touched = true;
+        t[b] = { [prop]: time };
+      } else delete t[b];
+      if (Object.keys(others).length) {
+        r[b] = others;
+        left = true;
+      } else delete r[b];
+    }
+    if (touched) timeKfs.push(t);
+    if (!touched || left) restKfs.push(r);
+  }
+  let restInitial = spec.initial;
+  let start;
+  if (hasInitial) {
+    const { time, ...others } = spec.initial;
+    start = typeof time === "number" && Number.isFinite(time) ? time : void 0;
+    restInitial = others;
+  }
+  return { timeKfs, restKfs: restKfs.length ? restKfs : void 0, restInitial, start, speed };
+}
+function resolveFromEnd(remap, length, prop) {
+  const fix = (v) => typeof v === "number" && v < 0 ? Math.max(0, length + v) : v;
+  const timeKfs = remap.timeKfs.map((kf) => {
+    const out = { ...kf };
+    for (const b of BAGS) {
+      const bag = kf[b];
+      if (bag && prop in bag) out[b] = { ...bag, [prop]: fix(bag[prop]) };
+    }
+    return out;
+  });
+  return { ...remap, timeKfs, start: remap.start === void 0 ? void 0 : fix(remap.start) };
+}
+function remapOf(spec, prop, length) {
+  const r = timeRemapOf(spec, prop);
+  return r && length !== null ? resolveFromEnd(r, length, prop) : r;
+}
+function contentLength(remap, duration) {
+  let m = duration;
+  if (remap.speed !== void 0) m = Math.max(m, Math.abs(remap.speed) * duration);
+  if (remap.start !== void 0) m = Math.max(m, remap.start + (remap.speed ?? 1) * duration);
+  for (const kf of remap.timeKfs) {
+    for (const b of BAGS) {
+      const bag = kf[b];
+      const v = bag && Object.values(bag)[0];
+      if (typeof v === "number") m = Math.max(m, v);
+    }
+  }
+  return m;
+}
+function bindClock(timeline, clock, prop, remap, duration, at, scope) {
+  if (remap.timeKfs.length) {
+    if (remap.start !== void 0) timeline.set(clock, { [prop]: remap.start }, at);
+    applyKeyframes(timeline, clock, remap.timeKfs, duration, scope, [], at);
+    return;
+  }
+  const s = remap.speed ?? 1;
+  const from = remap.start ?? (s < 0 ? -s * duration : 0);
+  timeline.fromTo(clock, { [prop]: from }, { [prop]: from + s * duration, duration, ease: "none" }, at);
+}
+function clockTable(remap, prop, duration, at, scope, to) {
+  const probe = gsap.timeline({ paused: true });
+  const clock = { [prop]: remap.start ?? 0 };
+  bindClock(probe, clock, prop, remap, duration, at, scope);
+  probe.time(probe.duration());
+  probe.time(0);
+  const h = 1 / 1e3;
+  const n = Math.max(2, Math.ceil(to / h) + 2);
+  const tab = new Float64Array(n);
+  let min = Infinity, max = -Infinity;
+  for (let k = 0; k < n; k++) {
+    probe.time(k * h);
+    const v = clock[prop];
+    tab[k] = v;
+    const t = k * h;
+    if (t >= at && t <= at + duration) {
+      if (v < min) min = v;
+      if (v > max) max = v;
+    }
+  }
+  probe.kill();
+  return {
+    at(t) {
+      const x = Math.min(Math.max(t / h, 0), n - 1.000001);
+      const k = Math.floor(x), f = x - k;
+      return tab[k] * (1 - f) + tab[k + 1] * f;
+    },
+    min: Number.isFinite(min) ? min : 0,
+    max: Number.isFinite(max) ? max : 0
+  };
+}
 
 // src/space/math.ts
 var DEG = Math.PI / 180;
@@ -2458,6 +2679,7 @@ var AudioSequence = class extends Sequence {
   _audioBuffer = null;
   _synth = null;
   _source = "";
+  _remap = null;
   async build() {
     this.target = null;
     if (this.spec.music !== void 0) return this._buildMusic(this.spec);
@@ -2466,13 +2688,16 @@ var AudioSequence = class extends Sequence {
     this._source = `asset "${spec.asset}"`;
     const data = await Assets.get(spec.asset);
     this._audioBuffer = data.audioBuffer;
+    this._remap = remapOf(spec, "time", data.duration ?? null);
+    const constant = this._remap && this._remap.timeKfs.length === 0 ? Math.abs(this._remap.speed ?? 1) : 1;
     if (this.duration === void 0) {
       const rest = Math.max(0, (this.parent?.duration ?? this.root.duration) - this.at);
-      this.duration = spec.duration ?? (spec.loop ? rest : data.duration) ?? this.root.duration;
+      this.duration = spec.duration ?? (spec.loop ? rest : data.duration !== void 0 ? data.duration / constant : void 0) ?? this.root.duration;
     }
-    if (!spec.loop && data.duration !== void 0 && this.duration > data.duration + 0.05) {
+    const playable = this._remap && this._remap.timeKfs.length > 0 ? Infinity : (data.duration ?? Infinity) / constant;
+    if (!spec.loop && Number.isFinite(playable) && this.duration > playable + 0.05) {
       console.warn(
-        `pixi-effects: ${describeLayer(spec)}: audio asset "${spec.asset}" is ${data.duration.toFixed(1)}s but the layer lasts ${this.duration.toFixed(1)}s, so it goes silent after ${data.duration.toFixed(1)}s. Add loop: true, or shorten the layer's duration.`
+        `pixi-effects: ${describeLayer(spec)}: audio asset "${spec.asset}" plays for ${playable.toFixed(1)}s (${data.duration.toFixed(1)}s at speed ${constant}) but the layer lasts ${this.duration.toFixed(1)}s, so it goes silent after ${playable.toFixed(1)}s. Add loop: true, or shorten the layer's duration.`
       );
     }
   }
@@ -2481,7 +2706,7 @@ var AudioSequence = class extends Sequence {
     const raw = spec;
     if (raw.asset !== void 0) console.warn(`pixi-effects: ${who}: has both asset and sfx \u2014 the sfx plays; remove one`);
     if (raw.loop) console.warn(`pixi-effects: ${who}: loop has no effect on an sfx \u2014 to repeat it, add one audio layer per hit (a JS loop)`);
-    const { resolveSfx, renderSfx, sfxKey } = await import('./sfx-S37DDC66.js');
+    const { resolveSfx, renderSfx, sfxKey } = await import('./sfx-U3GM2MED.js');
     const sfx = resolveSfx(spec.sfx, spec.duration, who);
     if (!sfx) return;
     this.duration = sfx.length;
@@ -2500,7 +2725,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-4HDFULNR.js');
+    const { resolveMusic, renderMusic, musicLength, musicKey } = await import('./music-CFEC7HKL.js');
     const music = resolveMusic(spec.music, who);
     if (!music) return;
     const natural = musicLength(music);
@@ -2526,7 +2751,9 @@ var AudioSequence = class extends Sequence {
     const initialVolume = this.spec.volume ?? this.spec.initial?.volume ?? 1;
     const t0 = baseTime + this.at;
     const dur = this.duration;
+    const sourceMap = this._remap ? clockTable(this._remap, "time", dur, t0, this.scope(), t0 + dur).at : void 0;
     out.push({
+      ...sourceMap ? { sourceMap } : {},
       ...this._audioBuffer ? { buffer: this._audioBuffer } : { synth: this._synth },
       layer: describeLayer(this.spec),
       source: this._source,
@@ -2585,7 +2812,7 @@ var FrameCache = class {
     this.capacity = options.capacity ?? 30;
   }
   _key(time) {
-    return Math.round(time * 1e3);
+    return Math.round(time * 1e6);
   }
   async getFrameAt(time) {
     const key = this._key(time);
@@ -2650,6 +2877,15 @@ var FrameCache = class {
   }
 };
 
+// src/core/sourceTime.ts
+var FRAME_EPS = 5e-5;
+function sourceLookup(v, sourceDuration, loop) {
+  if (!(sourceDuration > 0)) return Math.max(0, v);
+  const w = v + FRAME_EPS;
+  if (loop) return (w % sourceDuration + sourceDuration) % sourceDuration;
+  return Math.min(Math.max(w, 0), sourceDuration);
+}
+
 // src/sequences/Video.ts
 var VideoSequence = class extends Sequence {
   _sourceDuration = 0;
@@ -2658,9 +2894,15 @@ var VideoSequence = class extends Sequence {
   _canvas = null;
   _ctx = null;
   _drawSeq = 0;
+  /** The playhead value (seconds in the file) the timeline last wrote: already remapped, and local inside a remapped composition. */
+  _cur = 0;
+  _remap = null;
+  /** Movie asks this layer to draw the frame its own timeline is at, not the one for a time it computed. */
+  selfTimed = true;
   async build() {
     const data = await Assets.get(this.spec.asset);
     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 });
     const probeFrame = await this._cache.getFrameAt(0);
@@ -2679,7 +2921,8 @@ var VideoSequence = class extends Sequence {
     this.intrinsicWidth = w;
     this.intrinsicHeight = h;
     if (this.duration === void 0) {
-      this.duration = this.spec.duration ?? data.duration ?? this.root.duration;
+      const constant = this._remap && this._remap.timeKfs.length === 0 ? Math.abs(this._remap.speed ?? 1) : 1;
+      this.duration = this.spec.duration ?? (data.duration ?? this.root.duration * constant) / constant;
     }
     let currentTime = 0;
     const seq = this;
@@ -2689,8 +2932,9 @@ var VideoSequence = class extends Sequence {
       },
       set(v) {
         currentTime = v;
+        seq._cur = v;
         const mySeq = ++seq._drawSeq;
-        const lookup = seq.spec.loop && seq._sourceDuration > 0 ? v % seq._sourceDuration : v;
+        const lookup = sourceLookup(v, seq._sourceDuration, !!seq.spec.loop);
         seq._cache.getFrameAt(lookup).then((frame) => {
           if (mySeq !== seq._drawSeq) return;
           if (!frame || !seq._ctx) return;
@@ -2703,21 +2947,33 @@ var VideoSequence = class extends Sequence {
     });
     this.buildFilters();
   }
+  displayProps() {
+    const r = this._remap;
+    return r ? { initial: r.restInitial, keyframes: r.restKfs } : super.displayProps();
+  }
   bindTimeline(timeline, offset = 0) {
     super.bindTimeline(timeline, offset);
+    const at = offset + this.at;
+    if (this._remap) {
+      bindClock(timeline, this.target, "currentTime", this._remap, this.duration, at, this.scope());
+      return;
+    }
     const playDuration = this.spec.loop ? this.duration : Math.min(this.duration, this._sourceDuration);
     timeline.fromTo(
       this.target,
       { currentTime: 0 },
       { currentTime: playDuration, duration: playDuration, ease: "none" },
-      offset + this.at
+      at
       // offset = start of the enclosing composition(s); dropping it misplaced videos inside nested compositions
     );
   }
   collectAudio(out, baseTime) {
     if (!this._audioBuffer) return;
     const initialVolume = this.spec.volume ?? 1;
+    const t0 = baseTime + this.at;
+    const sourceMap = this._remap ? clockTable(this._remap, "currentTime", this.duration, t0, this.scope(), t0 + this.duration).at : void 0;
     out.push({
+      ...sourceMap ? { sourceMap } : {},
       buffer: this._audioBuffer,
       layer: describeLayer(this.spec),
       source: `video "${this.spec.asset}"`,
@@ -2728,9 +2984,12 @@ var VideoSequence = class extends Sequence {
       volumeKeyframes: []
     });
   }
-  async awaitFrameAt(time) {
+  /** Draw the frame the playhead is at NOW (`_cur`). The argument (a time Movie worked out for layers that need it) is not used. */
+  async awaitFrameAt(_time) {
+    const time = this._cur;
+    if (!this.keepHidden && !this.target?.renderable) return;
     const mySeq = ++this._drawSeq;
-    const lookup = this.spec.loop && this._sourceDuration > 0 ? time % this._sourceDuration : time;
+    const lookup = sourceLookup(time, this._sourceDuration, !!this.spec.loop);
     let frame = null;
     try {
       frame = await this._cache.getFrameAt(lookup);
@@ -3460,7 +3719,7 @@ function numOrZero(v, scope) {
 var _CompositionSequence = null;
 async function getCompositionSequence() {
   if (!_CompositionSequence) {
-    _CompositionSequence = (await import('./Composition-QBKEEJBV.js')).CompositionSequence;
+    _CompositionSequence = (await import('./Composition-6PA4C4TV.js')).CompositionSequence;
   }
   return _CompositionSequence;
 }
@@ -3498,6 +3757,6 @@ async function buildSequenceTree(specs, parent, root) {
   return out;
 }
 
-export { CameraSequence, DEFAULT_FOV, DEG, NEAR, NullSequence, Sequence, buildScope, buildSequenceTree, cameraBasis, checkEase, collectPropKeys, describeLayer, ensureFilterLibrary, evaluateExpr, flattenSvgPath, homeCamera, homeDistance, lintKeys, lintText, lintTiming, noise, projectLayer, rand, random, registerSequenceType, resolveAt, summarizeWarnings };
-//# sourceMappingURL=chunk-YRXTKOV5.js.map
-//# sourceMappingURL=chunk-YRXTKOV5.js.map
+export { CameraSequence, DEFAULT_FOV, DEG, NEAR, NullSequence, Sequence, bindClock, buildScope, buildSequenceTree, cameraBasis, checkEase, clockTable, collectPropKeys, contentLength, describeLayer, ensureFilterLibrary, evaluateExpr, flattenSvgPath, homeCamera, homeDistance, lintKeys, lintText, lintTiming, noise, projectLayer, rand, random, registerSequenceType, remapOf, resolveAt, summarizeWarnings, timeRemapOf };
+//# sourceMappingURL=chunk-DQHXVNOI.js.map
+//# sourceMappingURL=chunk-DQHXVNOI.js.map