pixi-effects 0.28.2 → 0.30.0

package/dist/index.js

@@ -1,4459 +1,8 @@
-import { CompositionSequence, maskSourceOf } from './chunk-5MZWXVTT.js';
-import { createTimeline, lengthen, ensureFilterLibrary, checkEase, parseEase, homeDistance, DEFAULT_FOV, random, noise, flattenSvgPath, rand, DEG, timeRemapOf, contentLength, resolveAt } from './chunk-7VN2KI3U.js';
-export { Sequence, noise, rand, random, registerSequenceType } from './chunk-7VN2KI3U.js';
-import { usesAdvancedBlend, enableAdvancedBlend } from './chunk-TYWFKCPY.js';
-import { collectPropKeys } from './chunk-45QKLD6M.js';
-import { warnUnknownOptions, suggestName } from './chunk-BXOCEZ4U.js';
-import { extensions, CullerPlugin, Application, Container, Rectangle, Culler, CanvasTextMetrics, TextStyle, Assets, ExtensionType, Filter, Texture, UniformGroup, GpuProgram, GlProgram, defaultFilterVert } from 'pixi.js';
-import { Output, BufferTarget, CanvasSource, AudioBufferSource, Input, ALL_FORMATS, BlobSource, WavOutputFormat, Conversion, VideoSampleSink, OggOutputFormat, QUALITY_VERY_HIGH, QUALITY_HIGH, QUALITY_MEDIUM, QUALITY_LOW, QUALITY_VERY_LOW, MkvOutputFormat, WebMOutputFormat, MovOutputFormat, Mp4OutputFormat, canEncodeVideo, getFirstEncodableAudioCodec } from 'mediabunny';
-
-var registered = false;
-function ensureLoadersRegistered(audioContext) {
-  if (registered) return;
-  registered = true;
-  extensions.add({
-    extension: { type: ExtensionType.LoadParser, name: "pixi-effects-audio" },
-    test: (url) => /\.(mp3|wav|ogg)$/i.test(url),
-    async load(url) {
-      const res = await fetch(url);
-      if (!res.ok) throw new Error(`pixi-effects: failed to load ${url}: ${res.statusText}`);
-      const buffer = await res.arrayBuffer();
-      const audioBuffer = await audioContext.decodeAudioData(buffer);
-      return { audioBuffer, duration: audioBuffer.duration };
-    }
-  });
-  extensions.add({
-    extension: { type: ExtensionType.LoadParser, name: "pixi-effects-video", priority: 1 },
-    test: (url) => /\.(mp4|webm|mov|mkv)$/i.test(url),
-    async load(url) {
-      const blob = await fetch(url).then((r) => r.blob());
-      const input = new Input({ source: new BlobSource(blob), formats: ALL_FORMATS });
-      const videoTrack = await input.getPrimaryVideoTrack();
-      if (!videoTrack || !await videoTrack.canDecode()) {
-        throw new Error("pixi-effects: video track cannot be decoded");
-      }
-      const audioTrack = await input.getPrimaryAudioTrack();
-      const videoDuration = await videoTrack.computeDuration();
-      const audioDuration = audioTrack ? await audioTrack.computeDuration() : 0;
-      let audioBuffer = null;
-      if (audioTrack) {
-        try {
-          const out = new Output({ format: new WavOutputFormat(), target: new BufferTarget() });
-          const conv = await Conversion.init({ input, output: out, video: { discard: true } });
-          await conv.execute();
-          audioBuffer = await audioContext.decodeAudioData(out.target.buffer);
-        } catch (e) {
-          console.warn("pixi-effects: audio extraction failed:", e);
-        }
-      }
-      return {
-        videoTrack,
-        audioBuffer,
-        videoDuration,
-        audioDuration,
-        duration: Math.max(videoDuration, audioDuration),
-        sink: new VideoSampleSink(videoTrack)
-      };
-    }
-  });
-}
-async function loadAssetBundle(assets, audioContext, onProgress) {
-  ensureLoadersRegistered(audioContext);
-  const bundle = assets.map((a) => ({ alias: a.name, src: a.src }));
-  Assets.addBundle("pixi-effects", bundle);
-  return await Assets.loadBundle("pixi-effects", onProgress);
-}
-
-// src/core/audioRemap.ts
-function gainAt(a, u) {
-  let prevT = a.start, prevV = a.initialVolume ?? 1;
-  if (u <= prevT) return prevV;
-  for (const kf of a.volumeKeyframes ?? []) {
-    if (u <= kf.time) return kf.time === prevT ? kf.value : prevV + (kf.value - prevV) * ((u - prevT) / (kf.time - prevT));
-    prevT = kf.time;
-    prevV = kf.value;
-  }
-  return prevV;
-}
-var CELL = 1 / 1e3;
-function resampleThrough(a, left, right, srcRate, outRate, total) {
-  const nCell = Math.ceil(total / CELL) + 2;
-  const U = new Float64Array(nCell);
-  let first = -1, last = -1;
-  for (let k = 0; k < nCell; k++) {
-    const u = a.warp ? a.warp(k * CELL) : k * CELL;
-    U[k] = u;
-    if (Number.isFinite(u) && u >= a.start && u < a.end) {
-      if (first < 0) first = k;
-      last = k;
-    }
-  }
-  if (first < 0) return null;
-  const lo = Math.max(0, (first - 1) * CELL), hi = Math.min(total, (last + 2) * CELL);
-  const n = Math.max(1, Math.ceil((hi - lo) * outRate));
-  const L = new Float32Array(n), R = new Float32Array(n);
-  const dur = left.length / srcRate;
-  let prevPos = NaN;
-  for (let i = 0; i < n; i++) {
-    const T = lo + i / outRate;
-    const x = T / CELL, k = Math.min(Math.floor(x), nCell - 2), f = x - k;
-    const u0 = U[k], u1 = U[k + 1];
-    if (!(Number.isFinite(u0) && Number.isFinite(u1))) {
-      prevPos = NaN;
-      continue;
-    }
-    const u = u0 * (1 - f) + u1 * f;
-    if (u < a.start || u >= a.end) {
-      prevPos = NaN;
-      continue;
-    }
-    const raw = a.sourceMap ? a.sourceMap(u) : u - a.start;
-    let pos = raw;
-    if (a.loop) pos = (pos % dur + dur) % dur;
-    const rate = Number.isNaN(prevPos) ? 1 : Math.abs(raw - prevPos) * outRate;
-    prevPos = raw;
-    if (pos < 0 || pos >= dur) continue;
-    const g = gainAt(a, u) * Math.min(1, rate / 0.02);
-    const sp = pos * srcRate, j = Math.floor(sp), fr = sp - j, j1 = Math.min(j + 1, left.length - 1);
-    L[i] = (left[j] * (1 - fr) + left[j1] * fr) * g;
-    R[i] = (right[j] * (1 - fr) + right[j1] * fr) * g;
-  }
-  return { L, R, at: lo };
-}
-function playSpan(a, total) {
-  if (!a.warp) return { start: a.start, end: a.end };
-  let first = -1, last = -1;
-  const n = Math.ceil(total / CELL) + 1;
-  for (let k = 0; k <= n; k++) {
-    const u = a.warp(k * CELL);
-    if (Number.isFinite(u) && u >= a.start && u < a.end) {
-      if (first < 0) first = k;
-      last = k;
-    }
-  }
-  return first < 0 ? { start: total, end: total } : { start: first * CELL, end: (last + 1) * CELL };
-}
-function clockReach(a, total) {
-  let reach = -Infinity;
-  const n = Math.ceil(total / CELL) + 1;
-  for (let k = 0; k <= n; k++) {
-    const u = a.warp ? a.warp(k * CELL) : k * CELL;
-    if (Number.isFinite(u) && u > reach) reach = u;
-  }
-  return reach;
-}
-
-// src/core/AudioMixer.ts
-async function mixdown(audios, totalDuration, sampleRate = 44100, pace) {
-  if (audios.length === 0) return null;
-  const weight = (a) => a.synth ? Math.max(1, a.end - a.start) : 0.2;
-  const all = audios.reduce((s, a) => s + weight(a), 0) + 0.5;
-  let made = 0;
-  const ctx = new OfflineAudioContext(2, Math.ceil(sampleRate * totalDuration), sampleRate);
-  const synthesised = /* @__PURE__ */ new Map();
-  const bufferOf = async (a, inner) => {
-    if (a.buffer) return a.buffer;
-    if (!a.synth) return null;
-    let buf = synthesised.get(a.synth.key);
-    if (!buf) {
-      const [left, right] = a.synth.renderAsync ? await a.synth.renderAsync(sampleRate, inner) : a.synth.render(sampleRate);
-      buf = ctx.createBuffer(2, left.length, sampleRate);
-      buf.getChannelData(0).set(left);
-      buf.getChannelData(1).set(right);
-      synthesised.set(a.synth.key, buf);
-    }
-    return buf;
-  };
-  for (const a of audios) {
-    const w = weight(a), base = made;
-    const buffer = await bufferOf(a, pace ? (f) => pace((base + w * f) / all) : void 0);
-    made += w;
-    if (pace) await pace(made / all);
-    if (!buffer) continue;
-    if (a.warp || a.sourceMap) {
-      const r = resampleThrough(a, buffer.getChannelData(0), buffer.numberOfChannels > 1 ? buffer.getChannelData(1) : buffer.getChannelData(0), buffer.sampleRate, sampleRate, totalDuration);
-      if (!r) continue;
-      const out = ctx.createBuffer(2, r.L.length, sampleRate);
-      out.getChannelData(0).set(r.L);
-      out.getChannelData(1).set(r.R);
-      const rendered = ctx.createBufferSource();
-      rendered.buffer = out;
-      rendered.connect(ctx.destination);
-      rendered.start(r.at);
-      continue;
-    }
-    const begin = Math.max(0, a.start);
-    const skipped = begin - a.start;
-    if (skipped > 0) {
-      console.warn(
-        `pixi-effects: ${a.layer ?? "an audio layer"} starts at ${a.start.toFixed(2)}s, before the movie starts, so its first ${skipped.toFixed(2)}s are cut off. Start it at 0 or later.`
-      );
-    }
-    const src = ctx.createBufferSource();
-    src.buffer = buffer;
-    src.loop = !!a.loop;
-    const gain = ctx.createGain();
-    gain.gain.setValueAtTime(a.initialVolume ?? 1, begin);
-    for (const kf of a.volumeKeyframes ?? []) {
-      gain.gain.linearRampToValueAtTime(kf.value, Math.max(0, kf.time));
-    }
-    src.connect(gain).connect(ctx.destination);
-    src.start(begin, skipped);
-    src.stop(Math.max(begin, a.end));
-  }
-  return await ctx.startRendering();
-}
-var KNEE = 0.9;
-function limitMix(buffer, audios) {
-  let peak = 0;
-  let peakIndex = 0;
-  for (let ch = 0; ch < buffer.numberOfChannels; ch++) {
-    const d = buffer.getChannelData(ch);
-    for (let i = 0; i < d.length; i++) {
-      const x = Math.abs(d[i]);
-      if (x > peak) {
-        peak = x;
-        peakIndex = i;
-      }
-      if (x > KNEE) d[i] = Math.sign(d[i]) * (KNEE + (1 - KNEE) * Math.tanh((x - KNEE) / (1 - KNEE)));
-    }
-  }
-  const peakAt = peakIndex / buffer.sampleRate;
-  if (peak > 1) {
-    const playing = audios.map((a) => ({ a, ...playSpan(a, buffer.duration) })).filter((s) => s.start <= peakAt && peakAt < s.end).map((s) => s.a.layer ?? "an audio layer");
-    console.warn(
-      `pixi-effects: the audio mix peaks at ${peak.toFixed(2)} (${(20 * Math.log10(peak)).toFixed(1)} dBFS) at ${peakAt.toFixed(2)}s, so it was limited (it would distort). Playing there: ${[...new Set(playing)].join(", ")}. Lower their volume.`
-    );
-  }
-  return { peak, peakAt };
-}
-
-// src/core/spectrum.ts
-function fft(re, im) {
-  const n = re.length;
-  for (let i = 1, j = 0; i < n; i++) {
-    let bit = n >> 1;
-    for (; j & bit; bit >>= 1) j ^= bit;
-    j ^= bit;
-    if (i < j) {
-      [re[i], re[j]] = [re[j], re[i]];
-      [im[i], im[j]] = [im[j], im[i]];
-    }
-  }
-  for (let len = 2; len <= n; len <<= 1) {
-    const ang = -2 * Math.PI / len;
-    for (let i = 0; i < n; i += len) {
-      for (let k = 0; k < len / 2; k++) {
-        const wr = Math.cos(ang * k), wi = Math.sin(ang * k);
-        const a = i + k, b = a + len / 2;
-        const xr = re[b] * wr - im[b] * wi, xi = re[b] * wi + im[b] * wr;
-        re[b] = re[a] - xr;
-        im[b] = im[a] - xi;
-        re[a] = re[a] + xr;
-        im[a] = im[a] + xi;
-      }
-    }
-  }
-}
-var FRAME = 2048;
-function spectralCentroid(samples, sampleRate, from = 0, to = samples.length) {
-  let num3 = 0;
-  let den = 0;
-  const re = new Float64Array(FRAME);
-  const im = new Float64Array(FRAME);
-  const end = Math.min(to, samples.length);
-  for (let start = Math.max(0, from); start < end; start += FRAME / 2) {
-    for (let i = 0; i < FRAME; i++) {
-      const k = start + i;
-      const w = 0.5 - 0.5 * Math.cos(2 * Math.PI * i / (FRAME - 1));
-      re[i] = k < end ? samples[k] * w : 0;
-      im[i] = 0;
-    }
-    fft(re, im);
-    for (let b = 1; b < FRAME / 2; b++) {
-      const power = re[b] * re[b] + im[b] * im[b];
-      num3 += power * (b * sampleRate / FRAME);
-      den += power;
-    }
-  }
-  return den > 1e-9 ? Math.round(num3 / den / 10) * 10 : 0;
-}
-
-// src/audio/loudness.ts
-var LOUDNESS_NOTES = { quietBelow: -24, loudAbove: -9, headroomDb: -1 };
-function kWeighting(fs) {
-  const f0 = 1681.974450955533, G = 3.999843853973347, Q = 0.7071752369554196;
-  const K = Math.tan(Math.PI * f0 / fs), Vh = 10 ** (G / 20), Vb = Vh ** 0.4996667741545416;
-  const a0 = 1 + K / Q + K * K;
-  const shelf = {
-    b: [(Vh + Vb * K / Q + K * K) / a0, 2 * (K * K - Vh) / a0, (Vh - Vb * K / Q + K * K) / a0],
-    a: [1, 2 * (K * K - 1) / a0, (1 - K / Q + K * K) / a0]
-  };
-  const f1 = 38.13547087602444, Q1 = 0.5003270373238773, K1 = Math.tan(Math.PI * f1 / fs), a1 = 1 + K1 / Q1 + K1 * K1;
-  const high = { b: [1, -2, 1], a: [1, 2 * (K1 * K1 - 1) / a1, (1 - K1 / Q1 + K1 * K1) / a1] };
-  return [shelf, high];
-}
-function filter(x, stages) {
-  let cur = x;
-  for (const { b, a } of stages) {
-    const out = new Float32Array(cur.length);
-    let x1 = 0, x2 = 0, y1 = 0, y2 = 0;
-    for (let i = 0; i < cur.length; i++) {
-      const xi = cur[i], y = b[0] * xi + b[1] * x1 + b[2] * x2 - a[1] * y1 - a[2] * y2;
-      x2 = x1;
-      x1 = xi;
-      y2 = y1;
-      y1 = y;
-      out[i] = y;
-    }
-    cur = out;
-  }
-  return cur;
-}
-var toDb = (x) => Math.round(200 * Math.log10(Math.max(x, 1e-6))) / 10;
-var TP_HALF = 12;
-var TP_BLOCK = 32;
-var TP_KERNELS = [0.25, 0.5, 0.75].map((p) => Float64Array.from({ length: 2 * TP_HALF }, (_, j) => {
-  const k = j - TP_HALF + 1, x = k - p, s = x === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
-  return s * (0.5 + 0.5 * Math.cos(Math.PI * x / (TP_HALF + 1)));
-}));
-var TP_GAIN = Math.max(...TP_KERNELS.map((k) => k.reduce((a, v) => a + Math.abs(v), 0)));
-function truePeak(chans) {
-  let peak = 0;
-  for (const c of chans) {
-    const n = c.length;
-    const blocks = Math.ceil(n / TP_BLOCK), blockMax = new Float32Array(blocks + 2);
-    for (let i = 0; i < n; i++) {
-      const a = Math.abs(c[i]), b = (i / TP_BLOCK | 0) + 1;
-      if (a > blockMax[b]) blockMax[b] = a;
-      if (a > peak) peak = a;
-    }
-    const padded = new Float32Array(n + 2 * TP_HALF);
-    padded.set(c, TP_HALF);
-    for (let i = 0; i < n; i++) {
-      const b = (i / TP_BLOCK | 0) + 1;
-      const local = Math.max(blockMax[b - 1], blockMax[b], blockMax[b + 1]);
-      if (local * TP_GAIN <= peak) continue;
-      for (let pi = 0; pi < 3; pi++) {
-        const k = TP_KERNELS[pi];
-        let v = 0;
-        for (let j = 0; j < 2 * TP_HALF; j++) v += padded[i + 1 + j] * k[j];
-        const a = Math.abs(v);
-        if (a > peak) peak = a;
-      }
-    }
-  }
-  return peak;
-}
-function measureLoudness(channels, sampleRate, opts = {}) {
-  let samplePeak = 0, clipped = 0;
-  for (const c of channels) for (let i = 0; i < c.length; i++) {
-    const a = Math.abs(c[i]);
-    if (a > samplePeak) samplePeak = a;
-    if (a >= 1) clipped++;
-  }
-  const stages = kWeighting(sampleRate);
-  const weighted = channels.map((c) => filter(c, stages));
-  const block = Math.round(0.4 * sampleRate), hop = Math.round(0.1 * sampleRate);
-  const energies = [];
-  for (let s = 0; s + block <= (weighted[0]?.length ?? 0); s += hop) {
-    let sum = 0;
-    for (const w of weighted) {
-      let z = 0;
-      for (let i = s; i < s + block; i++) z += w[i] * w[i];
-      sum += z / block;
-    }
-    energies.push(sum);
-  }
-  const lufs = (e) => -0.691 + 10 * Math.log10(e);
-  const absolute = energies.filter((e) => e > 0 && lufs(e) > -70);
-  let integrated = null;
-  if (absolute.length) {
-    const relative = lufs(absolute.reduce((a, b) => a + b, 0) / absolute.length) - 10;
-    const gated = absolute.filter((e) => lufs(e) > relative);
-    if (gated.length) integrated = Math.round(10 * lufs(gated.reduce((a, b) => a + b, 0) / gated.length)) / 10;
-  }
-  return { integratedLufs: integrated, truePeakDb: opts.truePeak === false ? null : toDb(truePeak(channels)), samplePeakDb: toDb(samplePeak), clippedSamples: clipped };
-}
-function findSilences(channels, sampleRate, opts = {}) {
-  const min = Math.round((opts.minLength ?? 1) * sampleRate), limit = 10 ** ((opts.thresholdDb ?? -60) / 20);
-  const n = channels[0]?.length ?? 0, out = [];
-  let start = -1;
-  const quiet = (i) => channels.every((c) => Math.abs(c[i]) < limit);
-  for (let i = 0; i <= n; i++) {
-    const q = i < n && quiet(i);
-    if (q && start < 0) start = i;
-    if (!q && start >= 0) {
-      if (i - start >= min) out.push({ from: Math.round(start / sampleRate * 1e3) / 1e3, to: Math.round(i / sampleRate * 1e3) / 1e3 });
-      start = -1;
-    }
-  }
-  return out;
-}
-
-// src/core/inspectAudio.ts
-var INAUDIBLE_DB = -50;
-var db = (x) => Math.round(10 * Math.max(-120, 20 * Math.log10(x))) / 10;
-var mono = (chans) => {
-  if (chans.length === 1) return chans[0];
-  const out = new Float32Array(chans[0].length);
-  for (const d of chans) for (let i = 0; i < out.length; i++) out[i] = out[i] + d[i] / chans.length;
-  return out;
-};
-function measure(chans, sampleRate) {
-  let peak = 0;
-  let at = 0;
-  for (const d of chans) for (let i = 0; i < d.length; i++) if (Math.abs(d[i]) > peak) {
-    peak = Math.abs(d[i]);
-    at = i;
-  }
-  return {
-    length: Math.round(chans[0].length / sampleRate * 1e3) / 1e3,
-    peakDb: db(peak),
-    loudestAt: Math.round(at / sampleRate * 1e3) / 1e3,
-    brightnessHz: spectralCentroid(mono(chans), sampleRate)
-  };
-}
-function analyzeAudio(mix, sources, stats, movieDuration, opts = {}) {
-  const warped = /* @__PURE__ */ new Map();
-  sources = sources.map((s) => {
-    if (!s.warp) return s;
-    const moved = { ...s, ...playSpan(s, movieDuration) };
-    warped.set(moved, { localEnd: s.end, reach: clockReach(s, movieDuration) });
-    return moved;
-  });
-  if (!mix) {
-    return {
-      duration: movieDuration,
-      sampleRate: 0,
-      peakDb: -120,
-      peakAt: 0,
-      sources: [],
-      windows: [],
-      loudness: { integratedLufs: null, truePeakDb: -120, clippedSamples: 0, silences: [] },
-      scenes: [],
-      cues: [],
-      notes: [],
-      issues: ['no audio: the movie has no audio layers (sound effects need no files: { type: "audio", sfx: "pop", at: 1 })']
-    };
-  }
-  const sr = mix.sampleRate;
-  const chans = Array.from({ length: mix.numberOfChannels }, (_, c) => mix.getChannelData(c));
-  const mixMono = mono(chans);
-  const peakIn = (t0, t1) => {
-    let p = 0;
-    const i1 = Math.min(mix.length, Math.ceil(t1 * sr));
-    for (const d of chans) for (let i = Math.max(0, Math.floor(t0 * sr)); i < i1; i++) p = Math.max(p, Math.abs(d[i]));
-    return p;
-  };
-  const win = opts.window && opts.window > 0 ? Math.max(0.01, opts.window) : 0.1;
-  const windows2 = [];
-  for (let t = 0; t < movieDuration - 1e-9; t += win) {
-    const i0 = Math.floor(t * sr);
-    const i1 = Math.min(mix.length, Math.floor((t + win) * sr));
-    let sum = 0;
-    let peak = 0;
-    for (const d of chans) {
-      for (let i = i0; i < i1; i++) {
-        sum += d[i] * d[i];
-        peak = Math.max(peak, Math.abs(d[i]));
-      }
-    }
-    const n = Math.max(1, (i1 - i0) * chans.length);
-    windows2.push({ t: Math.round(t * 1e3) / 1e3, rmsDb: db(Math.sqrt(sum / n)), peakDb: db(peak), brightnessHz: spectralCentroid(mixMono, sr, i0, i1) });
-  }
-  const issues = [];
-  if (stats && stats.peak > 1) {
-    issues.push(`the mix peaks at ${db(stats.peak)} dBFS at ${stats.peakAt.toFixed(2)}s and was limited \u2014 lower the volume of the layers playing there`);
-  }
-  const rendered = /* @__PURE__ */ new Map();
-  const soundOf = (s) => {
-    if (s.synth) {
-      let m = rendered.get(s.synth.key);
-      if (!m) rendered.set(s.synth.key, m = measure(s.synth.render(sr), sr));
-      return m;
-    }
-    const b = s.buffer;
-    return measure(Array.from({ length: b.numberOfChannels }, (_, c) => b.getChannelData(c)), b.sampleRate);
-  };
-  const list = [...sources].sort((a, b) => a.start - b.start).map((s) => {
-    const layer = s.layer ?? "an audio layer";
-    const source = s.source ?? "audio";
-    const peakDb = db(peakIn(s.start, Math.min(s.end, movieDuration)));
-    const sound = soundOf(s);
-    const topVolume = Math.max(s.initialVolume ?? 1, ...(s.volumeKeyframes ?? []).map((k) => k.value));
-    const ownDb = db(Math.pow(10, sound.peakDb / 20) * Math.max(0, topVolume));
-    if (s.start >= movieDuration) {
-      issues.push(`${layer} (${source}) starts at ${s.start.toFixed(2)}s, after the movie ends (${movieDuration}s)`);
-    } else if (ownDb < INAUDIBLE_DB || peakDb < INAUDIBLE_DB) {
-      issues.push(`${layer} (${source}) is inaudible from ${s.start.toFixed(2)}s to ${s.end.toFixed(2)}s (its own peak ${ownDb} dBFS at volume ${topVolume}; mix peak there ${peakDb} dBFS) \u2014 check its volume`);
-    }
-    const clock = warped.get(s);
-    if (s.synth && s.start < movieDuration) {
-      if (clock) {
-        if (clock.reach < clock.localEnd - 1e-3) {
-          issues.push(`${layer} (${source}) is cut off: its composition's clock only reaches ${clock.reach.toFixed(2)}s (the sound is ${clock.localEnd.toFixed(2)}s long), because the clock stops or the movie ends first \u2014 give the layer a shorter duration, or let the clock run on`);
-        }
-      } else if (s.end > movieDuration + 1e-6) {
-        issues.push(`${layer} (${source}) is cut off by the end of the movie at ${movieDuration}s (it runs to ${s.end.toFixed(2)}s)`);
-      }
-    }
-    return { layer, source, start: s.start, end: s.end, peakDb, sound, ...s.music ? { music: s.music } : {} };
-  });
-  const whole = measureLoudness(chans, sr);
-  const silences = findSilences(chans, sr, { minLength: 1 });
-  if (whole.clippedSamples > 0) issues.push(`${whole.clippedSamples} sample(s) of the mix are at full scale (clipped) \u2014 lower the volume of the layers that play loudest`);
-  if (whole.truePeakDb > 0) issues.push(`the mix's true peak is ${whole.truePeakDb} dBTP: it will distort when the video is encoded \u2014 lower the volume`);
-  const notes = [];
-  if (whole.integratedLufs !== null) {
-    if (whole.integratedLufs < LOUDNESS_NOTES.quietBelow) notes.push(`the mix is quiet for web video: ${whole.integratedLufs} LUFS (typical \u221214 to \u221216); raise the volume if that is not on purpose`);
-    else if (whole.integratedLufs > LOUDNESS_NOTES.loudAbove) notes.push(`the mix is loud: ${whole.integratedLufs} LUFS (typical web video \u221214 to \u221216)`);
-  }
-  if (whole.truePeakDb > LOUDNESS_NOTES.headroomDb && whole.truePeakDb <= 0) notes.push(`the true peak is ${whole.truePeakDb} dBTP: little headroom left for encoding (keep it below ${LOUDNESS_NOTES.headroomDb} dBTP)`);
-  for (const q of silences.slice(0, 3)) notes.push(`the mix is silent from ${q.from} s to ${q.to} s (${Math.round((q.to - q.from) * 10) / 10} s)`);
-  if (silences.length > 3) notes.push(`and ${silences.length - 3} more silent stretch(es) (loudness.silences lists them all)`);
-  const sceneList = (opts.scenes && opts.scenes.length ? opts.scenes : [{ name: "movie", start: 0, end: movieDuration }]).map((sc) => {
-    const a = Math.max(0, Math.round(sc.start * sr)), b = Math.min(mix.length, Math.round(sc.end * sr));
-    const part = chans.map((c) => c.subarray(a, Math.max(a, b)));
-    const m = measureLoudness(part, sr, { truePeak: false });
-    return { name: sc.name, from: sc.start, to: sc.end, lufs: m.integratedLufs, peakDb: m.samplePeakDb, silent: m.samplePeakDb < -60 };
-  });
-  return {
-    duration: movieDuration,
-    sampleRate: sr,
-    peakDb: db(stats?.peak ?? peakIn(0, movieDuration)),
-    peakAt: stats?.peakAt ?? 0,
-    sources: list,
-    windows: windows2,
-    issues,
-    loudness: { integratedLufs: whole.integratedLufs, truePeakDb: whole.truePeakDb ?? -120, clippedSamples: whole.clippedSamples, silences },
-    scenes: sceneList,
-    cues: list.map((s) => ({ t: s.start, name: `${s.layer} (${s.source})` })),
-    notes
-  };
-}
-
-// src/text/fonts.ts
-var GENERIC = /* @__PURE__ */ new Set(["serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui", "ui-serif", "ui-sans-serif", "ui-monospace", "ui-rounded", "emoji", "math", "fangsong", "-apple-system", "blinkmacsystemfont"]);
-function fontAvailable(family2) {
-  const f = family2.trim().replace(/^["']|["']$/g, "");
-  if (!f || GENERIC.has(f.toLowerCase())) return true;
-  const g = document.createElement("canvas").getContext("2d");
-  if (!g) return true;
-  const sample = "mmmmmmmmmmlliWWWW 0123 \u3042\u3044\u3046";
-  const width = (stack) => {
-    g.font = `72px ${stack}`;
-    return g.measureText(sample).width;
-  };
-  const q = JSON.stringify(f);
-  return width(`${q}, monospace`) !== width("monospace") || width(`${q}, serif`) !== width("serif");
-}
-
-// src/core/inspectFonts.ts
-function inspectFonts(root) {
-  const failed = /* @__PURE__ */ new Set();
-  if (typeof document !== "undefined" && document.fonts) document.fonts.forEach((face) => {
-    if (face.status === "error") failed.add(face.family.replace(/^["']|["']$/g, ""));
-  });
-  const missing = [];
-  const used = /* @__PURE__ */ new Set();
-  const walk2 = (seq, index) => {
-    const spec = seq.spec;
-    if (spec.type === "text") {
-      const raw = spec.style?.fontFamily;
-      const family2 = Array.isArray(raw) ? raw.join(", ") : typeof raw === "string" ? raw : "";
-      const list = family2.split(",").map((f) => f.trim()).filter(Boolean);
-      for (const f of list) used.add(f.replace(/^["']|["']$/g, "").toLowerCase());
-      if (list.length && !list.some(fontAvailable) && !list.some((f) => failed.has(f.replace(/^["']|["']$/g, "")))) missing.push({ layer: spec.name ?? `text#${index}`, family: family2 });
-    }
-    if (seq.maskSequence) walk2(seq.maskSequence, index);
-    (seq._children ?? []).forEach((child, i) => walk2(child, i));
-  };
-  walk2(root, 0);
-  const all = [...failed];
-  return { missing, failed: all.filter((f) => used.has(f.toLowerCase())), failedUnused: all.filter((f) => !used.has(f.toLowerCase())) };
-}
-
-// src/core/scenes.ts
-function namedScenes(rows) {
-  return rows.filter((r) => !r.local && r.depth === 0 && r.type === "composition" && !/[#×]/.test(r.name) && r.end - r.start >= 1).map((r) => ({ name: r.name, start: r.start, end: r.end }));
-}
-
-// src/core/timeFilters.ts
-function collectTimeFilters(seq, out = [], clock = null) {
-  for (const f of seq.filters ?? []) {
-    if (typeof f.setTime === "function") {
-      const tf = f;
-      out.push(clock ? { setTime: () => tf.setTime(clock()) } : tf);
-    }
-  }
-  if (seq.maskSequence) collectTimeFilters(seq.maskSequence, out, clock);
-  const own = seq.localClock?.() ?? clock;
-  for (const child of seq._children ?? []) collectTimeFilters(child, out, own);
-  return out;
-}
-
-// src/core/review.ts
-function sampleFrames({ totalFrames, frameRate, scenes = [], step = 0.25, cap = 240 }) {
-  const last = totalFrames;
-  const clamp2 = (f) => Math.max(0, Math.min(last, Math.round(f)));
-  const edges = /* @__PURE__ */ new Set([0, last]);
-  for (const s of scenes) {
-    edges.add(clamp2(s.start * frameRate));
-    edges.add(clamp2(s.end * frameRate - 1));
-  }
-  const room = Math.max(0, cap - edges.size);
-  const seconds = totalFrames / frameRate;
-  const wanted = Math.floor(seconds / step) + 1;
-  const stride = wanted <= room ? step : seconds / Math.max(1, room);
-  const frames = new Set(edges);
-  for (let t = stride; frames.size < cap && t < seconds; t += stride) frames.add(clamp2(t * frameRate));
-  return [...frames].sort((a, b) => a - b);
-}
-var AT_HELP = "use seconds (3.5), a percentage (50%), a frame (f120) or a layer's start / mid / end (name@end)";
-function resolveAtList(list, ctx) {
-  const { frameRate: fps, totalFrames, duration, rows } = ctx;
-  const out = [], used = /* @__PURE__ */ new Set();
-  const named = rows.filter((r) => !r.local).flatMap((r) => r.parts && r.partNames ? r.partNames.map((name, i) => ({ name, start: r.parts[i].start, end: r.parts[i].end })) : [r]);
-  for (const raw of String(list).split(",").map((s) => s.trim()).filter(Boolean)) {
-    let frame, label, m;
-    if (m = raw.match(/^(.+)@(start|mid|end)$/)) {
-      const row = named.find((r) => r.name === m[1]);
-      const inside = row ? void 0 : rows.find((r) => r.local && r.name === m[1]);
-      if (inside) throw new Error(`--at "${raw}": layer "${m[1]}" is inside a time-remapped composition (${inside.local}), so its times are that composition's local seconds, not the movie's; name the composition (${inside.local.replace(/ (×.*|time keyframes)$/, "")}@${m[2]}) or give seconds`);
-      if (!row) throw new Error(`--at "${raw}": no layer named "${m[1]}" (names: ${named.slice(0, 40).map((r) => r.name).join(", ")}${named.length > 40 ? ", \u2026" : ""})`);
-      const t = m[2] === "start" ? row.start : m[2] === "mid" ? (row.start + row.end) / 2 : row.end - 1 / fps;
-      frame = Math.round(t * fps);
-      label = `${m[1]}-${m[2]}`;
-    } else if (m = raw.match(/^(\d+(?:\.\d+)?)%$/)) {
-      frame = Math.round(Number(m[1]) / 100 * totalFrames);
-      label = `${m[1]}pct`;
-    } else if (m = raw.match(/^f(\d+)$/i)) {
-      frame = Number(m[1]);
-      label = `f${m[1]}`;
-    } else if (/^\d+(\.\d+)?$/.test(raw)) {
-      frame = Math.round(Number(raw) * fps);
-      label = `${Number(raw).toFixed(2)}s`;
-    } else throw new Error(`--at: cannot read "${raw}": ${AT_HELP}`);
-    if (frame > totalFrames || frame < 0) throw new Error(`--at "${raw}" is past the end: the movie is ${duration} s (${totalFrames} frames)`);
-    label = label.replace(/[\\/:*?"<>|]+/g, "-");
-    let unique = label, n = 2;
-    while (used.has(unique)) unique = `${label}-${n++}`;
-    used.add(unique);
-    out.push({ label: unique, frame });
-  }
-  return out;
-}
-function groupIssues(perFrame) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const { frame, issues } of perFrame) {
-    for (const message of issues) {
-      const key = message.replace(/-?\d+(\.\d+)?/g, "#");
-      const g = groups.get(key);
-      if (g) {
-        g.count++;
-        g.lastFrame = frame;
-      } else groups.set(key, { message, count: 1, firstFrame: frame, lastFrame: frame });
-    }
-  }
-  return [...groups.values()];
-}
-function splitIssues(groups, strict = false) {
-  if (strict) return { problems: groups, review: [] };
-  const overlap = (g) => /\boverlap\b/.test(g.message);
-  return { problems: groups.filter((g) => !overlap(g)), review: groups.filter(overlap) };
-}
-async function reviewMovie(movie, opts = {}) {
-  const rows = movie.timelineData().rows;
-  const at = opts.at ? resolveAtList(opts.at, { frameRate: movie.frameRate, totalFrames: movie.totalFrames, duration: movie.duration, rows }) : [];
-  const frames = sampleFrames({ totalFrames: movie.totalFrames, frameRate: movie.frameRate, scenes: namedScenes(rows) });
-  const perFrame = [];
-  for (const frame of frames) {
-    const r = await movie.inspect(frame, { layers: "none" });
-    if (r.issues.length) perFrame.push({ frame, issues: r.issues });
-  }
-  const grouped = splitIssues(groupIssues(perFrame), !!opts.strict);
-  const fonts = movie.inspectFonts();
-  for (const f of fonts.failedUnused) grouped.review.push({ message: `web font "${f}" failed to load, but no text layer uses it (a broken or unused @font-face)`, count: 1, firstFrame: 0, lastFrame: 0 });
-  for (const m of fonts.missing) {
-    (opts.strict ? grouped.problems : grouped.review).push({ message: `layer "${m.layer}": none of the fonts "${m.family}" is available here (it is drawn in a fallback font)`, count: 1, firstFrame: 0, lastFrame: 0 });
-  }
-  return { frames: frames.length, problems: grouped.problems, review: grouped.review, fonts, audio: movie.audioBuffer ? movie.inspectAudio() : null, at };
-}
-
-// src/core/onion.ts
-function onionTimes(from, to, count) {
-  if (count <= 1) return [from];
-  return Array.from({ length: count }, (_, i) => Math.round((from + (to - from) * i / (count - 1)) * 1e6) / 1e6);
-}
-function onionAlphas(count, ramp = 0.25) {
-  const weights = Array.from({ length: count }, (_, i) => count === 1 ? 1 : ramp + (1 - ramp) * (i / (count - 1)));
-  let sum = 0;
-  return weights.map((w) => {
-    sum += w;
-    return w / sum;
-  });
-}
-
-// src/core/motionBlur.ts
-var DEFAULTS = { samples: 8, shutter: 0.5 };
-function resolveMotionBlur(spec, where) {
-  if (spec === void 0 || spec === null || spec === false) return null;
-  const o = spec === true ? {} : typeof spec === "number" ? { samples: spec } : spec;
-  if (typeof spec === "object") warnUnknownOptions(`${where} motionBlur`, o, ["samples", "shutter"]);
-  const samples = o.samples ?? DEFAULTS.samples, shutter = o.shutter ?? DEFAULTS.shutter;
-  if (!(Number.isInteger(samples) && samples >= 2 && samples <= 64)) throw new Error(`pixi-effects: ${where}: motionBlur samples must be a whole number from 2 to 64, got ${samples}`);
-  if (!(Number.isFinite(shutter) && shutter > 0 && shutter <= 1)) throw new Error(`pixi-effects: ${where}: motionBlur shutter must be a fraction of the frame time above 0 and up to 1 (0.5 is a 180\xB0 shutter), got ${shutter}`);
-  return { samples, shutter };
-}
-function blurTimes(frame, frameRate, mb, duration) {
-  const t = frame / frameRate, width = mb.shutter / frameRate;
-  return Array.from({ length: mb.samples }, (_, k) => Math.min(Math.max(t + ((k + 0.5) / mb.samples - 0.5) * width, 0), duration));
-}
-
-// src/core/renderRange.ts
-function resolveRange(range2, ctx) {
-  const { frameRate: fps, totalFrames, duration } = ctx;
-  if (range2 === void 0) return { fromFrame: 0, toFrame: totalFrames, fromSec: 0, toSec: duration, partial: false };
-  let from, to;
-  if (typeof range2 === "string") {
-    const rows = (ctx.rows ?? []).filter((r) => r.depth === 0 && !r.local).flatMap((r) => r.parts && r.partNames ? r.partNames.map((name, i) => ({ name, start: r.parts[i].start, end: r.parts[i].end })) : [r]);
-    const row = rows.find((r) => r.name === range2);
-    if (!row) throw new Error(`pixi-effects: render({ range: "${range2}" }): no layer named "${range2}" at the top level (names: ${rows.slice(0, 40).map((r) => r.name).join(", ") || "none"}${rows.length > 40 ? ", \u2026" : ""})`);
-    from = row.start;
-    to = row.end;
-  } else {
-    if (!Array.isArray(range2) || range2.length !== 2 || !range2.every((n) => typeof n === "number" && Number.isFinite(n))) {
-      throw new Error("pixi-effects: render({ range }) must be [from, to] in seconds (numbers) or the name of a top-level layer");
-    }
-    [from, to] = range2;
-  }
-  if (from < 0 || to <= from) throw new Error(`pixi-effects: render({ range: [${from}, ${to}] }): a range must start before it ends (from >= 0, from < to)`);
-  if (to > duration + 0.5 / fps) throw new Error(`pixi-effects: render({ range: [${from}, ${to}] }) goes past the end: the movie is ${duration} s long`);
-  const fromFrame = Math.round(from * fps);
-  const toFrame = Math.min(Math.round(to * fps), totalFrames);
-  if (toFrame <= fromFrame) throw new Error(`pixi-effects: render({ range: [${from}, ${to}] }) is shorter than one frame (${(1 / fps).toFixed(4)} s at ${fps} fps)`);
-  const partial = fromFrame > 0 || toFrame < totalFrames;
-  return { fromFrame, toFrame, fromSec: fromFrame / fps, toSec: toFrame / fps, partial };
-}
-function sliceChannels(channels, sampleRate, fromSec, toSec, opts = {}) {
-  const fade = Math.max(0, Math.round((opts.fade ?? 0.01) * sampleRate));
-  const from = Math.round(fromSec * sampleRate), len = Math.max(1, Math.round(toSec * sampleRate) - from);
-  return channels.map((src) => {
-    const out = new Float32Array(len);
-    for (let i = 0; i < len; i++) {
-      const j = from + i;
-      if (j >= 0 && j < src.length) out[i] = src[j];
-    }
-    const f = Math.min(fade, len >> 1);
-    if (opts.fadeIn !== false) for (let i = 0; i < f; i++) out[i] = out[i] * (i / f);
-    if (opts.fadeOut !== false) for (let i = 0; i < f; i++) out[len - 1 - i] = out[len - 1 - i] * (i / f);
-    return out;
-  });
-}
-function resolveRenderOptions(o) {
-  const draft = !!o.draft;
-  const scale = o.scale ?? (draft ? 0.5 : 1);
-  if (!(typeof scale === "number" && scale > 0 && scale <= 1)) throw new Error(`pixi-effects: render({ scale }): scale must be above 0 and at most 1 (got ${scale})`);
-  return {
-    scale,
-    bitrate: o.video?.bitrate ?? (draft ? "low" : void 0),
-    motionBlur: o.motionBlur !== void 0 ? o.motionBlur : draft ? false : void 0
-  };
-}
-
-// src/core/renderOptions.ts
-var QUALITY_NAMES = ["very-low", "low", "medium", "high", "very-high"];
-function parseBitrate(v) {
-  if (v === void 0 || v === null) return {};
-  if (typeof v === "string" && QUALITY_NAMES.includes(v)) return { quality: v };
-  if (typeof v === "number" && Number.isFinite(v) && v > 0) return { bps: Math.round(v) };
-  const m = typeof v === "string" ? /^\s*(\d+(?:\.\d+)?)\s*([kKmM]?)\s*$/.exec(v) : null;
-  if (m) {
-    const n = Number(m[1]) * { "": 1, k: 1e3, m: 1e6 }[m[2].toLowerCase()];
-    if (n > 0) return { bps: Math.round(n) };
-  }
-  throw new Error(`pixi-effects: bitrate ${JSON.stringify(v)}: use a quality (${QUALITY_NAMES.join(", ")}) or bits a second (8000000, '8M', '800k')`);
-}
-var AUDIO_FORMATS = ["wav", "ogg"];
-var isAudioFormat = (f) => AUDIO_FORMATS.includes(f);
-var VIDEO_CODEC_PREFERENCE = {
-  mp4: ["avc", "hevc", "vp9", "av1"],
-  mov: ["avc", "hevc"],
-  webm: ["vp9", "av1", "vp8"],
-  mkv: ["vp9", "avc", "hevc", "av1", "vp8"]
-};
-var CODEC_ALIASES = {
-  h264: "avc",
-  "h.264": "avc",
-  x264: "avc",
-  avc1: "avc",
-  h265: "hevc",
-  "h.265": "hevc",
-  x265: "hevc",
-  hvc1: "hevc",
-  hev1: "hevc",
-  vp09: "vp9",
-  "vp-9": "vp9",
-  av01: "av1",
-  vp80: "vp8",
-  "vp-8": "vp8"
-};
-async function chooseVideoCodec(a) {
-  const held = a.supported ?? VIDEO_CODEC_PREFERENCE[a.fmt];
-  const order = VIDEO_CODEC_PREFERENCE[a.fmt].filter((c) => held.includes(c));
-  const firstThatWorks = async (list) => {
-    for (const c of list) if (await a.canEncode(c)) return c;
-    return null;
-  };
-  if (a.requested) {
-    const alias = CODEC_ALIASES[a.requested.toLowerCase()];
-    if (alias) throw new Error(`pixi-effects: render({ video: { codec: "${a.requested}" } }): "${a.requested}" is not a codec name here; did you mean "${alias}"?`);
-    if (!order.includes(a.requested)) throw new Error(`pixi-effects: render(): "${a.requested}" cannot go in ${a.fmt} (${a.fmt} holds ${order.join(", ")})`);
-    if (await a.canEncode(a.requested)) return { codec: a.requested };
-    const alt = await firstThatWorks(order.filter((c) => c !== a.requested));
-    throw new Error(`pixi-effects: this browser cannot encode "${a.requested}" video for ${a.fmt}` + (alt ? `; "${alt}" would work: render({ format: '${a.fmt}', video: { codec: '${alt}' } }), or leave video.codec out and the best one is chosen.` : "; it can encode none of " + order.join(", ") + "."));
-  }
-  const chosen = await firstThatWorks(order);
-  if (!chosen) throw new Error(`pixi-effects: this browser has no video encoder for ${a.fmt} (it tried ${order.join(", ")}): try another browser, or another format`);
-  return chosen === order[0] ? { codec: chosen } : { codec: chosen, fellBackFrom: order[0] };
-}
-
-// src/core/Renderer.ts
-var AUDIO_PREFERENCE = {
-  mp4: ["aac", "opus", "mp3", "flac"],
-  mov: ["aac", "mp3"],
-  webm: ["opus", "vorbis"],
-  mkv: ["opus", "vorbis", "aac", "flac", "mp3"],
-  ogg: ["opus", "vorbis", "flac"]
-};
-async function chooseAudioCodec(fmt, requested, container, audio, bitrate) {
-  const supported = container.getSupportedAudioCodecs?.();
-  const preferred = AUDIO_PREFERENCE[fmt].filter((c) => !supported || supported.includes(c));
-  const canEncode = (list) => getFirstEncodableAudioCodec(list, { numberOfChannels: audio.numberOfChannels ?? 2, sampleRate: audio.sampleRate, bitrate });
-  if (requested) {
-    if (await canEncode([requested])) return requested;
-    const alt = await canEncode(preferred.filter((c) => c !== requested));
-    throw new Error(`pixi-effects: this browser cannot encode "${requested}" audio for ${fmt}` + (alt ? `; "${alt}" would work: render({ format: '${fmt}', audio: { codec: '${alt}' } }), or leave audio.codec out and the best one is chosen.` : "; it has no audio encoder for this format at all (try another browser, or a movie without sound)."));
-  }
-  const chosen = await canEncode(preferred);
-  if (!chosen) throw new Error(`pixi-effects: this browser has no audio encoder for ${fmt} (it tried ${preferred.join(", ")}): try another browser, or render a movie without sound.`);
-  if (chosen !== preferred[0]) {
-    console.warn(`pixi-effects: this browser cannot encode ${preferred[0].toUpperCase()} audio (Chrome on Linux has no AAC encoder), so the ${fmt} carries ${chosen} instead; current players play it. A webm export needs no AAC.`);
-  }
-  return chosen;
-}
-var qualityMap = {
-  "very-low": QUALITY_VERY_LOW,
-  "low": QUALITY_LOW,
-  "medium": QUALITY_MEDIUM,
-  "high": QUALITY_HIGH,
-  "very-high": QUALITY_VERY_HIGH
-};
-function bitrateOf(v, fallback) {
-  const b = parseBitrate(v);
-  return b.bps ?? (b.quality ? qualityMap[b.quality] : fallback);
-}
-function makeOutputFormat(name) {
-  switch (name) {
-    case "mp4":
-      return new Mp4OutputFormat({ fastStart: "in-memory" });
-    case "mov":
-      return new MovOutputFormat({ fastStart: "in-memory" });
-    case "webm":
-      return new WebMOutputFormat();
-    case "mkv":
-      return new MkvOutputFormat();
-  }
-}
-function sliceAudio(buffer, fromSec, toSec, fadeIn, fadeOut) {
-  const channels = Array.from({ length: buffer.numberOfChannels }, (_, c) => buffer.getChannelData(c));
-  const cut = sliceChannels(channels, buffer.sampleRate, fromSec, toSec, { fadeIn, fadeOut });
-  const out = new AudioBuffer({ length: cut[0].length, numberOfChannels: cut.length, sampleRate: buffer.sampleRate });
-  cut.forEach((data, c) => out.copyToChannel(data, c));
-  return out;
-}
-async function exportAudioOnly(movie, options, fmt, range2) {
-  if (!movie.audioBuffer) {
-    throw new Error(`pixi-effects: render({ format: '${fmt}' }): this movie has no sound to export (add an audio layer, an sfx or a music score); for the picture use mp4, webm, mov or mkv`);
-  }
-  if (options.video) console.warn(`pixi-effects: render({ format: '${fmt}' }): video options are ignored, only the sound is written`);
-  const audio = range2.partial ? sliceAudio(movie.audioBuffer, range2.fromSec, range2.toSec, range2.fromFrame > 0, range2.toFrame < movie.totalFrames) : movie.audioBuffer;
-  const container = fmt === "wav" ? new WavOutputFormat() : new OggOutputFormat();
-  let codec;
-  if (fmt === "wav") {
-    codec = options.audio?.codec ?? "pcm-s16";
-    const held = container.getSupportedAudioCodecs();
-    if (!held.includes(codec)) throw new Error(`pixi-effects: render({ format: 'wav', audio: { codec: "${codec}" } }): wav holds ${held.join(", ")} (the usual is pcm-s16)`);
-  } else {
-    codec = await chooseAudioCodec("ogg", options.audio?.codec, container, audio, bitrateOf(options.audio?.bitrate, QUALITY_HIGH));
-  }
-  const output = new Output({ format: container, target: new BufferTarget() });
-  const source = new AudioBufferSource({ codec, ...fmt === "wav" ? {} : { bitrate: bitrateOf(options.audio?.bitrate, QUALITY_HIGH) } });
-  output.addAudioTrack(source);
-  movie.emit("progress", { progress: 0, frame: range2.fromFrame, totalFrames: movie.totalFrames });
-  await output.start();
-  await source.add(audio);
-  await source.close();
-  await output.finalize();
-  movie.emit("progress", { progress: 100, frame: range2.toFrame, totalFrames: movie.totalFrames });
-  return new Blob([output.target.buffer], { type: output.format.mimeType });
-}
-async function exportFrames(movie, options = {}) {
-  const fmt = options.format ?? "mp4";
-  const eff = resolveRenderOptions(options);
-  const range2 = resolveRange(options.range, { frameRate: movie.frameRate, totalFrames: movie.totalFrames, duration: movie.duration, rows: typeof options.range === "string" ? movie.timelineData().rows : void 0 });
-  if (isAudioFormat(fmt)) return exportAudioOnly(movie, options, fmt, range2);
-  if (!["mp4", "mov", "webm", "mkv"].includes(fmt)) throw new Error(`pixi-effects: render({ format: "${String(fmt)}" }): use mp4, mov, webm, mkv (a picture) or wav, ogg (only the sound)`);
-  warnUnknownOptions("movie.render({ video })", options.video, ["codec", "bitrate", "hardware", "keyFrameInterval"]);
-  warnUnknownOptions("movie.render({ audio })", options.audio, ["codec", "bitrate"]);
-  const videoBitrate = bitrateOf(eff.bitrate ?? "high", QUALITY_HIGH);
-  const opts = {
-    format: fmt,
-    video: { codec: "", bitrate: videoBitrate },
-    audio: {
-      codec: options.audio?.codec ?? (fmt === "mp4" || fmt === "mov" ? "aac" : "opus"),
-      bitrate: bitrateOf(options.audio?.bitrate, QUALITY_HIGH)
-    }
-  };
-  const container = makeOutputFormat(opts.format);
-  const audio = movie.audioBuffer && range2.partial ? sliceAudio(movie.audioBuffer, range2.fromSec, range2.toSec, range2.fromFrame > 0, range2.toFrame < movie.totalFrames) : movie.audioBuffer;
-  if (audio) opts.audio.codec = await chooseAudioCodec(fmt, options.audio?.codec, container, audio, opts.audio.bitrate);
-  const output = new Output({
-    format: container,
-    target: new BufferTarget()
-  });
-  const mb = eff.motionBlur !== void 0 ? resolveMotionBlur(eff.motionBlur, "movie.render()") : movie.motionBlur ?? null;
-  const stage = movie.app.canvas;
-  const blurCanvas = mb ? Object.assign(document.createElement("canvas"), { width: stage.width, height: stage.height }) : null;
-  const small = eff.scale < 1 ? Object.assign(document.createElement("canvas"), { width: Math.max(2, Math.round(stage.width * eff.scale / 2) * 2), height: Math.max(2, Math.round(stage.height * eff.scale / 2) * 2) }) : null;
-  const smallCtx = small?.getContext("2d") ?? null;
-  const picture = small ?? blurCanvas ?? stage;
-  const chosen = await chooseVideoCodec({
-    fmt,
-    requested: options.video?.codec,
-    supported: container.getSupportedVideoCodecs(),
-    canEncode: (c) => canEncodeVideo(c, { width: picture.width, height: picture.height, bitrate: opts.video.bitrate })
-  });
-  if (chosen.fellBackFrom) console.warn(`pixi-effects: this browser cannot encode ${chosen.fellBackFrom.toUpperCase()} video, so the ${fmt} carries ${chosen.codec.toUpperCase()} instead (name a codec with render({ video: { codec } }) to choose yourself).`);
-  opts.video.codec = chosen.codec;
-  const hardware = options.video?.hardware;
-  if (hardware !== void 0 && !["no-preference", "prefer-hardware", "prefer-software"].includes(hardware)) {
-    throw new Error(`pixi-effects: render({ video: { hardware: "${String(hardware)}" } }): use 'prefer-hardware', 'prefer-software' or 'no-preference'`);
-  }
-  const canvasSource = new CanvasSource(picture, {
-    codec: opts.video.codec,
-    bitrate: opts.video.bitrate,
-    ...hardware ? { hardwareAcceleration: hardware } : {}
-  });
-  output.addVideoTrack(canvasSource, { frameRate: movie.frameRate });
-  if (audio) {
-    const audioSource = new AudioBufferSource({
-      codec: opts.audio.codec,
-      bitrate: opts.audio.bitrate
-    }, { startTimestamp: opts.audio.codec === "aac" ? -2112 / audio.sampleRate : 0 });
-    output.addAudioTrack(audioSource);
-    await output.start();
-    await audioSource.add(audio);
-    await audioSource.close();
-  } else {
-    await output.start();
-  }
-  movie.app.ticker.stop();
-  const interval = options.video?.keyFrameInterval ?? 2;
-  if (!(typeof interval === "number" && Number.isFinite(interval) && interval > 0)) throw new Error(`pixi-effects: render({ video: { keyFrameInterval: ${String(interval)} } }): seconds between keyframes, above 0 (default 2)`);
-  const keyframeIntervalFrames = Math.max(1, Math.round(interval * movie.frameRate));
-  try {
-    const count = Math.max(1, range2.toFrame - range2.fromFrame);
-    for (let frame = range2.fromFrame; frame <= range2.toFrame; frame++) {
-      if (mb && blurCanvas) await movie._exposeFrame(frame, mb, blurCanvas, false);
-      else await movie.gotoFrame(frame, true);
-      if (small && smallCtx) smallCtx.drawImage(blurCanvas ?? stage, 0, 0, small.width, small.height);
-      const rel = frame - range2.fromFrame;
-      const isKey = rel === 0 || rel % keyframeIntervalFrames === 0;
-      const addOpts = isKey ? { keyFrame: true } : void 0;
-      await canvasSource.add(rel / movie.frameRate, 1 / movie.frameRate, addOpts);
-      const progress = Math.floor(rel / count * 100);
-      movie.emit("progress", { progress, frame, totalFrames: movie.totalFrames });
-    }
-    await canvasSource.close();
-    await output.finalize();
-    if (mb) await movie.gotoFrame(range2.toFrame, true);
-    return new Blob([output.target.buffer], { type: output.format.mimeType });
-  } finally {
-    movie.app.ticker.start();
-  }
-}
-var MODE_CODES = {
-  "wipe-left": 0,
-  "wipe-right": 1,
-  "wipe-up": 2,
-  "wipe-down": 3,
-  "iris-in": 4,
-  "iris-out": 5,
-  "dissolve": 6
-};
-var GL_FRAGMENT = `
-in vec2 vTextureCoord;
-uniform sampler2D uTexture;
-uniform highp vec4 uInputSize;     // PIXI-bound: xy = sprite render texture size (with padding)
-uniform highp vec4 uInputClamp;    // PIXI-bound: xy = min uv of unpadded content, zw = max uv
-uniform highp vec4 uOutputFrame;   // PIXI-bound: xy = sprite top-left on output, zw = bbox size in px
-uniform highp vec4 uGlobalFrame;   // PIXI-bound: xy = global frame offset, zw = canvas size in px
-uniform float uProgress;
-uniform float uSmoothing;
-uniform float uMode;
-uniform float uInvert;
-uniform float uScale;
-uniform float uSeed;
-
-out vec4 finalColor;
-
-// Classic 2D Perlin noise (Stefan Gustavson). Deterministic \u2014 same input
-// always returns the same output, which is what makes the dissolve pattern
-// reproducible across renders.
-vec4 _permute(vec4 x) { return mod(((x * 34.0) + 1.0) * x, 289.0); }
-vec2 _fade(vec2 t) { return t * t * t * (t * (t * 6.0 - 15.0) + 10.0); }
-float perlin2(vec2 P) {
-  vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);
-  vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);
-  Pi = mod(Pi, 289.0);
-  vec4 ix = Pi.xzxz;
-  vec4 iy = Pi.yyww;
-  vec4 fx = Pf.xzxz;
-  vec4 fy = Pf.yyww;
-  vec4 i = _permute(_permute(ix) + iy);
-  vec4 gx = 2.0 * fract(i / 41.0) - 1.0;
-  vec4 gy = abs(gx) - 0.5;
-  vec4 tx = floor(gx + 0.5);
-  gx = gx - tx;
-  vec2 g00 = vec2(gx.x, gy.x);
-  vec2 g10 = vec2(gx.y, gy.y);
-  vec2 g01 = vec2(gx.z, gy.z);
-  vec2 g11 = vec2(gx.w, gy.w);
-  vec4 norm = 1.79284291400159 - 0.85373472095314 * vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11));
-  g00 *= norm.x; g01 *= norm.y; g10 *= norm.z; g11 *= norm.w;
-  float n00 = dot(g00, vec2(fx.x, fy.x));
-  float n10 = dot(g10, vec2(fx.y, fy.y));
-  float n01 = dot(g01, vec2(fx.z, fy.z));
-  float n11 = dot(g11, vec2(fx.w, fy.w));
-  vec2 fade_xy = _fade(Pf.xy);
-  vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);
-  return 2.3 * mix(n_x.x, n_x.y, fade_xy.y);
-}
-
-// Map sprite-local vTextureCoord \u2192 canvas-pixel position. We do this in two
-// steps: first un-pad vTextureCoord (it spans 0..bbox/inputSize because the
-// filter target has padding) into a true 0..1 across the bbox, then offset
-// and scale by uOutputFrame to get canvas pixels. Operating in canvas space
-// (rather than sprite-uv space) is what makes the wipe / iris edge land at
-// the same canvas position for sprites of any size: at uProgress=0.25 the
-// wipe edge is at canvas x = 0.75 * canvasW for every sprite, regardless of
-// each sprite's bbox.
-vec2 toCanvasPx(vec2 uv) {
-  vec2 bboxUV = (uv - uInputClamp.xy) / (uInputClamp.zw - uInputClamp.xy);
-  return uOutputFrame.xy + bboxUV * uOutputFrame.zw;
-}
-
-vec2 toCanvasUV(vec2 uv) {
-  return toCanvasPx(uv) / uGlobalFrame.zw;
-}
-
-// Aspect-corrected, corner-normalized distance from canvas center.
-// Returns 0 at canvas center, 1 at the canvas corner \u2014 so iris is a true
-// circle in pixel space and p=1 reveals the entire canvas.
-float irisDistCanvas(vec2 uv) {
-  vec2 px = toCanvasPx(uv);
-  vec2 canvasSize = uGlobalFrame.zw;
-  vec2 offsetPx = px - canvasSize * 0.5;
-  float halfDiag = 0.5 * length(canvasSize);
-  return length(offsetPx) / max(halfDiag, 1.0);
-}
-
-float wipeReveal(vec2 uv, float p, float s, float mode) {
-  // Remap p so the smoothstep edge lies fully outside [0,1] at p=0 / p=1
-  // (otherwise smoothstep returns 0.5 at the very edge instead of 0 or 1).
-  float ep = p * (1.0 + 2.0 * s) - s;
-  vec2 cuv = toCanvasUV(uv);
-  if (mode < 0.5) {
-    // wipe-left: B reveals from the right edge moving left
-    return smoothstep(1.0 - ep - s, 1.0 - ep + s, cuv.x);
-  } else if (mode < 1.5) {
-    // wipe-right: B reveals from the left edge moving right
-    return smoothstep(1.0 - ep - s, 1.0 - ep + s, 1.0 - cuv.x);
-  } else if (mode < 2.5) {
-    // wipe-up
-    return smoothstep(1.0 - ep - s, 1.0 - ep + s, cuv.y);
-  } else if (mode < 3.5) {
-    // wipe-down: B reveals from the top edge moving down
-    return smoothstep(1.0 - ep - s, 1.0 - ep + s, 1.0 - cuv.y);
-  } else if (mode < 4.5) {
-    // iris-in: circle grows from center
-    float d = irisDistCanvas(uv);
-    return 1.0 - smoothstep(ep - s, ep + s, d);
-  } else if (mode < 5.5) {
-    // iris-out: circle shrinks toward center
-    float d = irisDistCanvas(uv);
-    return smoothstep(ep - s, ep + s, d);
-  } else {
-    // dissolve: pixel-grain Perlin noise threshold. Pixels with a low noise
-    // value reveal first; as p grows, more pixels reveal.
-    vec2 sampleUV = cuv * uScale + vec2(uSeed, uSeed * 0.7);
-    float n = perlin2(sampleUV) * 0.5 + 0.5;  // remap to 0..1
-    return 1.0 - smoothstep(ep - s, ep + s, n);
-  }
-}
-
-void main(void) {
-    vec4 raw = texture(uTexture, vTextureCoord);
-    float reveal = wipeReveal(vTextureCoord, uProgress, max(uSmoothing, 0.0001), uMode);
-    // Inverted mode uses a HARD binary cutoff: A stays at alpha=1 across
-    // B's smoothstep zone and snaps off only where B has fully revealed.
-    if (uInvert > 0.5) reveal = 1.0 - step(0.99, reveal);
-    finalColor = raw * reveal;
-}
-`;
-var WGSL_SOURCE = `
-struct GlobalFilterUniforms {
-  uInputSize: vec4<f32>,
-  uInputPixel: vec4<f32>,
-  uInputClamp: vec4<f32>,
-  uOutputFrame: vec4<f32>,
-  uGlobalFrame: vec4<f32>,
-  uOutputTexture: vec4<f32>,
-};
-
-struct TransitionUniforms {
-  uProgress: f32,
-  uMode: f32,
-  uSmoothing: f32,
-  uInvert: f32,
-  uScale: f32,
-  uSeed: f32,
-};
-
-@group(0) @binding(0) var<uniform> gfu: GlobalFilterUniforms;
-@group(0) @binding(1) var uTexture: texture_2d<f32>;
-@group(0) @binding(2) var uSampler : sampler;
-@group(1) @binding(0) var<uniform> transitionUniforms : TransitionUniforms;
-
-struct VSOutput {
-  @builtin(position) position: vec4<f32>,
-  @location(0) uv : vec2<f32>,
-};
-
-fn filterVertexPosition(aPosition : vec2<f32>) -> vec4<f32> {
-  var position = aPosition * gfu.uOutputFrame.zw + gfu.uOutputFrame.xy;
-  position.x = position.x * (2.0 / gfu.uOutputTexture.x) - 1.0;
-  position.y = position.y * (2.0 * gfu.uOutputTexture.z / gfu.uOutputTexture.y) - gfu.uOutputTexture.z;
-  return vec4<f32>(position, 0.0, 1.0);
-}
-
-fn filterTextureCoord(aPosition : vec2<f32>) -> vec2<f32> {
-  return aPosition * (gfu.uOutputFrame.zw * gfu.uInputSize.zw);
-}
-
-// NOTE on whitespace: PIXI v8's WGSL attribute extractor is regex-based and
-// expects the noise/blur reference format \u2014 multi-line param list + space
-// before the colon. A compact one-liner with no space before the colon parses
-// as having NO vertex attributes, which then causes a "Vertex attribute slot 0
-// not present in the VertexState" pipeline validation error.
-@vertex
-fn mainVertex(
-  @location(0) aPosition : vec2<f32>,
-) -> VSOutput {
-  return VSOutput(filterVertexPosition(aPosition), filterTextureCoord(aPosition));
-}
-
-// Aspect-corrected, corner-normalized distance from sprite center.
-// Map sprite-local uv \u2192 canvas-pixel position (see GLSL note).
-fn toCanvasPx(uv: vec2<f32>) -> vec2<f32> {
-  let bboxUV = (uv - gfu.uInputClamp.xy) / (gfu.uInputClamp.zw - gfu.uInputClamp.xy);
-  return gfu.uOutputFrame.xy + bboxUV * gfu.uOutputFrame.zw;
-}
-
-fn toCanvasUV(uv: vec2<f32>) -> vec2<f32> {
-  return toCanvasPx(uv) / gfu.uGlobalFrame.zw;
-}
-
-fn irisDistCanvas(uv: vec2<f32>) -> f32 {
-  let px = toCanvasPx(uv);
-  let canvasSize = gfu.uGlobalFrame.zw;
-  let offsetPx = px - canvasSize * 0.5;
-  let halfDiag = 0.5 * length(canvasSize);
-  return length(offsetPx) / max(halfDiag, 1.0);
-}
-
-// Classic 2D Perlin noise (Stefan Gustavson). Deterministic \u2014 same input
-// always returns the same output, so the dissolve pattern is reproducible.
-fn _wgsl_permute(x: vec4<f32>) -> vec4<f32> { return ((x * 34.0) + 1.0) * x % vec4<f32>(289.0); }
-fn _wgsl_fade(t: vec2<f32>) -> vec2<f32> { return t * t * t * (t * (t * 6.0 - 15.0) + 10.0); }
-fn perlin2(P: vec2<f32>) -> f32 {
-  var Pi: vec4<f32> = floor(vec4<f32>(P, P)) + vec4<f32>(0.0, 0.0, 1.0, 1.0);
-  var Pf: vec4<f32> = fract(vec4<f32>(P, P)) - vec4<f32>(0.0, 0.0, 1.0, 1.0);
-  Pi = Pi % vec4<f32>(289.0);
-  let ix = vec4<f32>(Pi.x, Pi.z, Pi.x, Pi.z);
-  let iy = vec4<f32>(Pi.y, Pi.y, Pi.w, Pi.w);
-  let fx = vec4<f32>(Pf.x, Pf.z, Pf.x, Pf.z);
-  let fy = vec4<f32>(Pf.y, Pf.y, Pf.w, Pf.w);
-  let i = _wgsl_permute(_wgsl_permute(ix) + iy);
-  var gx = 2.0 * fract(i / 41.0) - 1.0;
-  let gy = abs(gx) - 0.5;
-  let tx = floor(gx + 0.5);
-  gx = gx - tx;
-  var g00 = vec2<f32>(gx.x, gy.x);
-  var g10 = vec2<f32>(gx.y, gy.y);
-  var g01 = vec2<f32>(gx.z, gy.z);
-  var g11 = vec2<f32>(gx.w, gy.w);
-  let norm = 1.79284291400159 - 0.85373472095314 * vec4<f32>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11));
-  g00 = g00 * norm.x; g01 = g01 * norm.y; g10 = g10 * norm.z; g11 = g11 * norm.w;
-  let n00 = dot(g00, vec2<f32>(fx.x, fy.x));
-  let n10 = dot(g10, vec2<f32>(fx.y, fy.y));
-  let n01 = dot(g01, vec2<f32>(fx.z, fy.z));
-  let n11 = dot(g11, vec2<f32>(fx.w, fy.w));
-  let fade_xy = _wgsl_fade(vec2<f32>(Pf.x, Pf.y));
-  let n_x = mix(vec2<f32>(n00, n01), vec2<f32>(n10, n11), vec2<f32>(fade_xy.x));
-  return 2.3 * mix(n_x.x, n_x.y, fade_xy.y);
-}
-
-fn wipeReveal(uv: vec2<f32>, p: f32, s: f32, mode: f32) -> f32 {
-  let ep = p * (1.0 + 2.0 * s) - s;
-  let cuv = toCanvasUV(uv);
-  if (mode < 0.5) {
-    return smoothstep(1.0 - ep - s, 1.0 - ep + s, cuv.x);
-  } else if (mode < 1.5) {
-    // wipe-right: B reveals from the left edge moving right
-    return smoothstep(1.0 - ep - s, 1.0 - ep + s, 1.0 - cuv.x);
-  } else if (mode < 2.5) {
-    return smoothstep(1.0 - ep - s, 1.0 - ep + s, cuv.y);
-  } else if (mode < 3.5) {
-    // wipe-down: B reveals from the top edge moving down
-    return smoothstep(1.0 - ep - s, 1.0 - ep + s, 1.0 - cuv.y);
-  } else if (mode < 4.5) {
-    let d = irisDistCanvas(uv);
-    return 1.0 - smoothstep(ep - s, ep + s, d);
-  } else if (mode < 5.5) {
-    let d = irisDistCanvas(uv);
-    return smoothstep(ep - s, ep + s, d);
-  } else {
-    let sampleUV = cuv * transitionUniforms.uScale + vec2<f32>(transitionUniforms.uSeed, transitionUniforms.uSeed * 0.7);
-    let n = perlin2(sampleUV) * 0.5 + 0.5;
-    return 1.0 - smoothstep(ep - s, ep + s, n);
-  }
-}
-
-@fragment
-fn mainFragment(@location(0) uv : vec2<f32>) -> @location(0) vec4<f32> {
-  let raw = textureSample(uTexture, uSampler, uv);
-  var reveal = wipeReveal(uv, transitionUniforms.uProgress, max(transitionUniforms.uSmoothing, 0.0001), transitionUniforms.uMode);
-  if (transitionUniforms.uInvert > 0.5) { reveal = 1.0 - step(0.99, reveal); }
-  return raw * reveal;
-}
-`;
-var TransitionMaskFilter = class extends Filter {
-  constructor(options = {}) {
-    const mode = options.mode ?? "wipe-left";
-    const smoothing = options.smoothing ?? 0.02;
-    const progress = options.progress ?? 0;
-    const invert = options.invert ?? false;
-    const scale = options.scale ?? 30;
-    const seed = options.seed ?? 0;
-    super({
-      glProgram: GlProgram.from({
-        vertex: defaultFilterVert,
-        fragment: GL_FRAGMENT,
-        name: "transition-mask-filter"
-      }),
-      gpuProgram: GpuProgram.from({
-        vertex: { source: WGSL_SOURCE, entryPoint: "mainVertex" },
-        fragment: { source: WGSL_SOURCE, entryPoint: "mainFragment" }
-      }),
-      resources: {
-        transitionUniforms: new UniformGroup({
-          uProgress: { value: progress, type: "f32" },
-          uMode: { value: MODE_CODES[mode], type: "f32" },
-          uSmoothing: { value: smoothing, type: "f32" },
-          uInvert: { value: invert ? 1 : 0, type: "f32" },
-          uScale: { value: scale, type: "f32" },
-          uSeed: { value: seed, type: "f32" }
-        })
-      }
-    });
-  }
-  get uProgress() {
-    return this.resources.transitionUniforms.uniforms.uProgress;
-  }
-  set uProgress(v) {
-    this.resources.transitionUniforms.uniforms.uProgress = v;
-  }
-  get uMode() {
-    return this.resources.transitionUniforms.uniforms.uMode;
-  }
-  set uMode(v) {
-    this.resources.transitionUniforms.uniforms.uMode = v;
-  }
-  get uSmoothing() {
-    return this.resources.transitionUniforms.uniforms.uSmoothing;
-  }
-  set uSmoothing(v) {
-    this.resources.transitionUniforms.uniforms.uSmoothing = v;
-  }
-  get uInvert() {
-    return this.resources.transitionUniforms.uniforms.uInvert;
-  }
-  set uInvert(v) {
-    this.resources.transitionUniforms.uniforms.uInvert = v;
-  }
-  get uScale() {
-    return this.resources.transitionUniforms.uniforms.uScale;
-  }
-  set uScale(v) {
-    this.resources.transitionUniforms.uniforms.uScale = v;
-  }
-  get uSeed() {
-    return this.resources.transitionUniforms.uniforms.uSeed;
-  }
-  set uSeed(v) {
-    this.resources.transitionUniforms.uniforms.uSeed = v;
-  }
-};
-var LUMA_MAPS = ["linear", "diagonal", "radial"];
-var GL = `in vec2 vTextureCoord;
-uniform sampler2D uTexture;
-uniform sampler2D uMap;
-uniform highp vec4 uInputClamp;
-uniform highp vec4 uOutputFrame;
-uniform highp vec4 uGlobalFrame;
-uniform float uProgress;
-uniform float uSoftness;
-uniform float uInvert;
-uniform float uFlip;
-uniform float uMode;
-out vec4 finalColor;
-float lumaOf(vec2 cuv, float aspect) {
-  if (uMode > 2.5) { vec2 p = (cuv - 0.5) * vec2(aspect, 1.0); return clamp(length(p) / (0.5 * length(vec2(aspect, 1.0))), 0.0, 1.0); }
-  if (uMode > 1.5) return clamp((cuv.x + cuv.y) * 0.5, 0.0, 1.0);
-  if (uMode > 0.5) return clamp(cuv.x, 0.0, 1.0);
-  return dot(texture(uMap, cuv).rgb, vec3(0.2126, 0.7152, 0.0722));
-}
-void main(void) {
-  vec4 raw = texture(uTexture, vTextureCoord);
-  vec2 bboxUV = (vTextureCoord - uInputClamp.xy) / (uInputClamp.zw - uInputClamp.xy);
-  vec2 cuv = (uOutputFrame.xy + bboxUV * uOutputFrame.zw) / uGlobalFrame.zw;
-  float l = lumaOf(cuv, uGlobalFrame.z / uGlobalFrame.w);
-  if (uFlip > 0.5) l = 1.0 - l;
-  float s = max(uSoftness, 0.0001);
-  float ep = uProgress * (1.0 + 2.0 * s) - s;
-  float reveal = 1.0 - smoothstep(ep - s, ep + s, l);
-  if (uInvert > 0.5) reveal = 1.0 - step(0.99, reveal);
-  finalColor = raw * reveal;
-}`;
-var WGSL = `
-struct GlobalFilterUniforms {
-  uInputSize:vec4<f32>, uInputPixel:vec4<f32>, uInputClamp:vec4<f32>, uOutputFrame:vec4<f32>, uGlobalFrame:vec4<f32>, uOutputTexture:vec4<f32>,
-};
-struct LumaUniforms { uProgress:f32, uSoftness:f32, uInvert:f32, uFlip:f32, uMode:f32, };
-@group(0) @binding(0) var<uniform> gfu: GlobalFilterUniforms;
-@group(0) @binding(1) var uTexture: texture_2d<f32>;
-@group(0) @binding(2) var uSampler : sampler;
-@group(1) @binding(0) var<uniform> lumaUniforms : LumaUniforms;
-@group(1) @binding(1) var uMap: texture_2d<f32>;
-@group(1) @binding(2) var uMapSampler : sampler;
-struct VSOutput {
-  @builtin(position) position: vec4<f32>,
-  @location(0) uv : vec2<f32>,
-};
-@vertex
-fn mainVertex(
-  @location(0) aPosition : vec2<f32>,
-) -> VSOutput {
-  var position = aPosition * gfu.uOutputFrame.zw + gfu.uOutputFrame.xy;
-  position.x = position.x * (2.0 / gfu.uOutputTexture.x) - 1.0;
-  position.y = position.y * (2.0 * gfu.uOutputTexture.z / gfu.uOutputTexture.y) - gfu.uOutputTexture.z;
-  return VSOutput(vec4<f32>(position, 0.0, 1.0), aPosition * (gfu.uOutputFrame.zw * gfu.uInputSize.zw));
-}
-fn lumaOf(cuv: vec2<f32>, aspect: f32) -> f32 {
-  let mode = lumaUniforms.uMode;
-  if (mode > 2.5) {
-    let p = (cuv - vec2<f32>(0.5)) * vec2<f32>(aspect, 1.0);
-    return clamp(length(p) / (0.5 * length(vec2<f32>(aspect, 1.0))), 0.0, 1.0);
-  }
-  if (mode > 1.5) { return clamp((cuv.x + cuv.y) * 0.5, 0.0, 1.0); }
-  if (mode > 0.5) { return clamp(cuv.x, 0.0, 1.0); }
-  let m = textureSampleLevel(uMap, uMapSampler, cuv, 0.0).rgb;
-  return dot(m, vec3<f32>(0.2126, 0.7152, 0.0722));
-}
-@fragment
-fn mainFragment(@location(0) uv : vec2<f32>) -> @location(0) vec4<f32> {
-  let raw = textureSample(uTexture, uSampler, uv);
-  let bboxUV = (uv - gfu.uInputClamp.xy) / (gfu.uInputClamp.zw - gfu.uInputClamp.xy);
-  let cuv = (gfu.uOutputFrame.xy + bboxUV * gfu.uOutputFrame.zw) / gfu.uGlobalFrame.zw;
-  var l = lumaOf(cuv, gfu.uGlobalFrame.z / gfu.uGlobalFrame.w);
-  if (lumaUniforms.uFlip > 0.5) { l = 1.0 - l; }
-  let s = max(lumaUniforms.uSoftness, 0.0001);
-  let ep = lumaUniforms.uProgress * (1.0 + 2.0 * s) - s;
-  var reveal = 1.0 - smoothstep(ep - s, ep + s, l);
-  if (lumaUniforms.uInvert > 0.5) { reveal = 1.0 - step(0.99, reveal); }
-  return raw * reveal;
-}`;
-var LumaWipeFilter = class extends Filter {
-  _mapName;
-  _builtIn;
-  _resolved = false;
-  _warned = false;
-  constructor({ map, softness = 0.1, progress = 0, invert = false, flip = false }) {
-    const t = Texture.WHITE;
-    const mode = LUMA_MAPS.indexOf(map) + 1;
-    super({
-      glProgram: GlProgram.from({ vertex: defaultFilterVert, fragment: GL, name: "pe-luma-wipe" }),
-      gpuProgram: GpuProgram.from({ vertex: { source: WGSL, entryPoint: "mainVertex" }, fragment: { source: WGSL, entryPoint: "mainFragment" } }),
-      resources: {
-        lumaUniforms: new UniformGroup({
-          uProgress: { value: progress, type: "f32" },
-          uSoftness: { value: softness, type: "f32" },
-          uInvert: { value: invert ? 1 : 0, type: "f32" },
-          uFlip: { value: flip ? 1 : 0, type: "f32" },
-          uMode: { value: mode, type: "f32" }
-        }),
-        uMap: t.source,
-        uMapSampler: t.source.style
-      }
-    });
-    this._mapName = map;
-    this._builtIn = mode > 0;
-  }
-  get uProgress() {
-    return this.resources.lumaUniforms.uniforms.uProgress;
-  }
-  set uProgress(v) {
-    this.resources.lumaUniforms.uniforms.uProgress = v;
-  }
-  apply(fm, input, output, clear) {
-    if (!this._builtIn && !this._resolved) {
-      const t = Assets.get(this._mapName);
-      if (t) {
-        this.resources.uMap = t.source;
-        this.resources.uMapSampler = t.source.style;
-        this._resolved = true;
-      } else if (!this._warned) {
-        this._warned = true;
-        const guess = suggestName(this._mapName, LUMA_MAPS);
-        console.warn(`pixi-effects: luma transition map "${this._mapName}" is not a built-in map (${LUMA_MAPS.join(", ")}) and no image asset has that name${guess ? `; did you mean "${guess}"?` : ""}; the wipe follows a white map (everything changes at once)`);
-      }
-    }
-    fm.applyFilter(this, input, output, clear);
-  }
-};
-
-// src/core/Transitions.ts
-var EPS = 1e-6;
-var windows = /* @__PURE__ */ new WeakMap();
-function transitionWindowsOf(spec) {
-  return windows.get(spec) ?? [];
-}
-function carryTransitionWindows(from, to) {
-  const w = windows.get(from);
-  if (w) windows.set(to, w);
-  return to;
-}
-function expandTransitions(spec) {
-  const out = {
-    ...spec,
-    sequences: spec.sequences ? spec.sequences.map((s) => {
-      const cloned = {
-        ...s,
-        // Deep-clone the mutation surfaces only.
-        initial: "initial" in s && s.initial ? { ...s.initial } : void 0,
-        // Shallow: Keyframe / FilterSpec elements are shared references.
-        // Expansion only pushes new literals — never mutate existing ones.
-        keyframes: "keyframes" in s && s.keyframes ? s.keyframes.slice() : void 0,
-        filters: "filters" in s && s.filters ? s.filters.slice() : void 0
-      };
-      if (cloned.type === "composition") {
-        const c = cloned;
-        if (c.width === void 0) c.width = spec.width;
-        if (c.height === void 0) c.height = spec.height;
-        return expandTransitions(c);
-      }
-      return cloned;
-    }) : void 0
-  };
-  if (!out.transitions || out.transitions.length === 0) {
-    delete out.transitions;
-    return out;
-  }
-  const transitions = out.transitions;
-  const sequences = out.sequences ?? [];
-  const remap = out.duration !== void 0 ? timeRemapOf(out) : null;
-  const parentDuration = remap ? contentLength(remap, out.duration) : out.duration ?? Infinity;
-  const compW = out.width;
-  const compH = out.height;
-  const threeDByName = new Set(sequences.filter((s) => s.name && s.threeD).map((s) => s.name));
-  transitions.forEach((t, i) => {
-    for (const name of [t.from, t.to]) {
-      if (threeDByName.has(name)) {
-        console.warn(`pixi-effects: transitions[${i}]: "${name}" is threeD, but transitions are not supported on threeD layers yet \u2014 it will render without the camera`);
-      }
-    }
-  });
-  const masksParticipants = /* @__PURE__ */ new Set();
-  for (const t of transitions) {
-    if (t.kind === "wipe" || t.kind === "iris" || t.kind === "dissolve" || t.kind === "zoom" || t.kind === "luma") {
-      masksParticipants.add(t.from);
-      masksParticipants.add(t.to);
-    }
-  }
-  if (masksParticipants.size > 0 && compW !== void 0 && compH !== void 0) {
-    for (let i = 0; i < sequences.length; i++) {
-      const s = sequences[i];
-      if (!s.name || !masksParticipants.has(s.name)) continue;
-      const userFilters = s.filters;
-      if (userFilters) rejectReservedNameCollision(userFilters, s.name);
-      sequences[i] = wrapAsFullComposition(s, compW, compH);
-    }
-  }
-  const byName = /* @__PURE__ */ new Map();
-  for (let i = 0; i < sequences.length; i++) {
-    const s = sequences[i];
-    if (!s.name) continue;
-    if (byName.has(s.name)) {
-      throw new Error(`pixi-effects: composition has two sequences named "${s.name}" (transitions need unique names)`);
-    }
-    byName.set(s.name, { index: i, seq: s });
-  }
-  const fromCount = /* @__PURE__ */ new Map();
-  const toCount = /* @__PURE__ */ new Map();
-  for (let i = 0; i < transitions.length; i++) {
-    const t = transitions[i];
-    const tag = `transitions[${i}] (${t.kind})`;
-    if (t.from === t.to) {
-      throw new Error(`pixi-effects: ${tag} cannot transition a sequence to itself ("${t.from}")`);
-    }
-    if (!(t.duration > 0)) {
-      throw new Error(`pixi-effects: ${tag} duration must be > 0 (got ${t.duration})`);
-    }
-    const fromEntry = byName.get(t.from);
-    if (!fromEntry) {
-      throw new Error(`pixi-effects: ${tag} \`from\` "${t.from}" is not found among sibling sequences`);
-    }
-    const toEntry = byName.get(t.to);
-    if (!toEntry) {
-      throw new Error(`pixi-effects: ${tag} \`to\` "${t.to}" is not found among sibling sequences`);
-    }
-    if (toEntry.index <= fromEntry.index) {
-      throw new Error(`pixi-effects: ${tag} \`to\` "${t.to}" must be declared after \`from\` "${t.from}" in sibling order`);
-    }
-    const fromUses = (fromCount.get(t.from) ?? 0) + 1;
-    fromCount.set(t.from, fromUses);
-    if (fromUses > 1) {
-      throw new Error(`pixi-effects: ${tag} sequence "${t.from}" is used as \`from\` in more than one transition`);
-    }
-    const toUses = (toCount.get(t.to) ?? 0) + 1;
-    toCount.set(t.to, toUses);
-    if (toUses > 1) {
-      throw new Error(`pixi-effects: ${tag} sequence "${t.to}" is used as \`to\` in more than one transition`);
-    }
-    const tStart = resolveAt(t.at, parentDuration);
-    const tEnd = tStart + t.duration;
-    const fromSeq = fromEntry.seq;
-    const fromStart = resolveAt(fromSeq.at, parentDuration);
-    const fromEnd = fromStart + (fromSeq.duration ?? parentDuration);
-    if (tStart < fromStart - EPS || tEnd > fromEnd + EPS) {
-      throw new Error(`pixi-effects: ${tag} window [${tStart}, ${tEnd}] is not covered by \`from\` "${t.from}" (lives [${fromStart}, ${fromEnd}], so it ends at ${fromEnd})`);
-    }
-    const toSeq = toEntry.seq;
-    const toStart = resolveAt(toSeq.at, parentDuration);
-    const toEnd = toStart + (toSeq.duration ?? parentDuration);
-    if (tStart < toStart - EPS || tEnd > toEnd + EPS) {
-      throw new Error(`pixi-effects: ${tag} window [${tStart}, ${tEnd}] is not covered by \`to\` "${t.to}" (lives [${toStart}, ${toEnd}], so it starts at ${toStart})`);
-    }
-    const record = windows.get(out) ?? [];
-    record.push({ from: t.from, to: t.to, start: tStart, end: tEnd });
-    windows.set(out, record);
-    const abs = { ...t, at: tStart };
-    const nFrom = keyframeCount(fromEntry.seq);
-    const nTo = keyframeCount(toEntry.seq);
-    switch (abs.kind) {
-      case "crossfade":
-        expandCrossfade(out, abs, fromEntry.seq, toEntry.seq);
-        break;
-      case "wipe":
-        expandMask(out, abs, fromEntry.seq, toEntry.seq, i, wipeMode(abs.direction), abs.smoothing);
-        break;
-      case "iris":
-        expandMask(out, abs, fromEntry.seq, toEntry.seq, i, abs.mode === "out" ? "iris-out" : "iris-in", abs.smoothing);
-        break;
-      case "slide":
-        expandSlide(out, abs, fromEntry.seq, toEntry.seq);
-        break;
-      case "dip":
-        expandDip(out, abs, fromEntry.seq, toEntry.seq);
-        break;
-      case "zoom":
-        expandZoom(out, abs, fromEntry.seq, toEntry.seq);
-        break;
-      case "dissolve":
-        expandDissolve(out, abs, fromEntry.seq, toEntry.seq, i);
-        break;
-      case "luma":
-        expandLuma(out, abs, fromEntry.seq, toEntry.seq, i);
-        break;
-    }
-    rebaseNewKeyframes(fromEntry.seq, nFrom, fromStart);
-    rebaseNewKeyframes(toEntry.seq, nTo, toStart);
-  }
-  delete out.transitions;
-  return out;
-}
-function wrapAsFullComposition(seq, compW, compH) {
-  const centring = {
-    x: compW / 2,
-    y: compH / 2,
-    pivotX: compW / 2,
-    pivotY: compH / 2
-  };
-  if (seq.type === "composition" && seq.width === compW && seq.height === compH) {
-    const existing = seq.initial;
-    seq.initial = { ...centring, ...existing ?? {} };
-    return seq;
-  }
-  const inner = { ...seq };
-  delete inner.name;
-  delete inner.at;
-  delete inner.duration;
-  const m = inner.mask;
-  const carriesMatte = m !== void 0 && maskSourceOf(m).kind === "refs";
-  if (carriesMatte) delete inner.mask;
-  return {
-    ...carriesMatte ? { mask: m } : {},
-    type: "composition",
-    name: seq.name,
-    at: seq.at,
-    duration: seq.duration,
-    width: compW,
-    height: compH,
-    initial: centring,
-    sequences: [inner]
-  };
-}
-function keyframeCount(seq) {
-  return seq.keyframes?.length ?? 0;
-}
-function rebaseNewKeyframes(seq, from, seqStart) {
-  const kfs = seq.keyframes;
-  if (!kfs) return;
-  for (let i = from; i < kfs.length; i++) {
-    const kf = kfs[i];
-    if (typeof kf.at === "number") kfs[i] = { ...kf, at: kf.at - seqStart };
-  }
-}
-function ensureKeyframes(seq) {
-  const s = seq;
-  if (!s.keyframes) s.keyframes = [];
-  return s.keyframes;
-}
-function ensureInitial(seq) {
-  const s = seq;
-  if (!s.initial) s.initial = {};
-  return s.initial;
-}
-function ensureFilters(seq) {
-  const s = seq;
-  if (!s.filters) s.filters = [];
-  return s.filters;
-}
-function expandCrossfade(_comp, t, fromSeq, toSeq) {
-  const ease = t.ease ?? "none";
-  const fromKfs = ensureKeyframes(fromSeq);
-  fromKfs.push({ at: t.at, to: { alpha: 0 }, duration: t.duration, ease });
-  const toInitial = ensureInitial(toSeq);
-  if (toInitial.alpha !== void 0 && toInitial.alpha !== 0) {
-    throw new Error(
-      `pixi-effects: crossfade "${t.from}"\u2192"${t.to}" requires "${t.to}" to start invisible, but it already has initial.alpha=${String(toInitial.alpha)}. Remove the manual setting.`
-    );
-  }
-  toInitial.alpha = 0;
-  const toKfs = ensureKeyframes(toSeq);
-  toKfs.push({ at: t.at, to: { alpha: 1 }, duration: t.duration, ease });
-}
-function wipeMode(direction) {
-  switch (direction) {
-    case "left":
-      return "wipe-left";
-    case "right":
-      return "wipe-right";
-    case "up":
-      return "wipe-up";
-    case "down":
-      return "wipe-down";
-  }
-}
-function transitionFilterName(index) {
-  return `_pe-transition-${index}`;
-}
-function expandSlide(_comp, t, fromSeq, toSeq) {
-  const ease = t.ease ?? "none";
-  const isHorizontal = t.direction === "left" || t.direction === "right";
-  const axis = isHorizontal ? "x" : "y";
-  const dim = isHorizontal ? "W" : "H";
-  const sign = t.direction === "left" || t.direction === "up" ? -1 : 1;
-  const fromInitial = ensureInitial(fromSeq);
-  const fromNatural = fromInitial[axis];
-  const fromTarget = composeDimOffset(fromNatural, sign, dim);
-  const fromKfs = ensureKeyframes(fromSeq);
-  fromKfs.push({ at: t.at, to: { [axis]: fromTarget }, duration: t.duration, ease });
-  const toInitial = ensureInitial(toSeq);
-  const toNatural = toInitial[axis];
-  toInitial[axis] = composeDimOffset(toNatural, -sign, dim);
-  const toKfs = ensureKeyframes(toSeq);
-  toKfs.push({ at: t.at, to: { [axis]: toNatural ?? 0 }, duration: t.duration, ease });
-}
-function composeDimOffset(natural, sign, dim) {
-  const signed = sign === 1 ? dim : `-${dim}`;
-  if (natural === void 0 || natural === 0) return signed;
-  if (typeof natural === "number") {
-    return sign === 1 ? `${natural} + ${dim}` : `${natural} - ${dim}`;
-  }
-  return sign === 1 ? `(${String(natural)}) + ${dim}` : `(${String(natural)}) - ${dim}`;
-}
-function expandMask(comp, t, fromSeq, toSeq, transitionIndex, mode, smoothing) {
-  const ease = t.ease ?? "none";
-  const inName = transitionFilterName(transitionIndex);
-  const outName = `${transitionFilterName(transitionIndex)}-out`;
-  const sm = smoothing ?? 0.02;
-  const compW = comp.width ?? 0;
-  const compH = comp.height ?? 0;
-  const fullArea = { x: 0, y: 0, width: compW, height: compH };
-  const toFilters = ensureFilters(toSeq);
-  rejectReservedNameCollision(toFilters, toSeq.name);
-  toFilters.push({
-    type: "custom",
-    name: inName,
-    filter: new TransitionMaskFilter({ mode, smoothing: sm, progress: 0 })
-  });
-  ensureKeyframes(toSeq).push({
-    at: t.at,
-    to: { [`filters.${inName}.uProgress`]: 1 },
-    duration: t.duration,
-    ease
-  });
-  toSeq.filterArea = fullArea;
-  const fromFilters = ensureFilters(fromSeq);
-  rejectReservedNameCollision(fromFilters, fromSeq.name);
-  fromFilters.push({
-    type: "custom",
-    name: outName,
-    filter: new TransitionMaskFilter({ mode, smoothing: sm, progress: 0, invert: true })
-  });
-  ensureKeyframes(fromSeq).push({
-    at: t.at,
-    to: { [`filters.${outName}.uProgress`]: 1 },
-    duration: t.duration,
-    ease
-  });
-  fromSeq.filterArea = fullArea;
-}
-function expandDip(_comp, t, fromSeq, toSeq) {
-  const ease = t.ease ?? "none";
-  const half = t.duration / 2;
-  ensureKeyframes(fromSeq).push({
-    at: t.at,
-    to: { alpha: 0 },
-    duration: half,
-    ease
-  });
-  const toInitial = ensureInitial(toSeq);
-  if (toInitial.alpha !== void 0 && toInitial.alpha !== 0) {
-    throw new Error(
-      `pixi-effects: dip "${t.from}"\u2192"${t.to}" requires "${t.to}" to start invisible, but it already has initial.alpha=${String(toInitial.alpha)}. Remove the manual setting.`
-    );
-  }
-  toInitial.alpha = 0;
-  ensureKeyframes(toSeq).push({
-    at: t.at + half,
-    to: { alpha: 1 },
-    duration: half,
-    ease
-  });
-}
-function expandZoom(_comp, t, fromSeq, toSeq) {
-  const ease = t.ease ?? "none";
-  const startScale = t.fromScale ?? 4;
-  const mode = t.mode ?? "in";
-  if (mode === "in") {
-    ensureKeyframes(fromSeq).push({
-      at: t.at,
-      to: { alpha: 0 },
-      duration: t.duration,
-      ease
-    });
-    const toInitial = ensureInitial(toSeq);
-    toInitial.alpha = 0;
-    toInitial.scale = startScale;
-    ensureKeyframes(toSeq).push({
-      at: t.at,
-      to: { alpha: 1, scale: 1 },
-      duration: t.duration,
-      ease
-    });
-  } else {
-    ensureKeyframes(fromSeq).push({
-      at: t.at,
-      to: { alpha: 0, scale: startScale },
-      duration: t.duration,
-      ease
-    });
-    const toInitial = ensureInitial(toSeq);
-    toInitial.alpha = 0;
-    ensureKeyframes(toSeq).push({
-      at: t.at,
-      to: { alpha: 1 },
-      duration: t.duration,
-      ease
-    });
-  }
-}
-function expandDissolve(comp, t, fromSeq, toSeq, transitionIndex) {
-  const ease = t.ease ?? "none";
-  const inName = transitionFilterName(transitionIndex);
-  const outName = `${transitionFilterName(transitionIndex)}-out`;
-  const sm = t.smoothing ?? 0.05;
-  const scale = t.scale ?? 30;
-  const seed = t.seed ?? 0;
-  const compW = comp.width ?? 0;
-  const compH = comp.height ?? 0;
-  const fullArea = { x: 0, y: 0, width: compW, height: compH };
-  const toFilters = ensureFilters(toSeq);
-  rejectReservedNameCollision(toFilters, toSeq.name);
-  toFilters.push({
-    type: "custom",
-    name: inName,
-    filter: new TransitionMaskFilter({ mode: "dissolve", smoothing: sm, progress: 0, scale, seed })
-  });
-  ensureKeyframes(toSeq).push({
-    at: t.at,
-    to: { [`filters.${inName}.uProgress`]: 1 },
-    duration: t.duration,
-    ease
-  });
-  toSeq.filterArea = fullArea;
-  const fromFilters = ensureFilters(fromSeq);
-  rejectReservedNameCollision(fromFilters, fromSeq.name);
-  fromFilters.push({
-    type: "custom",
-    name: outName,
-    filter: new TransitionMaskFilter({ mode: "dissolve", smoothing: sm, progress: 0, scale, seed, invert: true })
-  });
-  ensureKeyframes(fromSeq).push({
-    at: t.at,
-    to: { [`filters.${outName}.uProgress`]: 1 },
-    duration: t.duration,
-    ease
-  });
-  fromSeq.filterArea = fullArea;
-}
-function expandLuma(comp, t, fromSeq, toSeq, transitionIndex) {
-  const ease = t.ease ?? "none";
-  const inName = transitionFilterName(transitionIndex);
-  const outName = `${transitionFilterName(transitionIndex)}-out`;
-  const fullArea = { x: 0, y: 0, width: comp.width ?? 0, height: comp.height ?? 0 };
-  const opts = { map: t.map ?? "linear", softness: t.softness ?? 0.1, flip: t.flip ?? false };
-  for (const [seq, name, invert] of [[toSeq, inName, false], [fromSeq, outName, true]]) {
-    const filters = ensureFilters(seq);
-    rejectReservedNameCollision(filters, seq.name);
-    filters.push({ type: "custom", name, filter: new LumaWipeFilter({ ...opts, invert }) });
-    ensureKeyframes(seq).push({ at: t.at, to: { [`filters.${name}.uProgress`]: 1 }, duration: t.duration, ease });
-    seq.filterArea = fullArea;
-  }
-}
-var OWN_NAME_PATTERN = /^_pe-transition-\d+(-out)?$/;
-function rejectReservedNameCollision(filters, seqName) {
-  for (const f of filters) {
-    if (typeof f.name === "string" && f.name.startsWith("_pe-transition-") && !OWN_NAME_PATTERN.test(f.name)) {
-      throw new Error(
-        `pixi-effects: sequence "${seqName}" already has a filter named "${f.name}" \u2014 the reserved name prefix "_pe-transition-" is for internally generated transition filters`
-      );
-    }
-  }
-}
-
-// src/core/inspect.ts
-var FAINT = 0.3;
-var intersection = (a, b) => {
-  const w = Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x);
-  const h = Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y);
-  return w > 0 && h > 0 ? w * h : 0;
-};
-var clip = (a, b) => {
-  const x = Math.max(a.x, b.x), y = Math.max(a.y, b.y);
-  const w = Math.min(a.x + a.width, b.x + b.width) - x, h = Math.min(a.y + a.height, b.y + b.height) - y;
-  return w > 0 && h > 0 ? { x, y, width: w, height: h } : null;
-};
-function inspectScene(root, frame, time, canvas, opts = {}) {
-  const layers = [];
-  const view = { x: 0, y: 0, width: canvas.width, height: canvas.height };
-  const seen = /* @__PURE__ */ new Map();
-  const scene = /* @__PURE__ */ new Map();
-  const scaledToNothing = /* @__PURE__ */ new Set();
-  const walk2 = (comp, prefix, insideThreeD, parentVisible, parentScene, parentMoving = false, parentZero = false) => {
-    const blending = /* @__PURE__ */ new Set();
-    const now = comp.childTime(time);
-    for (const w of transitionWindowsOf(comp.spec)) {
-      const start = comp.childBase + w.start, end = comp.childBase + w.end;
-      if (now >= start - 1e-9 && now <= end + 1e-9) {
-        blending.add(w.from);
-        blending.add(w.to);
-      }
-    }
-    comp.layers().forEach(({ seq, display, threeD, carriers, depthBlur, light }, i) => {
-      const t = seq.target;
-      const name = seq.spec.name;
-      const label = name ?? `${seq.spec.type}#${i}`;
-      const alpha = (t?.alpha ?? 1) * carriers.reduce((a, c) => a * (c.target?.alpha ?? 1), 1);
-      const alive = (threeD ? display.visible : t?.renderable ?? true) && carriers.every((c) => c.target?.renderable ?? true);
-      const visible = parentVisible && alive && alpha > 0;
-      let bounds = null;
-      if (!insideThreeD) {
-        const b = display.getBounds();
-        bounds = { x: b.x, y: b.y, width: b.width, height: b.height };
-      }
-      let onCanvas = null;
-      if (bounds) {
-        const inter = intersection(bounds, view);
-        const area = bounds.width * bounds.height;
-        onCanvas = inter === 0 && area > 0 ? "none" : inter >= area - 1e-6 ? "full" : "partial";
-        if (area === 0) onCanvas = "none";
-      }
-      const keys = collectPropKeys(seq.spec);
-      const carried = carriers.some((c) => {
-        const k = collectPropKeys(c.spec);
-        return (c.spec.keyframes ?? []).length > 0 && (k.has("x") || k.has("y") || k.has("rotation") || k.has("scale"));
-      });
-      const moving = parentMoving || carried || (seq.spec.keyframes ?? []).length > 0 && (keys.has("x") || keys.has("y"));
-      const zeroScale = (o) => {
-        const s = o?.scale;
-        return !!s && (s.x === 0 || s.y === 0);
-      };
-      const zero = parentZero || zeroScale(t) || carriers.some((c) => zeroScale(c.target));
-      const info = { path: prefix + label, name, type: seq.spec.type, threeD, visible, alpha, moving, bounds, onCanvas };
-      if (threeD) info.depthBlur = Number(depthBlur.toFixed(2));
-      if (threeD && light !== void 0) info.light = Number(light.toFixed(2));
-      layers.push(info);
-      let shown = bounds ? clip(bounds, view) : null;
-      const maskTarget = seq.maskSequence?.target;
-      if (shown && maskTarget && !seq.spec.maskInverted) {
-        const m = maskTarget.getBounds();
-        shown = clip(shown, { x: m.x, y: m.y, width: m.width, height: m.height });
-      }
-      seen.set(info, shown);
-      const group = parentScene ?? (name !== void 0 && blending.has(name) ? name : void 0);
-      if (group) scene.set(info, group);
-      if (zero || seq.showsNothingYet) scaledToNothing.add(info);
-      if (seq instanceof CompositionSequence) walk2(seq, prefix + label + "/", insideThreeD || threeD, visible, group, moving, zero);
-    });
-  };
-  walk2(root, "", false, true);
-  const issues = [];
-  const texts = layers.filter((l) => l.type === "text" && l.visible && l.alpha >= FAINT && l.bounds);
-  for (const l of texts) {
-    const b = l.bounds;
-    const who = `text layer "${l.path}"`;
-    if (b.width < 1 || b.height < 1) {
-      if (scaledToNothing.has(l)) continue;
-      issues.push(`${who} has no size (empty text, or not drawn yet)`);
-    } else if (l.moving || scene.has(l)) ; else if (l.onCanvas === "none") {
-      issues.push(`${who} is entirely outside the canvas (at ${Math.round(b.x)},${Math.round(b.y)}, ${Math.round(b.width)}\xD7${Math.round(b.height)})`);
-    } else if (l.onCanvas === "partial") {
-      const over = [];
-      if (b.x < 0) over.push(`${Math.round(-b.x)}px beyond the left edge`);
-      if (b.x + b.width > canvas.width) over.push(`${Math.round(b.x + b.width - canvas.width)}px beyond the right edge`);
-      if (b.y < 0) over.push(`${Math.round(-b.y)}px beyond the top edge`);
-      if (b.y + b.height > canvas.height) over.push(`${Math.round(b.y + b.height - canvas.height)}px beyond the bottom edge`);
-      issues.push(`${who} is cut off by the canvas edge: ${over.join(", ")}`);
-    }
-  }
-  for (let i = 0; i < texts.length; i++) {
-    for (let j = i + 1; j < texts.length; j++) {
-      const a = seen.get(texts[i]), b = seen.get(texts[j]);
-      if (!a || !b) continue;
-      const sa = scene.get(texts[i]), sb = scene.get(texts[j]);
-      if (sa && sb && sa !== sb) continue;
-      const smaller = Math.min(a.width * a.height, b.width * b.height);
-      if (smaller <= 0) continue;
-      const share = intersection(a, b) / smaller;
-      if (share > 0.25) issues.push(`text layers "${texts[i].path}" and "${texts[j].path}" overlap by ${Math.round(share * 100)}% of the smaller one`);
-    }
-  }
-  const mode = opts.layers ?? "all";
-  const listed = mode === "none" ? [] : mode === "visible" ? layers.filter((l) => l.visible) : layers;
-  return { frame, time, canvas, summary: { layers: layers.length, visible: layers.filter((l) => l.visible).length }, issues, layers: listed };
-}
-
-// src/core/timelineChart.ts
-var GROUP_MIN = 4;
-var MAX_KEYS = 200;
-var round = (n) => Math.round(n * 1e6) / 1e6;
-var family = (name) => name.replace(/\d+/g, "#");
-function detailOf(seq) {
-  const s = seq.spec;
-  if (typeof s.text === "string") return s.text.length > 60 ? s.text.slice(0, 57) + "\u2026" : s.text;
-  if (typeof s.asset === "string") return `asset \u201C${s.asset}\u201D`;
-  if (typeof s.sfx === "string") return `sfx \u201C${s.sfx}\u201D`;
-  if (s.sfx && typeof s.sfx === "object") return "sfx (custom)";
-  if (s.music && typeof s.music === "object") return "music";
-  return void 0;
-}
-function walk(comp, parentStart, parentEnd, depth, prefix, rows, transitions, local) {
-  const entries = [];
-  comp._children.forEach((seq, i) => {
-    const name = seq.spec.name ?? `${seq.spec.type}#${i}`;
-    const start = parentStart + (seq.at ?? 0);
-    const end = Math.min(parentEnd, seq.duration !== void 0 ? start + seq.duration : parentEnd);
-    const span = end - start;
-    const keys = (seq.spec.keyframes ?? []).map((kf) => round(start + resolveAt(kf.at, span))).sort((a, b) => a - b).slice(0, MAX_KEYS);
-    const row = { path: prefix + name, name, type: seq.spec.type, depth, start: round(start), end: round(end), keys, detail: detailOf(seq), ...local ? { local } : {} };
-    const inner = [];
-    const isComp = seq instanceof CompositionSequence;
-    if (isComp) {
-      const label = seq.remapLabel();
-      walk(seq, label ? 0 : start, label ? seq.contentSpan : end, depth + 1, prefix + name + "/", inner, transitions, label ? `${name} ${label}` : local);
-    }
-    entries.push({ row, inner, groupable: !isComp });
-  });
-  rows.push(...groupFamilies(entries));
-  for (const w of transitionWindowsOf(comp.spec)) {
-    transitions.push({ from: prefix + w.from, to: prefix + w.to, start: round(parentStart + w.start), end: round(parentStart + w.end), ...local ? { local } : {} });
-  }
-}
-function groupFamilies(entries) {
-  const buckets = /* @__PURE__ */ new Map();
-  for (const e of entries) {
-    if (!e.groupable) continue;
-    const key = e.row.type + "|" + family(e.row.name);
-    (buckets.get(key) ?? buckets.set(key, []).get(key)).push(e.row);
-  }
-  const out = [];
-  const done = /* @__PURE__ */ new Set();
-  for (const e of entries) {
-    const key = e.row.type + "|" + family(e.row.name);
-    const members = e.groupable ? buckets.get(key) : null;
-    if (members && members.length >= GROUP_MIN) {
-      if (done.has(key)) continue;
-      done.add(key);
-      const label = `${family(e.row.name)} \xD7${members.length}`;
-      out.push({
-        path: e.row.path.slice(0, e.row.path.length - e.row.name.length) + label,
-        name: label,
-        type: e.row.type,
-        depth: e.row.depth,
-        start: Math.min(...members.map((x) => x.start)),
-        end: Math.max(...members.map((x) => x.end)),
-        keys: members.flatMap((x) => x.keys).sort((a, b) => a - b).slice(0, MAX_KEYS),
-        parts: members.map((x) => ({ start: x.start, end: x.end })),
-        partNames: members.map((x) => x.name)
-      });
-    } else {
-      out.push(e.row, ...e.inner);
-      continue;
-    }
-    out.push(...e.inner);
-  }
-  return out;
-}
-function collectTimeline(root, duration) {
-  const rows = [];
-  const transitions = [];
-  const label = root.remapLabel();
-  walk(root, 0, label ? root.contentSpan : duration, 0, "", rows, transitions, label ? `movie ${label}` : void 0);
-  return { duration, rows, transitions };
-}
-var COLORS = {
-  text: "#4cc9f0",
-  shape: "#ffd166",
-  image: "#7bd88f",
-  video: "#c77dff",
-  audio: "#ff7aa8",
-  composition: "#8ea4c8",
-  three: "#ff9f68",
-  camera: "#b0b0b0",
-  light: "#b0b0b0",
-  null: "#b0b0b0"
-};
-var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-var num = (n) => String(Math.round(n * 100) / 100);
-function tickStep(duration, chartWidth) {
-  for (const s of [0.04, 0.1, 0.2, 0.5, 1, 2, 5, 10, 15, 30, 60, 120, 300, 600, 1200, 3600]) if (s / duration * chartWidth >= 70) return s;
-  return 7200;
-}
-function timelineSvg(data, opts = {}) {
-  const CHART = Math.max(100, opts.chartWidth ?? 950), withLabels = opts.labels !== false;
-  const LABEL = withLabels ? 250 : 0, ROW = 22, TOP = 34, PAD = 16;
-  const W = LABEL + CHART + PAD * 2, H = TOP + data.rows.length * ROW + PAD;
-  const x = (t) => PAD + LABEL + Math.max(0, Math.min(data.duration, t)) / data.duration * CHART;
-  const step = tickStep(data.duration, CHART);
-  const out = [];
-  for (let t = 0; t <= data.duration + 1e-9; t += step) {
-    out.push(`<line class="grid" x1="${num(x(t))}" y1="${TOP - 6}" x2="${num(x(t))}" y2="${H - PAD}"/>`);
-    out.push(`<text class="tick" x="${num(x(t))}" y="${TOP - 12}" text-anchor="middle">${num(t)}${t === 0 || Math.abs(t - data.duration) < 1e-9 ? " s" : ""}</text>`);
-  }
-  if (Math.abs(data.duration % step) > 1e-9) out.push(`<text class="tick" x="${num(x(data.duration))}" y="${TOP - 12}" text-anchor="middle">${num(data.duration)} s</text>`);
-  for (const t of data.transitions) {
-    out.push(`<g><title>transition ${esc(t.from)} \u2192 ${esc(t.to)} (${num(t.start)}\u2013${num(t.end)} s${t.local ? `, local time of ${esc(t.local)}` : ""})</title><rect class="transition" x="${num(x(t.start))}" y="${TOP - 4}" width="${num(Math.max(2, x(t.end) - x(t.start)))}" height="${H - TOP - PAD + 4}"/></g>`);
-  }
-  data.rows.forEach((r, i) => {
-    const y = TOP + i * ROW;
-    const color = COLORS[r.type] ?? "#9aa7b8";
-    const tip = `${r.path} \xB7 ${r.type} \xB7 ${num(r.start)}\u2013${num(r.end)} s (${num(r.end - r.start)} s)${r.keys.length ? ` \xB7 ${r.keys.length} keyframe${r.keys.length > 1 ? "s" : ""}` : ""}${r.detail ? ` \xB7 ${r.detail}` : ""}${r.local ? ` \xB7 local time of ${r.local}` : ""}`;
-    out.push(`<g class="row" data-start="${num(r.start)}"><title>${esc(tip)}</title>`);
-    out.push(`<rect class="band" x="${PAD}" y="${y}" width="${LABEL + CHART}" height="${ROW}" ${i % 2 ? 'fill-opacity=".05"' : 'fill-opacity="0"'}/>`);
-    if (withLabels) out.push(`<text class="label" x="${PAD + 6 + r.depth * 14}" y="${y + 15}">${esc(r.name)}</text>`);
-    for (const p of r.parts ?? [{ start: r.start, end: r.end }]) {
-      out.push(`<rect class="bar" x="${num(x(p.start))}" y="${y + 4}" width="${num(Math.max(2, x(p.end) - x(p.start)))}" height="${ROW - 8}" rx="3" fill="${color}"/>`);
-    }
-    for (const k of r.keys) out.push(`<path class="key" d="M ${num(x(k))} ${y + 7} l 3 4 l -3 4 l -3 -4 z"/>`);
-    out.push("</g>");
-  });
-  const LEGEND_STEP = 108, perLine = Math.max(1, Math.floor((W - PAD * 2) / LEGEND_STEP));
-  const kinds = Object.entries(COLORS), lines = Math.ceil(kinds.length / perLine), HH = H + 14 + lines * 18;
-  const legend = kinds.map(([type, c], i) => `<g transform="translate(${PAD + i % perLine * LEGEND_STEP},${H + 10 + Math.floor(i / perLine) * 18})"><rect width="12" height="12" rx="3" fill="${c}"/><text x="18" y="10" class="tick">${type}</text></g>`).join("");
-  return `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${HH}" viewBox="0 0 ${W} ${HH}" role="img" aria-label="Timeline of ${data.rows.length} rows" data-duration="${num(data.duration)}" data-x0="${num(x(0))}" data-x1="${num(x(data.duration))}" data-top="${TOP - 6}" data-bottom="${H - PAD}" data-row="${ROW}">
-${out.join("\n")}
-${legend}
-</svg>`;
-}
-function timelineHtml(data, opts = {}) {
-  const W = 250 + 950 + 32;
-  const title = esc(opts.title ?? "Timeline");
-  return `<!doctype html>
-<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>${title} \u2014 timeline</title>
-<style>
-  :root { --bg: #f7f5f1; --ink: #1d2433; --dim: #6b7587; --grid: #d9d5cc; --key: #1d2433; --trans: #4cc9f0; }
-  @media (prefers-color-scheme: dark) { :root { --bg: #0e1320; --ink: #e8eefc; --dim: #8fa0bf; --grid: #26304a; --key: #ffffff; --trans: #4cc9f0; } }
-  body { margin: 0; background: var(--bg); color: var(--ink); font: 14px system-ui, sans-serif; }
-  main { padding: 20px 16px 32px; max-width: ${W + 32}px; margin: 0 auto; overflow-x: auto; }
-  h1 { font-size: 18px; font-weight: 600; margin: 0 0 4px; }
-  p { margin: 0 0 14px; color: var(--dim); font-size: 13px; }
-  svg { display: block; }
-  .grid { stroke: var(--grid); stroke-width: 1; }
-  .tick { fill: var(--dim); font-size: 11px; }
-  .label { fill: var(--ink); font-size: 12px; font-family: ui-monospace, Menlo, monospace; }
-  .band { fill: var(--ink); }
-  .key { fill: var(--key); opacity: .85; }
-  .transition { fill: var(--trans); opacity: .16; }
-  .bar { opacity: .88; }
-  .row:hover .bar { opacity: 1; }
-</style></head>
-<body><main>
-<h1>${title}</h1>
-<p>${data.rows.length} row${data.rows.length === 1 ? "" : "s"} \xB7 ${num(data.duration)} s \xB7 \u25C6 keyframe start \xB7 shaded band: a transition \xB7 hover a bar for details</p>
-${timelineSvg(data)}
-</main></body></html>
-`;
-}
-
-// src/core/frames.ts
-function pickFrames(lastFrame, count) {
-  const last = Math.max(0, Math.floor(lastFrame));
-  const n = Math.max(1, Math.floor(count));
-  if (n === 1) return [0];
-  const out = [];
-  for (let i = 0; i < n; i++) {
-    const f = Math.round(last * i / (n - 1));
-    if (out[out.length - 1] !== f) out.push(f);
-  }
-  return out;
-}
-function sheetLayout(n, columns, cellW, srcW, srcH, labelH) {
-  const cols = Math.max(1, Math.min(Math.floor(columns), n));
-  const rows = Math.ceil(n / cols);
-  const cellH = Math.round(cellW * srcH / srcW);
-  const positions = Array.from({ length: n }, (_, i) => ({ x: i % cols * cellW, y: Math.floor(i / cols) * (cellH + labelH) }));
-  return { cols, rows, cellW, cellH, width: cols * cellW, height: rows * (cellH + labelH), positions };
-}
-
-// src/core/startWhenRunning.ts
-function startWhenRunning(ctx, start, gesture) {
-  if (ctx.state === "running") {
-    start();
-    return () => {
-    };
-  }
-  let done = false;
-  const resume = () => {
-    ctx.resume?.()?.catch(() => {
-    });
-  };
-  const stop = () => {
-    done = true;
-    ctx.removeEventListener("statechange", onState);
-    for (const e of GESTURES) gesture?.removeEventListener(e, resume, true);
-  };
-  const onState = () => {
-    if (done || ctx.state !== "running") return;
-    stop();
-    start();
-  };
-  ctx.addEventListener("statechange", onState);
-  for (const e of GESTURES) gesture?.addEventListener(e, resume, true);
-  resume();
-  return stop;
-}
-var GESTURES = ["pointerdown", "mousedown", "touchend", "keydown"];
-function audioIsBlocked(ctx, hasAudio) {
-  return !!ctx && hasAudio && ctx.state !== "running";
-}
-
-// src/core/poster.ts
-function normalizePoster(poster, duration, frameRate) {
-  if (poster === void 0 || poster === null) return { seconds: null, frame: null };
-  if (typeof poster !== "number" || !Number.isFinite(poster)) {
-    console.warn(`pixi-effects: movie.init({ poster }): ${JSON.stringify(poster)} is not a time in seconds; ignored`);
-    return { seconds: null, frame: null };
-  }
-  let seconds = poster < 0 ? Math.max(0, duration + poster) : poster;
-  if (seconds > duration) {
-    console.warn(`pixi-effects: movie.init({ poster }): the poster time ${poster} s is past the end of the movie (${duration} s); using the last frame`);
-    seconds = duration;
-  }
-  return { seconds, frame: Math.round(seconds * frameRate) };
-}
-
-// src/core/pdf.ts
-var enc = (s) => {
-  const out = new Uint8Array(s.length);
-  for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i) & 255;
-  return out;
-};
-var num2 = (n) => String(Math.round(n * 1e3) / 1e3);
-var textString = (s) => {
-  if (/^[\x20-\x7e]*$/.test(s)) return `(${s.replace(/[\\()]/g, (m) => `\\${m}`)})`;
-  let hex = "FEFF";
-  for (let i = 0; i < s.length; i++) hex += s.charCodeAt(i).toString(16).toUpperCase().padStart(4, "0");
-  return `<${hex}>`;
-};
-function buildPdf(pages, opts = {}) {
-  if (pages.length === 0) throw new Error("pixi-effects: a PDF needs at least one page");
-  const first = (i) => 3 + i * 3;
-  const objects = [];
-  objects[1] = [enc("<< /Type /Catalog /Pages 2 0 R >>")];
-  objects[2] = [enc(`<< /Type /Pages /Kids [${pages.map((_, i) => `${first(i)} 0 R`).join(" ")}] /Count ${pages.length} >>`)];
-  pages.forEach((p, i) => {
-    const w = p.width * 0.75, h = p.height * 0.75, n = first(i);
-    objects[n] = [enc(`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${num2(w)} ${num2(h)}] /Resources << /XObject << /Im0 ${n + 2} 0 R >> >> /Contents ${n + 1} 0 R >>`)];
-    const content = `q ${num2(w)} 0 0 ${num2(h)} 0 0 cm /Im0 Do Q`;
-    objects[n + 1] = [enc(`<< /Length ${content.length} >>
-stream
-${content}
-endstream`)];
-    objects[n + 2] = [enc(`<< /Type /XObject /Subtype /Image /Width ${p.width} /Height ${p.height} /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode /Length ${p.jpeg.length} >>
-stream
-`), p.jpeg, enc("\nendstream")];
-  });
-  const infoNo = opts.title !== void 0 ? first(pages.length) : 0;
-  if (infoNo) objects[infoNo] = [enc(`<< /Title ${textString(opts.title)} /Producer (pixi-effects) >>`)];
-  const count = infoNo || first(pages.length);
-  const chunks = [enc("%PDF-1.4\n%\xE2\xE3\xCF\xD3\n")];
-  let offset = chunks[0].length;
-  const offsets = [];
-  for (let n = 1; n < count + (infoNo ? 1 : 0); n++) {
-    const body = objects[n];
-    if (!body) continue;
-    offsets[n] = offset;
-    const parts = [enc(`${n} 0 obj
-`), ...body, enc("\nendobj\n")];
-    for (const part of parts) {
-      chunks.push(part);
-      offset += part.length;
-    }
-  }
-  const size = (infoNo || first(pages.length)) + (infoNo ? 1 : 0);
-  let xref = `xref
-0 ${size}
-0000000000 65535 f 
-`;
-  for (let n = 1; n < size; n++) xref += `${String(offsets[n] ?? 0).padStart(10, "0")} 00000 n 
-`;
-  xref += `trailer
-<< /Size ${size} /Root 1 0 R${infoNo ? ` /Info ${infoNo} 0 R` : ""} >>
-startxref
-${offset}
-%%EOF
-`;
-  chunks.push(enc(xref));
-  const total = chunks.reduce((sum, c) => sum + c.length, 0);
-  const out = new Uint8Array(total);
-  let at = 0;
-  for (const c of chunks) {
-    out.set(c, at);
-    at += c.length;
-  }
-  return out;
-}
-
-// src/core/stops.ts
-var KEYS = ["at", "page", "notes", "advance", "pdf"];
-function normalizeStops(raw, duration, frameRate) {
-  if (!raw || raw.length === 0) return [];
-  const total = Math.round(duration * frameRate);
-  const specs = [];
-  raw.forEach((r, i) => {
-    const spec = typeof r === "number" ? { at: r } : r && typeof r === "object" ? r : null;
-    if (!spec || typeof spec.at !== "number" || !Number.isFinite(spec.at)) {
-      console.warn(`pixi-effects: stops[${i}] ${JSON.stringify(r)} is not a time in seconds (or { at, page?, notes?, advance?, pdf? }); ignored`);
-      return;
-    }
-    if (typeof r === "object") warnUnknownOptions(`stops[${i}]`, r, KEYS);
-    const at = spec.at < 0 ? duration + spec.at : spec.at;
-    if (at < -1e-9 || at > duration + 1e-9) {
-      console.warn(`pixi-effects: stops[${i}] at ${spec.at} s is outside the movie (0 to ${duration} s); ignored`);
-      return;
-    }
-    specs.push({ ...spec, at });
-  });
-  specs.sort((a, b) => a.at - b.at);
-  const kept = [];
-  for (const s of specs) {
-    const frame = Math.min(total, Math.max(0, Math.round(s.at * frameRate)));
-    const last = kept[kept.length - 1];
-    if (last && Math.min(total, Math.max(0, Math.round(last.at * frameRate))) === frame) {
-      console.warn(`pixi-effects: two stops are on the same frame (${frame}, about ${s.at.toFixed(2)} s); one is kept`);
-      continue;
-    }
-    kept.push(s);
-  }
-  const anyPage = kept.some((s) => s.page !== void 0);
-  let pageIndex = -1, pageName = null;
-  return kept.map((s, index) => {
-    const pageStart = index === 0 || (anyPage ? s.page !== void 0 : true);
-    if (pageStart) {
-      pageIndex++;
-      pageName = typeof s.page === "string" ? s.page : null;
-    }
-    const stop = { index, at: s.at, frame: Math.min(total, Math.max(0, Math.round(s.at * frameRate))), page: pageName, pageIndex, pageStart };
-    if (typeof s.notes === "string") stop.notes = s.notes;
-    if (s.advance !== void 0) {
-      if (typeof s.advance === "number" && Number.isFinite(s.advance) && s.advance >= 0) stop.advance = s.advance;
-      else console.warn(`pixi-effects: stops[${index}] advance must be a number of seconds >= 0, got ${JSON.stringify(s.advance)}; ignored`);
-    }
-    if (s.pdf !== void 0) {
-      if (typeof s.pdf === "boolean") stop.pdf = s.pdf;
-      else console.warn(`pixi-effects: stops[${index}] pdf must be true or false, got ${JSON.stringify(s.pdf)}; ignored`);
-    }
-    return stop;
-  });
-}
-function nextStopAfter(stops, frame) {
-  return stops.find((s) => s.frame > frame) ?? null;
-}
-function previousStopBefore(stops, frame) {
-  for (let i = stops.length - 1; i >= 0; i--) if (stops[i].frame < frame) return stops[i];
-  return null;
-}
-function stopAtOrBefore(stops, frame) {
-  for (let i = stops.length - 1; i >= 0; i--) if (stops[i].frame <= frame) return stops[i];
-  return null;
-}
-function pageStarts(stops) {
-  return stops.filter((s) => s.pageStart);
-}
-function pictureStops(stops, opts = {}) {
-  if (opts.which === "stops") return opts.pdf ? stops.filter((s) => s.pdf !== false) : [...stops];
-  const byPage = /* @__PURE__ */ new Map();
-  for (const s of stops) byPage.set(s.pageIndex, [...byPage.get(s.pageIndex) ?? [], s]);
-  const take = (list) => opts.pick === "first" ? list[0] : list[list.length - 1];
-  const picks = [];
-  for (const list of byPage.values()) {
-    const flagged = list.filter((s) => s.pdf === true);
-    const usable = list.filter((s) => s.pdf !== false);
-    const one = take(flagged.length ? flagged : usable.length ? usable : opts.pdf ? [] : list);
-    if (one) picks.push(one);
-  }
-  return picks;
-}
-function changedFraction(a, b, threshold = 12) {
-  const n = Math.min(a.length, b.length) >> 2;
-  if (n === 0) return 0;
-  let changed = 0;
-  for (let i = 0; i < n; i++) {
-    const k = i << 2;
-    if (Math.abs(a[k] - b[k]) > threshold || Math.abs(a[k + 1] - b[k + 1]) > threshold || Math.abs(a[k + 2] - b[k + 2]) > threshold) changed++;
-  }
-  return changed / n;
-}
-
-// src/core/loadProgress.ts
-var STAGE_LABEL = {
-  assets: "LOADING ASSETS",
-  build: "BUILDING LAYERS",
-  sound: "MIXING SOUND",
-  frames: "PREPARING"
-};
-var ORDER = ["assets", "build", "sound", "frames"];
-var WEIGHT = { assets: 0.15, build: 0.6, sound: 0.2, frames: 0.05 };
-var YIELD_EVERY_MS = 50;
-function defaultYielder() {
-  if (typeof MessageChannel === "undefined") return new Promise((resolve) => setTimeout(resolve, 0));
-  return new Promise((resolve) => {
-    const ch = new MessageChannel();
-    ch.port1.onmessage = () => {
-      ch.port1.close();
-      resolve();
-    };
-    ch.port2.postMessage(0);
-  });
-}
-var LoadProgress = class {
-  constructor(_onChange, opts = {}) {
-    this._onChange = _onChange;
-    this._now = opts.now ?? (() => typeof performance !== "undefined" ? performance.now() : Date.now());
-    this._yielder = opts.yielder ?? defaultYielder;
-    this._hidden = opts.hidden ?? (() => typeof document !== "undefined" && document.hidden === true);
-    this._every = opts.yieldEveryMs ?? YIELD_EVERY_MS;
-    this._lastYield = this._now();
-  }
-  _onChange;
-  _stage = null;
-  _loaded = 0;
-  _part = 0;
-  _total = 0;
-  _high = 0;
-  _started = 0;
-  _ms = { assets: 0, build: 0, sound: 0, frames: 0 };
-  _lastYield;
-  _now;
-  _yielder;
-  _every;
-  _hidden;
-  get progress() {
-    return this._high;
-  }
-  /** Start a stage with `total` items (0 = nothing to wait for). Every earlier stage is done. */
-  begin(stage, total) {
-    this._closeTiming();
-    this._stage = stage;
-    this._loaded = 0;
-    this._part = 0;
-    this._total = Math.max(0, total);
-    this._started = this._now();
-    this._emit();
-  }
-  tick(n = 1) {
-    if (!this._stage) return;
-    this._loaded = Math.min(this._total, this._loaded + n);
-    this._part = 0;
-    this._emit();
-  }
-  /** How much of the item being worked on is done (0..1), for an item that takes long: the number moves between two `tick`s. */
-  part(done) {
-    if (!this._stage) return;
-    this._part = Math.min(1, Math.max(0, done));
-    this._emit();
-  }
-  /** Everything is done: 1, whatever stage it was in. */
-  finish() {
-    this._closeTiming();
-    this._stage = this._stage ?? "frames";
-    this._loaded = this._total;
-    this._high = 1;
-    this._onChange({ stage: this._stage, loaded: this._loaded, total: this._total, progress: 1 });
-  }
-  /** Milliseconds each stage took (a stage never begun is 0). */
-  timings() {
-    return { ...this._ms };
-  }
-  /** Await one macrotask when 50 ms of work have gone by since the last time, so the page can paint the bar. Cheap when it is not due. */
-  async yieldIfDue() {
-    const t = this._now();
-    if (t - this._lastYield < this._every || this._hidden()) return;
-    await this._yielder();
-    this._lastYield = this._now();
-  }
-  _closeTiming() {
-    if (this._stage) this._ms[this._stage] += Math.max(0, this._now() - this._started);
-  }
-  _emit() {
-    const stage = this._stage;
-    let done = 0;
-    for (const s of ORDER) {
-      if (s === stage) break;
-      done += WEIGHT[s];
-    }
-    const within = this._total > 0 ? Math.min(1, (this._loaded + this._part) / this._total) : 1;
-    this._high = Math.min(1, Math.max(this._high, done + WEIGHT[stage] * within));
-    this._onChange({ stage, loaded: this._loaded, total: this._total, progress: this._high });
-  }
-};
-
-// src/core/loader.ts
-var FADE_FALLBACK_MS = 900;
-function resolveLoader(option, canvas) {
-  if (option === false) return null;
-  if (option instanceof HTMLElement) return option;
-  if (typeof option === "string") return document.querySelector(option);
-  let box = canvas?.parentElement ?? null;
-  for (let level = 0; box && level < 4; level++, box = box.parentElement) {
-    if (level > 0 && (box === document.body || box === document.documentElement)) break;
-    const found = box.querySelector(".pe-loader");
-    if (found) return found;
-  }
-  return null;
-}
-function dismissLoader(loader) {
-  if (!loader || loader.classList.contains("pe-loader--done")) return;
-  loader.classList.add("pe-loader--done");
-  loader.setAttribute("aria-hidden", "true");
-  let removed = false;
-  const remove = () => {
-    if (!removed) {
-      removed = true;
-      loader.remove();
-    }
-  };
-  loader.addEventListener("transitionend", (e) => {
-    if (e.target === loader && e.propertyName === "opacity") remove();
-  });
-  setTimeout(remove, FADE_FALLBACK_MS);
-}
-function failLoader(loader, message) {
-  if (!loader) return;
-  loader.setAttribute("data-state", "error");
-  for (const a of ["data-stage", "data-percent"]) loader.removeAttribute(a);
-  loader.querySelector(".pe-loader__bar")?.remove();
-  if (loader.hasAttribute("data-label")) loader.setAttribute("data-label", message);
-  loader.setAttribute("aria-busy", "false");
-}
-function setLoaderProgress(loader, state) {
-  if (!loader || loader.getAttribute("data-state") === "error" || loader.classList.contains("pe-loader--done")) return;
-  if (!loader.querySelector(".pe-loader__bar")) {
-    const bar = loader.ownerDocument.createElement("i");
-    bar.className = "pe-loader__bar";
-    bar.setAttribute("aria-hidden", "true");
-    loader.appendChild(bar);
-  }
-  loader.style.setProperty("--pe-progress", String(Math.round(state.progress * 1e3) / 1e3));
-  loader.setAttribute("data-stage", STAGE_LABEL[state.stage]);
-  loader.setAttribute("data-percent", String(Math.round(state.progress * 100)));
-}
-
-// src/core/Movie.ts
-extensions.add(CullerPlugin);
-var Movie = class {
-  _events = {};
-  _initState = "idle";
-  app = null;
-  timeline = null;
-  audioBuffer = null;
-  audioSource = null;
-  gainNode = null;
-  _cancelAudioStart = null;
-  /** The poster time in seconds (`movie.init({ poster })`), or null. */
-  poster = null;
-  /** The stops of the composition (`composition.stops`), checked and in order: where `next()` pauses. Empty for an ordinary movie. */
-  stops = [];
-  /** The frame `next()` is playing toward, or null. */
-  _stopAt = null;
-  _stopWaiters = [];
-  _arriving = false;
-  /** The motion blur `render()`, `snapshot()` and `contactSheet()` apply unless told otherwise (`movie.init({ motionBlur })`), or null. */
-  motionBlur = null;
-  _posterFrame = null;
-  /** The canvas shows the poster picture while the playhead is still at frame 0 (like `<video poster>`): the first seek or play replaces it. */
-  _atPoster = false;
-  /** > 0 while the movie moves its own playhead (playback, render, snapshot, contactSheet): those are not the seeks `seeking` / `seeked` report. */
-  _quiet = 0;
-  _volume = 1;
-  _muted = false;
-  isPlaying = false;
-  currentFrame = 0;
-  totalFrames = 0;
-  width = 0;
-  height = 0;
-  duration = 0;
-  frameRate = 30;
-  background = "#000000";
-  _audioContext = null;
-  _rootSequence = null;
-  /** The filters that take the time of the frame they draw (`grain`), collected once after the build. */
-  _timeFilters = [];
-  /** While a motion-blurred frame is exposed: the frame's own time, so all its sub-frames share one grain frame (and not the playhead's). */
-  _nominalTime = null;
-  _feedTimeFilters() {
-    if (!this._timeFilters.length) return;
-    const t = this._nominalTime ?? this._timeOf(this.currentFrame);
-    for (const f of this._timeFilters) f.setTime(t);
-  }
-  _rootContainer = null;
-  _raf = null;
-  /** What went into the mix, and its peak before limiting — kept for inspectAudio(). */
-  _audioSources = [];
-  _mixStats = null;
-  on(event, fn) {
-    (this._events[event] ??= []).push(fn);
-    if (event === "ready" && this._initState === "ready") {
-      try {
-        fn();
-      } catch (e) {
-        console.warn("pixi-effects: ready listener threw:", e);
-      }
-    }
-    return this;
-  }
-  off(event, fn) {
-    const list = this._events[event];
-    if (!list) return this;
-    const i = list.indexOf(fn);
-    if (i > -1) list.splice(i, 1);
-    return this;
-  }
-  emit(event, ...args) {
-    for (const fn of this._events[event] ?? []) fn(...args);
-  }
-  get isReady() {
-    return this._initState === "ready";
-  }
-  /** Milliseconds `init()` spent in each stage (assets, build, sound, frames), or null before it has finished: `check` says which stage is the slow one. */
-  get loadStages() {
-    return this._loadStages;
-  }
-  _loadStages = null;
-  /** True while the movie has sound but the browser keeps it silent until the viewer taps (iOS Safari, a page nobody has touched): a player can show "tap for sound"; the sound starts at a tap or key press that arrives while play() is pending, or at the next play() made from a tap. */
-  get audioBlocked() {
-    return audioIsBlocked(this._audioContext, !!this.audioBuffer);
-  }
-  /** The poster time as a frame number, or null. */
-  get posterFrame() {
-    return this._posterFrame;
-  }
-  /** Draw the poster frame on the canvas and leave the playhead where it is (frame 0): the picture before the movie plays. */
-  async _showPoster() {
-    if (this._posterFrame === null || !this.timeline) return;
-    const back = this.currentFrame;
-    this.currentFrame = this._posterFrame;
-    try {
-      this.timeline.time(this._timeOf(this._posterFrame));
-      await this._awaitVideoFrames();
-      this._updateSpace();
-      this._renderNow();
-    } finally {
-      this.currentFrame = back;
-    }
-    this._atPoster = true;
-  }
-  async posterImage(opts = {}) {
-    this._requireReady("posterImage");
-    const back = this.currentFrame, wasAtPoster = this._atPoster;
-    try {
-      return await this.snapshot(this._posterFrame ?? 0, opts);
-    } finally {
-      this.currentFrame = back;
-      if (wasAtPoster) await this._showPoster();
-      else await this._quietly(() => this.gotoFrame(back, true));
-    }
-  }
-  _ensureAudioContext() {
-    if (!this._audioContext) {
-      const Ctx = window.AudioContext ?? window.webkitAudioContext;
-      this._audioContext = new Ctx();
-    }
-    return this._audioContext;
-  }
-  async init(options = {}) {
-    warnUnknownOptions("movie.init()", options, ["width", "height", "duration", "frameRate", "background", "canvas", "assets", "composition", "poster", "motionBlur", "loader"]);
-    this._initState = "pending";
-    try {
-      this.width = options.width ?? 1920;
-      this.height = options.height ?? 1080;
-      this.duration = options.duration ?? 10;
-      this.frameRate = options.frameRate ?? 30;
-      this.totalFrames = Math.round(this.duration * this.frameRate);
-      const poster = normalizePoster(options.poster, this.duration, this.frameRate);
-      this.poster = poster.seconds;
-      this.motionBlur = resolveMotionBlur(options.motionBlur, "movie.init()");
-      this.stops = normalizeStops(options.composition?.stops, this.duration, this.frameRate);
-      this._posterFrame = poster.frame;
-      this.background = options.background ?? "#000000";
-      this.timeline = createTimeline({ paused: true, defaults: { ease: "none" } });
-      lengthen(this.timeline, this.duration);
-      const baseAppOptions = {
-        width: this.width,
-        height: this.height,
-        background: this.background,
-        antialias: true,
-        resolution: 1,
-        autoDensity: false,
-        preserveDrawingBuffer: true,
-        canvas: options.canvas
-      };
-      this.app = new Application();
-      try {
-        await this.app.init({ ...baseAppOptions, preference: "webgpu" });
-      } catch (err) {
-        console.warn("pixi-effects: WebGPU init failed, falling back to WebGL \u2014", err);
-        this.app = new Application();
-        await this.app.init({ ...baseAppOptions, preference: "webgl" });
-      }
-      if (usesAdvancedBlend(options.composition)) await enableAdvancedBlend(this.app.renderer);
-      const root = new Container();
-      root.cullable = true;
-      root.cullableChildren = true;
-      root.cullArea = new Rectangle(0, 0, this.width, this.height);
-      this.app.stage.addChild(root);
-      this._rootContainer = root;
-      const audioContext = this._ensureAudioContext();
-      let loaderEl;
-      const lp = new LoadProgress((state) => {
-        if (loaderEl === void 0) loaderEl = resolveLoader(options.loader, options.canvas ?? this.app?.canvas ?? null);
-        setLoaderProgress(loaderEl, state);
-        this.emit("loadprogress", state);
-      }, { yieldEveryMs: globalThis.__peLoadYieldMs });
-      const assetCount = (options.assets ?? []).length;
-      lp.begin("assets", assetCount);
-      let assetsSeen = 0;
-      await loadAssetBundle(options.assets ?? [], audioContext, (p) => {
-        const n = Math.round(p * assetCount);
-        if (n > assetsSeen) {
-          lp.tick(n - assetsSeen);
-          assetsSeen = n;
-        }
-      });
-      const rootShape = {
-        width: this.width,
-        height: this.height,
-        duration: this.duration,
-        frameRate: this.frameRate,
-        onLayerBuilt: async () => {
-          lp.tick();
-          await lp.yieldIfDue();
-        }
-      };
-      const seededComposition = options.composition ? {
-        ...options.composition,
-        width: options.composition.width ?? this.width,
-        height: options.composition.height ?? this.height,
-        duration: options.composition.duration ?? this.duration
-      } : void 0;
-      await ensureFilterLibrary(seededComposition);
-      const userComposition = seededComposition ? expandTransitions(seededComposition) : void 0;
-      const rootSeqSpec = {
-        type: "composition",
-        width: this.width,
-        height: this.height,
-        duration: this.duration,
-        ...userComposition
-      };
-      if (userComposition) carryTransitionWindows(userComposition, rootSeqSpec);
-      const composition = new CompositionSequence(rootSeqSpec, null, rootShape);
-      lp.begin("build", countLayers(rootSeqSpec));
-      await composition.build();
-      this._rootSequence = composition;
-      if (composition.target) root.addChild(composition.target);
-      composition.bindTimeline(this.timeline);
-      this._timeFilters = collectTimeFilters(composition);
-      const audios = [];
-      composition.collectAudio(audios, 0);
-      lp.begin("sound", 1);
-      if (audios.length > 0) {
-        this.audioBuffer = await mixdown(audios, this.duration, audioContext.sampleRate, async (done) => {
-          lp.part(done);
-          await lp.yieldIfDue();
-        });
-        lp.tick();
-        if (this.audioBuffer) this._mixStats = limitMix(this.audioBuffer, audios);
-      }
-      this._audioSources = audios;
-      lp.begin("frames", 0);
-      this.timeline.time(this._timeOf(0));
-      await this._awaitVideoFrames();
-      this._updateSpace();
-      this._renderNow();
-      lp.finish();
-      this._loadStages = lp.timings();
-      this._initState = "ready";
-      if (this._posterFrame !== null) await this._showPoster();
-      this.emit("ready");
-      dismissLoader(resolveLoader(options.loader, options.canvas ?? this.app?.canvas ?? null));
-    } catch (err) {
-      failLoader(resolveLoader(options.loader, options.canvas ?? null), "COULD NOT LOAD");
-      try {
-        await this.destroy();
-      } catch (cleanupErr) {
-        console.warn("pixi-effects: cleanup after init failure also threw:", cleanupErr);
-      }
-      this._emitError("init", err);
-      throw err;
-    }
-  }
-  async gotoFrame(frame, force = false) {
-    if (this._initState !== "ready") return;
-    if (!this._arriving) this._cancelStop();
-    if (!force && !this._atPoster && this.currentFrame === frame) return;
-    if (this._quiet > 0) return this._goto(frame);
-    const target = Math.max(0, Math.min(frame, this.totalFrames));
-    this.emit("seeking", { frame: target, totalFrames: this.totalFrames });
-    await this._goto(frame);
-    this.emit("seeked", { frame: this.currentFrame, totalFrames: this.totalFrames });
-  }
-  /** Run `fn` with `seeking` / `seeked` silenced: the movie is moving its own playhead, not answering a seek. */
-  async _quietly(fn) {
-    this._quiet++;
-    try {
-      return await fn();
-    } finally {
-      this._quiet--;
-    }
-  }
-  _emitError(where, error) {
-    this.emit("error", { where, message: error instanceof Error ? error.message : String(error), error });
-  }
-  async _goto(frame) {
-    this._atPoster = false;
-    this.currentFrame = Math.max(0, Math.min(frame, this.totalFrames));
-    this.timeline.time(this._timeOf(this.currentFrame));
-    await this._awaitVideoFrames();
-    this._updateSpace();
-    this._renderNow();
-    this.emit("frame", { frame: this.currentFrame, totalFrames: this.totalFrames });
-  }
-  /**
-   * The moment frame `frame` shows. The very last frame (`totalFrames`) is at the end of the movie, where every layer's lifespan
-   * has just closed: it is drawn a hair before, so a layer that lasts to the end is still on screen in the final frame
-   * (it used to be an empty one, the last frame of every export).
-   */
-  _timeOf(frame) {
-    return Math.min(frame / this.frameRate, Math.max(0, this.duration - END_MARGIN));
-  }
-  async _awaitVideoFrames(t = this._timeOf(this.currentFrame)) {
-    if (!this._rootSequence) return;
-    const collected = [];
-    const clocks = /* @__PURE__ */ new Map();
-    collectVideoSequences(this._rootSequence, collected, clocks);
-    await Promise.all(collected.map((v) => {
-      if (v.selfTimed) return v.awaitFrameAt(t);
-      const local = (clocks.get(v)?.() ?? t) - (v.absoluteStart ?? v.at);
-      if (local < 0 || local > (v.duration ?? 0)) return Promise.resolve();
-      return v.awaitFrameAt(local);
-    }));
-  }
-  async snapshot(frame = this.currentFrame, opts = {}) {
-    warnUnknownOptions("movie.snapshot()", opts, ["scale", "type", "as", "motionBlur"]);
-    this._requireReady("snapshot");
-    return this._captureFrame(clampFrame(frame, this.totalFrames), { scale: opts.scale ?? 1, type: opts.type ?? "image/png", as: opts.as ?? "blob", motionBlur: opts.motionBlur });
-  }
-  /** Seek to `frame` (quietly, and stay there) and draw the canvas on a new canvas of `scale` times its size. */
-  async _frameCanvas(frame, scale, motionBlur) {
-    const mb = this._blurFor(motionBlur, "a picture");
-    let source = this.app.canvas;
-    if (mb) {
-      source = this._blurCanvas();
-      await this._quietly(() => this._exposeFrame(frame, mb, source, true));
-    } else await this._quietly(() => this.gotoFrame(frame, true));
-    const out = document.createElement("canvas");
-    out.width = Math.max(1, Math.round(this.width * scale));
-    out.height = Math.max(1, Math.round(this.height * scale));
-    out.getContext("2d").drawImage(source, 0, 0, out.width, out.height);
-    return out;
-  }
-  /** The pixels of `frame`, small (about 320 px wide) and without motion blur, to compare pictures. */
-  async _framePixels(frame) {
-    const c = await this._frameCanvas(frame, Math.min(1, 320 / Math.max(1, this.width)), false);
-    return c.getContext("2d").getImageData(0, 0, c.width, c.height).data;
-  }
-  /** Seek to `frame` (quietly, and stay there) and encode the canvas as a picture. */
-  async _captureFrame(frame, o) {
-    const out = await this._frameCanvas(frame, o.scale, o.motionBlur);
-    return encodeCanvas(out, o.type, o.as, o.quality);
-  }
-  async stopImages(opts = {}) {
-    warnUnknownOptions("movie.stopImages()", opts, ["which", "pick", "scale", "type", "quality", "as", "motionBlur", "pdf", "onImage"]);
-    this._requireReady("stopImages");
-    if (this.stops.length === 0) return [];
-    const picks = pictureStops(this.stops, { which: opts.which, pick: opts.pick, pdf: opts.pdf });
-    this.pause();
-    const back = this.currentFrame, wasAtPoster = this._atPoster;
-    const out = [];
-    try {
-      for (const stop of picks) {
-        const image = await this._captureFrame(stop.frame, {
-          scale: opts.scale ?? 1,
-          type: opts.type ?? "image/png",
-          quality: opts.quality,
-          as: opts.as ?? "blob",
-          motionBlur: opts.motionBlur === void 0 ? false : opts.motionBlur
-        });
-        const item = { stop, page: stop.pageIndex, image };
-        out.push(item);
-        opts.onImage?.(item);
-      }
-    } finally {
-      if (wasAtPoster) await this._showPoster();
-      else await this._quietly(() => this.gotoFrame(back, true));
-    }
-    return out;
-  }
-  /**
-   * Look at every stop: is the picture there still changing? A stop is compared with the picture `lookback` frames before it (default 3):
-   * when more than `tolerance` (default 0.4 %) of the picture differs, the audience, a page overview and a PDF all see a half-finished
-   * animation. `issues` says which stop, which page and what to do; leaves the playhead where it was.
-   */
-  async inspectStops(opts = {}) {
-    warnUnknownOptions("movie.inspectStops()", opts, ["lookback", "tolerance"]);
-    this._requireReady("inspectStops");
-    const out = { stops: [], issues: [] };
-    if (this.stops.length === 0) return out;
-    const lookback = Math.max(1, Math.round(opts.lookback ?? 3));
-    const tolerance = opts.tolerance ?? 4e-3;
-    this.pause();
-    const back = this.currentFrame, wasAtPoster = this._atPoster;
-    try {
-      for (const stop of this.stops) {
-        const before = Math.max(0, stop.frame - lookback);
-        let moving = 0;
-        if (before < stop.frame) {
-          const now = await this._framePixels(stop.frame);
-          moving = changedFraction(now, await this._framePixels(before));
-        }
-        const settled = moving <= tolerance;
-        out.stops.push({ index: stop.index, page: stop.page, at: stop.at, frame: stop.frame, moving, settled });
-        if (!settled) {
-          out.issues.push(`stop ${stop.index + 1}${stop.page ? ` (page "${stop.page}")` : ""} at ${stop.at.toFixed(1)} s: the picture is still changing there (${moving < 0.1 ? (moving * 100).toFixed(1) : Math.round(moving * 100)}% of it changed in the last ${stop.frame - before} frames), so the audience, the page overview and a PDF see it mid-animation. Move the stop to after the animation has finished, or flag a settled stop of the page with \`pdf: true\`.`);
-        }
-      }
-    } finally {
-      if (wasAtPoster) await this._showPoster();
-      else await this._quietly(() => this.gotoFrame(back, true));
-    }
-    return out;
-  }
-  /**
-   * The deck as a PDF: one page per page of the talk (the page's last stop, fully built, unless a stop says `pdf: true` or `pdf: false`;
-   * `which: 'stops'` makes a page of every stop that is not `pdf: false`), each a
-   * JPEG at the canvas size. Needs `composition.stops`. A transparent background comes out black: give the movie a `background`.
-   */
-  async exportPDF(opts = {}) {
-    warnUnknownOptions("movie.exportPDF()", opts, ["which", "pick", "scale", "quality", "title", "motionBlur", "onImage"]);
-    this._requireReady("exportPDF");
-    if (this.stops.length === 0) throw new Error("pixi-effects: movie.exportPDF(): this movie has no stops, so there are no pages; add `stops` to the composition (or build it with deck())");
-    const scale = opts.scale ?? 1;
-    const images = await this.stopImages({
-      which: opts.which,
-      pick: opts.pick,
-      scale,
-      type: "image/jpeg",
-      quality: opts.quality ?? 0.92,
-      as: "blob",
-      motionBlur: opts.motionBlur,
-      pdf: true,
-      onImage: opts.onImage
-    });
-    const pages = await Promise.all(images.map(async (i) => ({
-      jpeg: new Uint8Array(await i.image.arrayBuffer()),
-      width: Math.max(1, Math.round(this.width * scale)),
-      height: Math.max(1, Math.round(this.height * scale))
-    })));
-    return new Blob([buildPdf(pages, { title: opts.title })], { type: "application/pdf" });
-  }
-  async onionSkin(opts = {}) {
-    warnUnknownOptions("movie.onionSkin()", opts, ["from", "to", "count", "scale", "as", "motionBlur"]);
-    this._requireReady("onionSkin");
-    const from = opts.from ?? 0, to = opts.to ?? this.duration, count = opts.count ?? 8, scale = opts.scale ?? 1;
-    if (!(Number.isInteger(count) && count >= 1 && count <= 64)) throw new Error(`pixi-effects: movie.onionSkin(): count must be a whole number from 1 to 64, got ${count}`);
-    if (!(from >= 0 && to <= this.duration + 1e-9 && (count === 1 || from < to))) throw new Error(`pixi-effects: movie.onionSkin(): from must be before to, inside the movie (0 to ${this.duration} s), got ${from} to ${to}`);
-    if (!(scale > 0 && scale <= 4)) throw new Error(`pixi-effects: movie.onionSkin(): scale must be above 0 and at most 4, got ${scale}`);
-    const mb = this._blurFor(opts.motionBlur, "movie.onionSkin()");
-    const blurred = mb ? this._blurCanvas() : null;
-    const out = document.createElement("canvas");
-    out.width = Math.max(1, Math.round(this.width * scale));
-    out.height = Math.max(1, Math.round(this.height * scale));
-    const g = out.getContext("2d");
-    const alphas = onionAlphas(count);
-    const frames = onionTimes(from, to, count).map((t) => clampFrame(t * this.frameRate, this.totalFrames));
-    const back = this.currentFrame, wasAtPoster = this._atPoster;
-    try {
-      for (let i = 0; i < frames.length; i++) {
-        const f = frames[i];
-        if (mb && blurred) await this._quietly(() => this._exposeFrame(f, mb, blurred, true));
-        else await this._quietly(() => this.gotoFrame(f, true));
-        g.globalAlpha = alphas[i];
-        g.drawImage(blurred ?? this.app.canvas, 0, 0, out.width, out.height);
-      }
-    } finally {
-      g.globalAlpha = 1;
-      if (wasAtPoster) await this._showPoster();
-      else await this._quietly(() => this.gotoFrame(back, true));
-    }
-    return encodeCanvas(out, "image/png", opts.as ?? "blob");
-  }
-  async contactSheet(opts = {}) {
-    warnUnknownOptions("movie.contactSheet()", opts, ["frames", "times", "count", "columns", "cellWidth", "as", "motionBlur"]);
-    this._requireReady("contactSheet");
-    const mb = this._blurFor(opts.motionBlur, "movie.contactSheet()");
-    const blurred = mb ? this._blurCanvas() : null;
-    const frames = (opts.frames ?? opts.times?.map((t) => Math.round(t * this.frameRate)) ?? pickFrames(this.totalFrames, opts.count ?? 6)).map((f) => clampFrame(f, this.totalFrames));
-    const LABEL_H = 26;
-    const L = sheetLayout(frames.length, opts.columns ?? 3, opts.cellWidth ?? 480, this.width, this.height, LABEL_H);
-    const sheet = document.createElement("canvas");
-    sheet.width = L.width;
-    sheet.height = L.height;
-    const g = sheet.getContext("2d");
-    g.fillStyle = "#10131c";
-    g.fillRect(0, 0, L.width, L.height);
-    const back = this.currentFrame, wasAtPoster = this._atPoster;
-    try {
-      for (let i = 0; i < frames.length; i++) {
-        const f = frames[i];
-        if (mb && blurred) await this._quietly(() => this._exposeFrame(f, mb, blurred, true));
-        else await this._quietly(() => this.gotoFrame(f, true));
-        const { x, y } = L.positions[i];
-        g.drawImage(blurred ?? this.app.canvas, x, y + LABEL_H, L.cellW, L.cellH);
-        g.fillStyle = "#e8ecf8";
-        g.font = "600 15px system-ui, sans-serif";
-        g.textBaseline = "middle";
-        g.fillText(`frame ${f}  \xB7  ${(f / this.frameRate).toFixed(2)}s`, x + 8, y + LABEL_H / 2);
-      }
-    } finally {
-      if (wasAtPoster) await this._showPoster();
-      else await this._quietly(() => this.gotoFrame(back, true));
-    }
-    return encodeCanvas(sheet, "image/png", opts.as ?? "blob");
-  }
-  /**
-   * Where every layer is drawn at `frame` (canvas pixels, visibility) plus `issues` — text that is off
-   * the canvas, cut by an edge, empty, or overlapping other text. Seeks there and stays there.
-   */
-  async inspect(frame = this.currentFrame, opts = { layers: "visible" }) {
-    warnUnknownOptions("movie.inspect()", opts, ["layers"]);
-    this._requireReady("inspect");
-    const f = clampFrame(frame, this.totalFrames);
-    await this.gotoFrame(f, true);
-    return inspectScene(this._rootSequence, f, f / this.frameRate, { width: this.width, height: this.height }, opts);
-  }
-  /**
-   * Every layer as a row with absolute start / end / keyframe times (seconds), plus the transition windows. Runs of
-   * similar layers (`pop-1` … `pop-12`) are one row with a `parts` span each. Read it, or draw it with `timelineChart()`.
-   */
-  timelineData() {
-    this._requireReady("timelineData");
-    return collectTimeline(this._rootSequence, this.duration);
-  }
-  /** The timeline as one self-contained HTML page (an inline SVG, no scripts): layers as bars on a time axis, ◆ keyframes, transition bands. Open it in a browser. */
-  timelineChart(opts = {}) {
-    warnUnknownOptions("movie.timelineChart()", opts, ["title"]);
-    return timelineHtml(this.timelineData(), opts);
-  }
-  /** Just the chart: one `<svg>` whose geometry is in `data-*` attributes (a viewer puts a playhead on it: `pixi-effects-view`). */
-  timelineSvg(opts = {}) {
-    warnUnknownOptions("movie.timelineSvg()", opts, ["chartWidth", "labels"]);
-    return timelineSvg(this.timelineData(), opts);
-  }
-  /**
-   * The soundtrack, measured: when every audio layer plays, how loud the mix is over time, and `issues`
-   * (limiting, inaudible layers, sounds cut off by the end). Use it to CHECK sound you cannot hear.
-   */
-  /** The pictures to look at for moments such as `3.5`, `50%`, `f120`, `title@end` (comma-separated). A mistake says what could not be read. */
-  resolveAt(list) {
-    this._requireReady("resolveAt");
-    return resolveAtList(list, { frameRate: this.frameRate, totalFrames: this.totalFrames, duration: this.duration, rows: this.timelineData().rows });
-  }
-  /**
-   * One call that looks at everything `pixi-effects-check` looks at inside the page: layout issues over the whole timeline (every
-   * scene's first and last frame and a frame every 0.25 s), fonts and the sound. See `ReviewReport`. Page warnings are in `window.__logs`. The movie is left as it was.
-   */
-  async review(opts = {}) {
-    warnUnknownOptions("movie.review()", opts, ["at", "strict"]);
-    this._requireReady("review");
-    const back = this.currentFrame, wasAtPoster = this._atPoster;
-    try {
-      return await reviewMovie(this, opts);
-    } finally {
-      this.currentFrame = back;
-      if (wasAtPoster) await this._showPoster();
-      else await this._quietly(() => this.gotoFrame(back, true));
-    }
-  }
-  /**
-   * The fonts of the text layers: `missing` lists layers none of whose `fontFamily` entries is available in this browser (they are
-   * drawn in a fallback font), `failed` lists web fonts (`@font-face`) whose file could not be loaded.
-   */
-  inspectFonts() {
-    this._requireReady("inspectFonts");
-    return inspectFonts(this._rootSequence);
-  }
-  inspectAudio(opts = {}) {
-    warnUnknownOptions("movie.inspectAudio()", opts, ["window", "scenes"]);
-    this._requireReady("inspectAudio");
-    const scenes = opts.scenes ?? namedScenes(this.timelineData().rows);
-    return analyzeAudio(this.audioBuffer, this._audioSources, this._mixStats, this.duration, { ...opts, scenes });
-  }
-  /**
-   * Draw the stage now. PixiJS's CullerPlugin only culls inside `app.render()` (the ticker), and we render
-   * by hand — while seeking and especially during `render()`, which stops the ticker — so without this the
-   * `culled` flags are whatever the last tick left: a layer that is now on screen can stay culled and be
-   * missing from the frame or from the exported video. Cull again (updating transforms: the timeline just
-   * moved things) right before drawing.
-   */
-  _renderNow() {
-    const app = this.app;
-    if (!app?.renderer) return;
-    if (!this._synced) this._rootSequence?.syncFrame();
-    this._synced = false;
-    this._feedTimeFilters();
-    Culler.shared.cull(app.stage, app.renderer.screen, false);
-    app.renderer.render({ container: app.stage });
-  }
-  _requireReady(what) {
-    if (this._initState !== "ready" || !this._rootSequence || !this.app) {
-      throw new Error(`pixi-effects: movie.${what}() needs a ready movie \u2014 await movie.init(...) first`);
-    }
-  }
-  /** True when the layers were already synced to the playhead for the frame about to be drawn (so `_renderNow` need not do it again). */
-  _synced = false;
-  /**
-   * Projects every `threeD` layer for the current frame (see src/space). A threeD card is drawn into its own texture HERE, before the stage is
-   * drawn, so the shapes inside it must be brought up to the playhead first: syncing only in `_renderNow` left every card showing the state of
-   * the frame before (after a jump seek, a card whose children were animated showed a stale picture).
-   */
-  _updateSpace(t = this._timeOf(this.currentFrame)) {
-    this._feedTimeFilters();
-    if (!this._rootSequence || !this.app) return;
-    this._rootSequence.syncFrame();
-    this._synced = true;
-    this._rootSequence.updateSpace(t, this.app.renderer);
-  }
-  /** The motion blur an operation uses: its own option when given (`false` is off), otherwise the movie's. */
-  _blurFor(option, where) {
-    return option === void 0 ? this.motionBlur : resolveMotionBlur(option, where);
-  }
-  /**
-   * @internal Draw `frame` with motion blur into `target` (a canvas the size of the stage): the average of `mb.samples` renders at moments
-   * spread over the shutter interval around the frame time. With `settle` the playhead and the stage are left exactly on the frame.
-   */
-  async _exposeFrame(frame, mb, target, settle) {
-    const g = target.getContext("2d");
-    const stage = this.app.canvas;
-    this._atPoster = false;
-    const times = blurTimes(frame, this.frameRate, mb, Math.max(0, this.duration - END_MARGIN));
-    this._nominalTime = this._timeOf(Math.max(0, Math.min(frame, this.totalFrames)));
-    try {
-      for (let k = 0; k < times.length; k++) {
-        const t = times[k];
-        this.timeline.time(t);
-        await this._awaitVideoFrames(t);
-        this._updateSpace(t);
-        this._renderNow();
-        if (k === 0) g.clearRect(0, 0, target.width, target.height);
-        g.globalAlpha = 1 / (k + 1);
-        g.drawImage(stage, 0, 0, target.width, target.height);
-      }
-    } finally {
-      this._nominalTime = null;
-    }
-    g.globalAlpha = 1;
-    if (settle) await this._goto(frame);
-    else {
-      this.currentFrame = Math.max(0, Math.min(frame, this.totalFrames));
-      this.emit("frame", { frame: this.currentFrame, totalFrames: this.totalFrames });
-    }
-  }
-  _blurCanvas() {
-    const stage = this.app.canvas;
-    const c = document.createElement("canvas");
-    c.width = stage.width;
-    c.height = stage.height;
-    return c;
-  }
-  /** Which stop the playhead is on or has passed (-1 before the first). */
-  get stopIndex() {
-    return stopAtOrBefore(this.stops, this.currentFrame)?.index ?? -1;
-  }
-  /** The stop the playhead is on or has passed, or null. */
-  get currentStop() {
-    return stopAtOrBefore(this.stops, this.currentFrame);
-  }
-  /** Which page the playhead is in (0-based), -1 before the first stop. */
-  get pageIndex() {
-    return this.currentStop?.pageIndex ?? -1;
-  }
-  /** How many pages the stops make. */
-  get pageCount() {
-    return pageStarts(this.stops).length;
-  }
-  _cancelStop() {
-    this._stopAt = null;
-    this._settleStopWaiters();
-  }
-  _settleStopWaiters() {
-    const waiters = this._stopWaiters;
-    this._stopWaiters = [];
-    waiters.forEach((w) => w());
-  }
-  _emitStop(stop) {
-    this.emit("stop", { index: stop.index, stop, pageIndex: stop.pageIndex });
-  }
-  /** Land exactly on a stop's frame, pause, and say so. */
-  async _arriveAtStop(frame) {
-    this._arriving = true;
-    this._stopAt = null;
-    try {
-      this.pause();
-      await this._goto(frame);
-    } catch (err) {
-      console.warn("pixi-effects: could not land on a stop:", err);
-      this._emitError("playback", err);
-    } finally {
-      this._arriving = false;
-    }
-    const stop = this.stops.find((s) => s.frame === frame);
-    if (stop) this._emitStop(stop);
-    this._settleStopWaiters();
-  }
-  /**
-   * Play to the next stop and pause exactly there (a presentation's "next"). Pressed again while it is playing toward a stop, it skips the
-   * rest of the animation and lands on that stop at once. After the last stop it plays to the end. Resolves when it has landed (or
-   * stopped for another reason). An ordinary `play()` ignores the stops.
-   */
-  async next() {
-    if (this._initState !== "ready") return;
-    if (this._stopAt !== null) {
-      await this._arriveAtStop(this._stopAt);
-      return;
-    }
-    if (this.currentFrame >= this.totalFrames) return;
-    const target = nextStopAfter(this.stops, this.currentFrame);
-    this._stopAt = target ? target.frame : null;
-    const landed = new Promise((resolve) => this._stopWaiters.push(resolve));
-    this.play();
-    await landed;
-  }
-  /** Jump back to the previous stop at once (no reverse playback); from the first stop, to the start. */
-  async prev() {
-    if (this._initState !== "ready") return;
-    this.pause();
-    const target = previousStopBefore(this.stops, this.currentFrame);
-    await this.gotoFrame(target ? target.frame : 0, true);
-    if (target) this._emitStop(target);
-  }
-  /** Jump to stop `index` (0-based). */
-  async goToStop(index) {
-    if (this._initState !== "ready") return;
-    const stop = this.stops[index];
-    if (!stop) {
-      console.warn(`pixi-effects: movie.goToStop(${index}): there are ${this.stops.length} stops (0 to ${this.stops.length - 1})`);
-      return;
-    }
-    this.pause();
-    await this.gotoFrame(stop.frame, true);
-    this._emitStop(stop);
-  }
-  /** Jump to the first stop of page `page` (0-based). */
-  async goToPage(page) {
-    const starts = pageStarts(this.stops);
-    const stop = starts[page];
-    if (!stop) {
-      console.warn(`pixi-effects: movie.goToPage(${page}): there are ${starts.length} pages (0 to ${starts.length - 1})`);
-      return;
-    }
-    await this.goToStop(stop.index);
-  }
-  play() {
-    if (this._initState !== "ready") return;
-    if (this.currentFrame >= this.totalFrames) this.currentFrame = 0;
-    const wasPlaying = this.isPlaying;
-    this.isPlaying = true;
-    const startTime = performance.now() - this.currentFrame / this.frameRate * 1e3;
-    let inFlight = false;
-    const tick = (time) => {
-      if (!this.isPlaying) return;
-      if (inFlight) {
-        this._raf = requestAnimationFrame(tick);
-        return;
-      }
-      const elapsed = (time - startTime) / 1e3;
-      const frame = Math.floor(elapsed * this.frameRate);
-      if (this._stopAt !== null && frame >= this._stopAt) {
-        void this._arriveAtStop(this._stopAt);
-        return;
-      }
-      if (frame <= this.totalFrames) {
-        inFlight = true;
-        this._goto(frame).catch((err) => {
-          console.warn("pixi-effects: gotoFrame failed during playback:", err);
-          this._emitError("playback", err);
-        }).finally(() => {
-          inFlight = false;
-        });
-        this._raf = requestAnimationFrame(tick);
-      } else {
-        this.pause();
-        this._goto(this.totalFrames).catch((err) => {
-          console.warn("pixi-effects: final gotoFrame failed:", err);
-          this._emitError("playback", err);
-        });
-        this.emit("ended");
-        this._settleStopWaiters();
-      }
-    };
-    this._raf = requestAnimationFrame(tick);
-    if (this.audioBuffer) {
-      const ctx = this._ensureAudioContext();
-      const buffer = this.audioBuffer;
-      this._cancelAudioStart?.();
-      this._cancelAudioStart = startWhenRunning(ctx, () => {
-        if (!this.isPlaying) return;
-        this.audioSource = ctx.createBufferSource();
-        this.audioSource.buffer = buffer;
-        this.gainNode = ctx.createGain();
-        this.gainNode.gain.value = this._muted ? 0 : this._volume;
-        this.audioSource.connect(this.gainNode).connect(ctx.destination);
-        this.audioSource.start(0, Math.min(this.currentFrame / this.frameRate, buffer.duration));
-      }, typeof window !== "undefined" ? window : void 0);
-    }
-    if (!wasPlaying) this.emit("play");
-  }
-  pause() {
-    const wasPlaying = this.isPlaying;
-    this.isPlaying = false;
-    this._cancelAudioStart?.();
-    this._cancelAudioStart = null;
-    if (this._raf) {
-      cancelAnimationFrame(this._raf);
-      this._raf = null;
-    }
-    if (this.audioSource) {
-      try {
-        this.audioSource.stop();
-      } catch {
-      }
-      this.audioSource.disconnect();
-      this.audioSource = null;
-    }
-    if (this.gainNode) {
-      this.gainNode.disconnect();
-      this.gainNode = null;
-    }
-    if (wasPlaying) this.emit("pause");
-    if (!this._arriving) this._cancelStop();
-  }
-  set volume(v) {
-    const next = Math.max(0, Math.min(1, v));
-    const changed = next !== this._volume;
-    this._volume = next;
-    if (this.gainNode) this.gainNode.gain.value = this._muted ? 0 : this._volume;
-    if (changed) this.emit("volumechange", { volume: this._volume, muted: this._muted });
-  }
-  get volume() {
-    return this._volume;
-  }
-  set muted(v) {
-    const changed = !!v !== this._muted;
-    this._muted = !!v;
-    if (this.gainNode) this.gainNode.gain.value = this._muted ? 0 : this._volume;
-    if (changed) this.emit("volumechange", { volume: this._volume, muted: this._muted });
-  }
-  get muted() {
-    return this._muted;
-  }
-  toggleMute() {
-    this.muted = !this.muted;
-    return this.muted;
-  }
-  async render(options) {
-    warnUnknownOptions("movie.render()", options, ["format", "video", "audio", "motionBlur", "range", "scale", "draft"]);
-    try {
-      return await this._quietly(() => exportFrames(this, options));
-    } catch (err) {
-      this._emitError("render", err);
-      throw err;
-    }
-  }
-  async destroy() {
-    safeRun(() => this.pause());
-    this._timeFilters = [];
-    safeRun(() => this._rootSequence?.destroy());
-    this._rootSequence = null;
-    safeRun(() => this.timeline?.kill());
-    this.timeline = null;
-    safeRun(() => this.app?.destroy(true, { children: true, texture: true }));
-    this.app = null;
-    this.audioBuffer = null;
-    this._audioSources = [];
-    this._mixStats = null;
-    safeRun(() => this._audioContext?.close().catch(() => {
-    }));
-    this._audioContext = null;
-    this._initState = "destroyed";
-  }
-};
-var END_MARGIN = 1e-4;
-var clampFrame = (f, last) => Math.max(0, Math.min(Math.round(f), last));
-function encodeCanvas(canvas, type, as, quality) {
-  if (as === "dataURL") return Promise.resolve(canvas.toDataURL(type, quality));
-  return new Promise((resolve, reject) => canvas.toBlob((b) => b ? resolve(b) : reject(new Error("pixi-effects: could not encode the image")), type, quality));
-}
-function safeRun(fn) {
-  try {
-    fn();
-  } catch (e) {
-    console.warn("pixi-effects: cleanup step threw, continuing:", e);
-  }
-}
-function collectVideoSequences(seq, out, clocks, clock = null) {
-  if (typeof seq.awaitFrameAt === "function") {
-    out.push(seq);
-    if (clock && clocks) clocks.set(seq, clock);
-  }
-  if (seq.maskSequence) collectVideoSequences(seq.maskSequence, out, clocks, clock);
-  const own = seq.localClock?.() ?? clock;
-  for (const child of seq._children ?? []) {
-    collectVideoSequences(child, out, clocks, own);
-  }
-}
-function countLayers(spec) {
-  let n = 0;
-  for (const s of spec?.sequences ?? []) {
-    const mask = s.mask;
-    n += 1 + countLayers(s);
-    for (const m of Array.isArray(mask) ? mask : [mask]) if (m && typeof m === "object" && "type" in m) n += 1 + countLayers(m);
-  }
-  return n;
-}
-var BY = ["chars", "words", "lines"];
-var ALIGN = ["left", "center", "right"];
-var widthOf = (text, style) => CanvasTextMetrics.measureText(text, style).width;
-function measureText(text, style = {}) {
-  const m = CanvasTextMetrics.measureText(text, new TextStyle(style));
-  return { width: m.width, height: m.height, lines: text.split("\n").length };
-}
-function splitText(text, style = {}, opts = {}) {
-  warnUnknownOptions("splitText()", opts, ["by", "x", "y", "align"]);
-  let by = opts.by ?? "chars";
-  if (!BY.includes(by)) {
-    const g = suggestName(String(by), BY);
-    console.warn(`pixi-effects: splitText(): by "${by}" is not one of ${BY.map((b) => `"${b}"`).join(", ")}${g ? ` \u2014 did you mean "${g}"?` : ""}; using "chars"`);
-    by = "chars";
-  }
-  let align = opts.align ?? "left";
-  if (!ALIGN.includes(align)) {
-    const g = suggestName(String(align), ALIGN);
-    console.warn(`pixi-effects: splitText(): align "${align}" is not one of ${ALIGN.join(", ")}${g ? ` \u2014 did you mean "${g}"?` : ""}; using "left"`);
-    align = "left";
-  }
-  const x0 = opts.x ?? 0, y0 = opts.y ?? 0;
-  for (const [n, v] of [["x", x0], ["y", y0]]) {
-    if (typeof v !== "number" || !Number.isFinite(v)) throw new Error(`splitText(): ${n} must be a number of pixels (e.g. ${n}: 640), got ${JSON.stringify(v)}: the pieces are placed by measuring, so an expression such as 'GW/2' cannot be used here. \`y\` is the top of the line.`);
-  }
-  if (text === "") return [];
-  const ts = new TextStyle(style);
-  const lineHeight = CanvasTextMetrics.measureText("M", ts).lineHeight ?? CanvasTextMetrics.measureText("M", ts).height;
-  const sentinel = widthOf("|", ts);
-  const out = [];
-  text.split("\n").forEach((line, lineNo) => {
-    const lineWidth = widthOf(line, ts);
-    const left = align === "center" ? x0 - lineWidth / 2 : align === "right" ? x0 - lineWidth : x0;
-    const y = y0 + lineNo * lineHeight;
-    const advance = (upTo) => upTo === 0 ? 0 : widthOf(line.slice(0, upTo) + "|", ts) - sentinel;
-    const spans = [];
-    if (by === "lines") {
-      if (line.trim() !== "") spans.push([0, line.length]);
-    } else if (by === "words") {
-      for (const m of line.matchAll(/\S+/g)) spans.push([m.index, m.index + m[0].length]);
-    } else {
-      for (let i = 0; i < line.length; i++) if (!/\s/.test(line[i])) spans.push([i, i + 1]);
-    }
-    for (const [a, b] of spans) {
-      const piece = line.slice(a, b);
-      out.push({ text: piece, x: left + advance(a), y, width: widthOf(piece, ts), index: out.length, line: lineNo });
-    }
-  });
-  return out;
-}
-
-// src/presets/_ease.ts
-function parseEase2(name) {
-  checkEase(name, "a preset");
-  return parseEase(name);
-}
-
-// src/presets/kenBurns.ts
-var KEN_BURNS_KEYS = ["asset", "name", "at", "duration", "fit", "ease", "motion", "origin", "zoom", "direction", "angle", "from", "to"];
-function kenBurns(opts) {
-  warnUnknownOptions("kenBurns()", opts, KEN_BURNS_KEYS);
-  const {
-    asset,
-    name,
-    at,
-    duration,
-    fit = "cover",
-    ease = "sine.inOut"
-  } = opts;
-  const baseScale = fit;
-  let initial;
-  let keyframes;
-  if (opts.motion === "still") {
-    initial = {
-      x: "W/2",
-      y: "H/2",
-      anchorX: 0.5,
-      anchorY: 0.5,
-      scale: baseScale
-    };
-    keyframes = [];
-  } else if (opts.motion === "scale") {
-    const origin = opts.origin ?? [0.5, 0.5];
-    const zoom = opts.zoom ?? 1.15;
-    const direction = opts.direction ?? "in";
-    const fromZ = direction === "in" ? 1 : zoom;
-    const toZ = direction === "in" ? zoom : 1;
-    const pivotXExpr = `w * ${origin[0]}`;
-    const pivotYExpr = `h * ${origin[1]}`;
-    const initialScale = `${baseScale} * ${fromZ}`;
-    const xExpr = `W * ${origin[0]}`;
-    const yExpr = `H * ${origin[1]}`;
-    initial = {
-      x: xExpr,
-      y: yExpr,
-      pivotX: pivotXExpr,
-      pivotY: pivotYExpr,
-      scale: initialScale
-    };
-    keyframes = [
-      { at: 0, to: { scale: `${baseScale} * ${toZ}` }, duration, ease }
-    ];
-  } else if (opts.motion === "rotation") {
-    const angle = clamp(opts.angle ?? 8, 0, 30);
-    const direction = opts.direction ?? "cw";
-    const startAngle = direction === "cw" ? 0 : direction === "ccw" ? 0 : -angle / 2;
-    const endAngle = direction === "cw" ? +angle : direction === "ccw" ? -angle : +angle / 2;
-    const sampleStep = 1;
-    const span = Math.abs(endAngle - startAngle);
-    const sampleCount = Math.max(2, Math.ceil(span / sampleStep) + 1);
-    const scaleAt = (deg) => {
-      const \u03B8 = Math.abs(deg) * Math.PI / 180;
-      const c = Math.cos(\u03B8);
-      const s = Math.sin(\u03B8);
-      return `max(${baseScale}, max((W*${c} + H*${s}) / w, (W*${s} + H*${c}) / h))`;
-    };
-    initial = {
-      x: "W/2",
-      y: "H/2",
-      pivotX: "w * 0.5",
-      pivotY: "h * 0.5",
-      scale: scaleAt(startAngle),
-      rotation: startAngle
-    };
-    keyframes = [];
-    for (let i = 1; i < sampleCount; i++) {
-      const tFrac = i / (sampleCount - 1);
-      const angleHere = startAngle + (endAngle - startAngle) * tFrac;
-      const tHere = duration * tFrac;
-      const tPrev = duration * ((i - 1) / (sampleCount - 1));
-      keyframes.push({
-        at: tPrev,
-        to: { rotation: angleHere, scale: scaleAt(angleHere) },
-        duration: tHere - tPrev,
-        ease: i === 1 ? ease : "none"
-      });
-    }
-  } else {
-    const from = opts.from ?? [0.25, 0.25];
-    const to = opts.to ?? [0.75, 0.75];
-    const zoom = opts.zoom ?? 1.15;
-    const scaleExpr = `(${baseScale}) * ${zoom}`;
-    const xExpr = (panX) => `W/2 + (${0.5 - panX}) * (w * (${baseScale}) * ${zoom} - W)`;
-    const yExpr = (panY) => `H/2 + (${0.5 - panY}) * (h * (${baseScale}) * ${zoom} - H)`;
-    initial = {
-      x: xExpr(from[0]),
-      y: yExpr(from[1]),
-      pivotX: "w * 0.5",
-      pivotY: "h * 0.5",
-      scale: scaleExpr
-    };
-    keyframes = [
-      { at: 0, to: { x: xExpr(to[0]), y: yExpr(to[1]) }, duration, ease }
-    ];
-  }
-  const spec = {
-    type: "image",
-    asset,
-    duration,
-    initial,
-    keyframes
-  };
-  if (name !== void 0) spec.name = name;
-  if (at !== void 0) spec.at = at;
-  return spec;
-}
-function clamp(v, lo, hi) {
-  return Math.max(lo, Math.min(hi, v));
-}
-
-// src/presets/orbit.ts
-var ORBIT_KEYS = ["duration", "degrees", "start", "radius", "center", "width", "height", "fov", "ease", "dollyZoom", "at", "name", "stepsPerSecond"];
-function orbit(opts) {
-  warnUnknownOptions("orbit()", opts, ORBIT_KEYS);
-  const {
-    duration,
-    degrees,
-    width = 1280,
-    height = 720,
-    fov,
-    ease = "sine.inOut",
-    stepsPerSecond = 10
-  } = opts;
-  if (!(duration > 0)) throw new Error(`pixi-effects: orbit duration must be > 0 (got ${duration})`);
-  const dolly = opts.dollyZoom;
-  if (dolly && opts.radius !== void 0) {
-    throw new Error("pixi-effects: orbit() cannot combine `radius` with `dollyZoom` \u2014 the radius follows the animated fov");
-  }
-  const [cx, cy] = opts.center ?? [width / 2, height / 2];
-  const fixedR = opts.radius ?? homeDistance(height, fov ?? DEFAULT_FOV);
-  const start = opts.start ?? -degrees / 2;
-  const steps = Math.max(1, Math.round(duration * stepsPerSecond));
-  const easeFn = parseEase2(ease);
-  const dollyEase = dolly ? parseEase2(dolly.ease ?? ease) : null;
-  const pos = (i) => {
-    const p = i / steps;
-    const a = (start + degrees * easeFn(p)) * DEG;
-    if (!dolly) return { x: cx + fixedR * Math.sin(a), z: fixedR * Math.cos(a) };
-    const f = dolly.from + (dolly.to - dolly.from) * dollyEase(p);
-    const R = homeDistance(height, f);
-    return { x: cx + R * Math.sin(a), z: R * Math.cos(a), fov: f };
-  };
-  const keyframes = [];
-  for (let i = 0; i < steps; i++) {
-    keyframes.push({ at: duration * i / steps, to: pos(i + 1), duration: duration / steps, ease: "none" });
-  }
-  const p0 = pos(0);
-  const spec = {
-    type: "camera",
-    duration,
-    initial: {
-      x: p0.x,
-      y: cy,
-      z: p0.z,
-      lookAtX: cx,
-      lookAtY: cy,
-      lookAtZ: 0,
-      ...p0.fov !== void 0 ? { fov: p0.fov } : fov !== void 0 ? { fov } : {}
-    },
-    keyframes
-  };
-  if (opts.at !== void 0) spec.at = opts.at;
-  if (opts.name !== void 0) spec.name = opts.name;
-  return spec;
-}
-
-// src/presets/particles.ts
-var KEYS2 = ["count", "at", "emit", "life", "area", "angle", "speed", "gravity", "wind", "drag", "sway", "size", "scale", "fade", "colors", "shape", "spin", "seed", "name", "blendMode", "template", "sampleRate"];
-var SHAPES = ["circle", "rect", "star"];
-var MAX_KEYFRAMES = 3e4;
-function particles(opts) {
-  warnUnknownOptions("particles()", opts, KEYS2);
-  const { count, at = 0, emit = 0, gravity = 0, wind = 0, drag = 0, sway, fade, colors = ["#ffffff"], shape = "circle", seed = 0, name = "particle", template, sampleRate = 20 } = opts;
-  if (!(Number.isInteger(count) && count > 0)) throw new Error(`particles(): count must be a whole number of particles (at least 1), got ${count}`);
-  const life = range("life", opts.life, 1e-6);
-  if (!opts.area || !Number.isFinite(opts.area.x) || !Number.isFinite(opts.area.y)) throw new Error("particles(): area is required: { x, y } (the centre) and optionally width / height to spread over");
-  if (!(Number.isFinite(emit) && emit >= 0)) throw new Error(`particles(): emit must be a number of seconds >= 0, got ${emit}`);
-  if (!(Number.isFinite(sampleRate) && sampleRate > 0)) throw new Error(`particles(): sampleRate must be a positive number (samples per second), got ${sampleRate}`);
-  if (!SHAPES.includes(shape)) {
-    const g = suggestName(String(shape), SHAPES);
-    throw new Error(`particles(): shape "${shape}" is not one of ${SHAPES.map((s) => `"${s}"`).join(", ")}${g ? `; did you mean "${g}"?` : ""}`);
-  }
-  const angle = range("angle", opts.angle ?? [0, 360], -Infinity);
-  const speed = range("speed", opts.speed ?? [100, 300], 0);
-  const size = range("size", opts.size ?? [3, 6], 0);
-  const spin = opts.spin === void 0 ? null : range("spin", opts.spin, -Infinity);
-  const curved = gravity !== 0 || wind !== 0 || drag !== 0 || !!sway;
-  const worst = curved ? Math.max(1, Math.ceil(life[1] * sampleRate)) : 1;
-  if (count * worst > MAX_KEYFRAMES) {
-    throw new Error(`particles(): too many keyframes (${count} particles \xD7 up to ${worst} samples each): lower count or life, or lower sampleRate (now ${sampleRate})`);
-  }
-  const round3 = (v) => Math.round(v * 1e6) / 1e6;
-  const out = [];
-  for (let i = 0; i < count; i++) {
-    const r = random(seed * 1000003 + i * 7919 + 17);
-    const pick = ([a2, b]) => a2 + r() * (b - a2);
-    const born = at + r() * emit;
-    const lifetime = pick(life);
-    const ax = (r() - 0.5) * (opts.area.width ?? 0), ay = (r() - 0.5) * (opts.area.height ?? 0);
-    const x0 = opts.area.x + ax, y0 = opts.area.y + ay;
-    const a = pick(angle) * Math.PI / 180, v = pick(speed);
-    const vx = v * Math.cos(a), vy = v * Math.sin(a);
-    const s = pick(size);
-    const color = colors[Math.min(colors.length - 1, Math.floor(r() * colors.length))];
-    const turn = spin ? pick(spin) : 0;
-    const startAngle = spin ? r() * 360 : 0;
-    const swayAmp = sway?.amp ?? 0, swayFreq = sway?.freq ?? 1;
-    const n0 = sway ? noise(0, seed * 1000003 + i) : 0;
-    const at_ = (t) => {
-      const axis = (p0, v0, acc) => {
-        if (drag > 0) {
-          const vInf = acc / drag;
-          return p0 + vInf * t + (v0 - vInf) * (1 - Math.exp(-drag * t)) / drag;
-        }
-        return p0 + v0 * t + 0.5 * acc * t * t;
-      };
-      const sw = sway ? swayAmp * (noise(t * swayFreq, seed * 1000003 + i) - n0) : 0;
-      return { x: axis(x0, vx, wind) + sw, y: axis(y0, vy, gravity) };
-    };
-    const kfs = [];
-    const steps = curved ? Math.max(1, Math.ceil(lifetime * sampleRate)) : 1;
-    const step = lifetime / steps;
-    for (let k = 1; k <= steps; k++) {
-      const p = at_(k * step);
-      kfs.push({ at: round3((k - 1) * step), to: { x: round3(p.x), y: round3(p.y) }, duration: round3(step), ease: "none" });
-    }
-    if (opts.scale) kfs.push({ at: 0, to: { scale: opts.scale[1] }, duration: round3(lifetime), ease: "none" });
-    if (turn !== 0) kfs.push({ at: 0, to: { rotation: round3(startAngle + turn * lifetime) }, duration: round3(lifetime), ease: "none" });
-    if (fade?.in) kfs.push({ at: 0, to: { alpha: 1 }, duration: fade.in, ease: "none" });
-    if (fade?.out) kfs.push({ at: -fade.out, from: { alpha: 1 }, to: { alpha: 0 }, duration: fade.out, ease: "none" });
-    const initial = { x: round3(x0), y: round3(y0) };
-    if (opts.scale) initial.scale = opts.scale[0];
-    if (fade?.in) initial.alpha = 0;
-    if (spin) initial.rotation = round3(startAngle);
-    const common = { name: `${name}-${i}`, at: round3(born), duration: round3(lifetime), ...opts.blendMode ? { blendMode: opts.blendMode } : {} };
-    if (template) {
-      const t = template;
-      out.push({ ...t, ...common, initial: { ...t.initial, ...initial }, keyframes: [...t.keyframes ?? [], ...kfs] });
-      continue;
-    }
-    const style = { ...initial, fillColor: color };
-    if (shape === "circle") out.push({ type: "shape", shape: "circle", radius: round3(s), ...common, initial: style, keyframes: kfs });
-    else if (shape === "rect") out.push({ type: "shape", shape: "rect", width: round3(s * 2), height: round3(s * 2), ...common, initial: style, keyframes: kfs });
-    else {
-      const points = [];
-      for (let p = 0; p < 10; p++) {
-        const rad = p % 2 === 0 ? s : s * 0.45, ang = -Math.PI / 2 + p * Math.PI / 5;
-        points.push([round3(rad * Math.cos(ang)), round3(rad * Math.sin(ang))]);
-      }
-      out.push({ type: "shape", shape: "polygon", points, ...common, initial: style, keyframes: kfs });
-    }
-  }
-  return out;
-}
-function range(name, v, min) {
-  const [a, b] = typeof v === "number" ? [v, v] : v;
-  if (!(Number.isFinite(a) && Number.isFinite(b)) || a > b || a < min || min > 0 && a <= 0) {
-    throw new Error(`particles(): ${name} must be a number or [min, max] with min <= max${min > -Infinity ? ` and min >= ${min}` : ""}, got ${JSON.stringify(v)}`);
-  }
-  return [a, b];
-}
-
-// src/presets/followPath.ts
-var KEYS3 = ["d", "at", "duration", "ease", "from", "to", "orient", "rotate", "frameRate"];
-var MAX_STEPS = 2e3;
-function followPath(opts) {
-  warnUnknownOptions("followPath()", opts, KEYS3);
-  const { d, at = 0, duration, ease = "none", from = 0, to = 1, orient = false, rotate = 0, frameRate = 30 } = opts;
-  if (typeof d !== "string" || d.trim() === "") throw new Error('followPath(): d must be SVG path data, e.g. "M 100 600 C 300 100 900 100 1180 600"');
-  if (!(Number.isFinite(duration) && duration > 0)) throw new Error(`followPath(): duration must be a positive number of seconds, got ${duration}`);
-  if (!(Number.isFinite(frameRate) && frameRate > 0)) throw new Error(`followPath(): frameRate must be a positive number (samples per second), got ${frameRate}`);
-  for (const [n, v] of [["from", from], ["to", to]]) {
-    if (!(Number.isFinite(v) && v >= 0 && v <= 1)) throw new Error(`followPath(): ${n} must be a fraction of the path between 0 and 1, got ${v}`);
-  }
-  const steps = Math.max(1, Math.round(duration * frameRate));
-  if (steps > MAX_STEPS) throw new Error(`followPath(): ${steps} samples is too many (max ${MAX_STEPS}); lower frameRate or duration`);
-  const segments = [];
-  let total = 0;
-  for (const line of flattenSvgPath(d)) {
-    const p = line.closed ? [...line.pts, line.pts[0], line.pts[1]] : line.pts;
-    for (let i = 2; i < p.length; i += 2) {
-      const len = Math.hypot(p[i] - p[i - 2], p[i + 1] - p[i - 1]);
-      if (len === 0) continue;
-      segments.push({ x0: p[i - 2], y0: p[i - 1], x1: p[i], y1: p[i + 1], start: total, len });
-      total += len;
-    }
-  }
-  if (!(total > 0)) throw new Error(`followPath(): the path "${d}" has no length (it needs at least two different points)`);
-  const find = (s) => {
-    let lo = 0, hi = segments.length - 1;
-    while (lo < hi) {
-      const mid = lo + hi >> 1;
-      if (segments[mid].start + segments[mid].len < s) lo = mid + 1;
-      else hi = mid;
-    }
-    return segments[lo];
-  };
-  const at_ = (fraction) => {
-    const s = Math.min(Math.max(fraction, 0), 1) * total;
-    const g = find(s);
-    const t = Math.min(Math.max((s - g.start) / g.len, 0), 1);
-    return { x: g.x0 + (g.x1 - g.x0) * t, y: g.y0 + (g.y1 - g.y0) * t, heading: Math.atan2(g.y1 - g.y0, g.x1 - g.x0) * 180 / Math.PI };
-  };
-  const shape = parseEase2(ease);
-  const round3 = (v) => Math.round(v * 1e6) / 1e6;
-  let turn = 0;
-  const sample = (k) => {
-    const p = from + (to - from) * shape(k / steps);
-    const pt = at_(p);
-    const out2 = { x: round3(pt.x), y: round3(pt.y) };
-    if (orient) {
-      let h = pt.heading + rotate;
-      if (k === 0) turn = h;
-      else {
-        let delta = h - turn;
-        delta -= 360 * Math.round(delta / 360);
-        turn += delta;
-      }
-      out2.rotation = round3(turn);
-    }
-    return out2;
-  };
-  const out = [{ at, set: sample(0) }];
-  const step = duration / steps;
-  for (let k = 1; k <= steps; k++) out.push({ at: round3(at + (k - 1) * step), to: sample(k), duration: round3(step), ease: "none" });
-  return out;
-}
-
-// src/presets/cameraPath.ts
-var KEYS4 = ["points", "at", "duration", "ease", "look", "lookAhead", "smooth", "from", "to", "frameRate"];
-var MAX_STEPS2 = 4e3;
-var PER_SPAN = 48;
-function cameraPath(opts) {
-  warnUnknownOptions("cameraPath()", opts, KEYS4);
-  const { points, at = 0, duration, ease = "none", look = "ahead", lookAhead = 0.08, smooth = true, from = 0, to = 1, frameRate = 30 } = opts;
-  if (!Array.isArray(points) || points.length < 2) throw new Error("cameraPath(): points needs at least two points: [[x, y, z], [x, y, z], \u2026]");
-  points.forEach((p, i) => {
-    if (!Array.isArray(p) || p.length !== 3 || !p.every(Number.isFinite)) throw new Error(`cameraPath(): points[${i}] must be [x, y, z] numbers, got ${JSON.stringify(p)}`);
-  });
-  if (!(Number.isFinite(duration) && duration > 0)) throw new Error(`cameraPath(): duration must be a positive number of seconds, got ${duration}`);
-  if (!(Number.isFinite(frameRate) && frameRate > 0)) throw new Error(`cameraPath(): frameRate must be a positive number (samples per second), got ${frameRate}`);
-  if (look !== "ahead" && !(Array.isArray(look) && look.length === 3 && look.every(Number.isFinite))) throw new Error(`cameraPath(): look must be 'ahead' or [x, y, z] numbers, got ${JSON.stringify(look)}`);
-  if (!(Number.isFinite(lookAhead) && lookAhead >= 0 && lookAhead <= 1)) throw new Error(`cameraPath(): lookAhead must be a fraction of the route between 0 and 1, got ${lookAhead}`);
-  for (const [n, v] of [["from", from], ["to", to]]) {
-    if (!(Number.isFinite(v) && v >= 0 && v <= 1)) throw new Error(`cameraPath(): ${n} must be a fraction of the route between 0 and 1, got ${v}`);
-  }
-  const steps = Math.max(1, Math.round(duration * frameRate));
-  if (steps > MAX_STEPS2) throw new Error(`cameraPath(): ${steps} samples is too many (max ${MAX_STEPS2}); lower frameRate or duration`);
-  const curve = [];
-  if (smooth && points.length > 2) {
-    const pts = points;
-    for (let i = 0; i < pts.length - 1; i++) {
-      const p0 = pts[Math.max(i - 1, 0)], p1 = pts[i], p2 = pts[i + 1], p3 = pts[Math.min(i + 2, pts.length - 1)];
-      for (let s = 0; s < PER_SPAN; s++) curve.push(catmullRom(p0, p1, p2, p3, s / PER_SPAN));
-    }
-    curve.push(pts[pts.length - 1]);
-  } else curve.push(...points);
-  const cum = [0];
-  for (let i = 1; i < curve.length; i++) cum.push(cum[i - 1] + dist(curve[i - 1], curve[i]));
-  const total = cum[cum.length - 1];
-  if (!(total > 0)) throw new Error("cameraPath(): the route has no length (the points are all the same)");
-  const find = (s) => {
-    let lo = 0, hi = cum.length - 1;
-    while (lo < hi - 1) {
-      const mid = lo + hi >> 1;
-      if (cum[mid] <= s) lo = mid;
-      else hi = mid;
-    }
-    return lo;
-  };
-  const along = (fraction) => {
-    const s = fraction * total;
-    if (s >= total) {
-      const a2 = curve[curve.length - 2], b2 = curve[curve.length - 1], len = dist(a2, b2) || 1, extra = s - total;
-      return [b2[0] + (b2[0] - a2[0]) / len * extra, b2[1] + (b2[1] - a2[1]) / len * extra, b2[2] + (b2[2] - a2[2]) / len * extra];
-    }
-    const i = find(Math.max(s, 0)), span = cum[i + 1] - cum[i], t = span > 0 ? (s - cum[i]) / span : 0;
-    const a = curve[i], b = curve[i + 1];
-    return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
-  };
-  const shape = parseEase2(ease);
-  const round3 = (v) => Math.round(v * 1e6) / 1e6;
-  const sample = (k) => {
-    const p = from + (to - from) * shape(k / steps);
-    const pos = along(Math.min(Math.max(p, 0), 1));
-    const target = look === "ahead" ? along(Math.max(p + (to >= from ? lookAhead : -lookAhead), 0)) : look;
-    return { x: round3(pos[0]), y: round3(pos[1]), z: round3(pos[2]), lookAtX: round3(target[0]), lookAtY: round3(target[1]), lookAtZ: round3(target[2]) };
-  };
-  const out = [{ at, set: sample(0) }];
-  const step = duration / steps;
-  for (let k = 1; k <= steps; k++) out.push({ at: round3(at + (k - 1) * step), to: sample(k), duration: round3(step), ease: "none" });
-  return out;
-}
-var dist = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
-function catmullRom(p0, p1, p2, p3, t) {
-  const t2 = t * t, t3 = t2 * t;
-  const c = (a, b, d, e) => 0.5 * (2 * b + (d - a) * t + (2 * a - 5 * b + 4 * d - e) * t2 + (3 * b - a - 3 * d + e) * t3);
-  return [c(p0[0], p1[0], p2[0], p3[0]), c(p0[1], p1[1], p2[1], p3[1]), c(p0[2], p1[2], p2[2], p3[2])];
-}
-
-// src/presets/stagger.ts
-var STAGGER_KEYS = ["each", "amount", "from", "grid", "ease", "seed"];
-var FROM_NAMES = ["start", "end", "center", "edges", "random"];
-function stagger(items, options = {}) {
-  const isCount = typeof items === "number";
-  const n = isCount ? items : items.length;
-  if (!Number.isInteger(n) || n < 0) throw new Error(`stagger(): count must be a whole number of items, got ${n}`);
-  warnUnknownOptions("stagger()", options, STAGGER_KEYS);
-  const { each, amount, from = "start", grid, ease = "none", seed = 0 } = options;
-  if (each !== void 0 && amount !== void 0) throw new Error("stagger(): give `each` (seconds between neighbours) or `amount` (seconds in total), not both");
-  if (each !== void 0 && !(Number.isFinite(each) && each >= 0)) throw new Error(`stagger(): each must be a number of seconds >= 0, got ${each}`);
-  if (amount !== void 0 && !(Number.isFinite(amount) && amount >= 0)) throw new Error(`stagger(): amount must be a number of seconds >= 0, got ${amount}`);
-  if (typeof from === "string" && !FROM_NAMES.includes(from)) {
-    throw new Error(`stagger(): from "${from}" is not one of ${FROM_NAMES.map((f) => `"${f}"`).join(", ")} or an item index`);
-  }
-  if (typeof from === "number" && !(Number.isInteger(from) && from >= 0 && from < Math.max(n, 1))) throw new Error(`stagger(): from ${from} is not an index of the ${n} items`);
-  if (grid && !(Array.isArray(grid) && grid.length === 2 && grid.every((g) => Number.isInteger(g) && g > 0) && grid[0] * grid[1] >= n)) {
-    throw new Error(`stagger(): grid must be [columns, rows] and hold all ${n} items, got ${JSON.stringify(grid)}`);
-  }
-  const dist2 = distances(n, from, grid, seed);
-  const max = dist2.reduce((m, d) => Math.max(m, d), 0);
-  const total = amount !== void 0 ? amount : (each ?? 0.1) * max;
-  const shape = parseEase2(ease);
-  const clamp01 = (v) => Math.min(1, Math.max(0, v));
-  const delays = dist2.map((d) => max === 0 ? 0 : Math.round(total * clamp01(shape(d / max)) * 1e6) / 1e6);
-  if (isCount) return delays;
-  return items.map((layer, i) => ({ ...layer, at: Math.round(((layer.at ?? 0) + delays[i]) * 1e6) / 1e6 }));
-}
-function distances(n, from, grid, seed) {
-  if (n === 0) return [];
-  if (from === "random") {
-    const order = Array.from({ length: n }, (_, i) => i);
-    const r = random(seed);
-    for (let i = n - 1; i > 0; i--) {
-      const j = Math.floor(r() * (i + 1));
-      [order[i], order[j]] = [order[j], order[i]];
-    }
-    return order;
-  }
-  if (!grid) {
-    const mid = (n - 1) / 2;
-    return Array.from({ length: n }, (_, i) => {
-      switch (from) {
-        case "start":
-          return i;
-        case "end":
-          return n - 1 - i;
-        case "center":
-          return Math.abs(i - mid);
-        case "edges":
-          return mid - Math.abs(i - mid);
-        default:
-          return Math.abs(i - from);
-      }
-    });
-  }
-  const [cols, rows] = grid;
-  const at = (i) => ({ x: i % cols, y: Math.floor(i / cols) });
-  const origin = from === "start" ? { x: 0, y: 0 } : from === "end" ? { x: cols - 1, y: rows - 1 } : from === "center" || from === "edges" ? { x: (cols - 1) / 2, y: (rows - 1) / 2 } : at(from);
-  const d = Array.from({ length: n }, (_, i) => Math.hypot(at(i).x - origin.x, at(i).y - origin.y));
-  if (from !== "edges") return d;
-  const far = Math.max(...d);
-  return d.map((v) => far - v);
-}
-
-// src/presets/wiggle.ts
-var WIGGLE_KEYS = ["at", "duration", "freq", "seed", "ease", "props"];
-var MAX_STEPS3 = 2e3;
-function wiggle(opts) {
-  warnUnknownOptions("wiggle()", opts, WIGGLE_KEYS);
-  const { at = 0, duration, freq = 3, seed = 0, ease = "sine.inOut", props } = opts;
-  if (!(Number.isFinite(duration) && duration > 0)) throw new Error(`wiggle(): duration must be a positive number of seconds, got ${duration}`);
-  if (!(Number.isFinite(freq) && freq > 0)) throw new Error(`wiggle(): freq must be a positive number (steps per second), got ${freq}`);
-  const names = Object.keys(props ?? {});
-  if (names.length === 0) throw new Error("wiggle(): props is empty; name at least one property, e.g. props: { x: { around: 100, amp: 8 } }");
-  for (const n of names) {
-    const p = props[n];
-    if (!Number.isFinite(p.amp)) throw new Error(`wiggle(): props.${n}.amp must be a number, got ${p.amp}`);
-    if (p.around === void 0 || p.around === null || p.around === "") throw new Error(`wiggle(): props.${n}.around is missing`);
-  }
-  const steps = Math.ceil(duration * freq - 1e-9);
-  if (steps > MAX_STEPS3) throw new Error(`wiggle(): ${steps} steps is too many (max ${MAX_STEPS3}); lower freq or duration`);
-  const set = {};
-  for (const n of names) set[n] = props[n].around;
-  const out = [{ at, set }];
-  const stepLen = duration / steps;
-  for (let s = 0; s < steps; s++) {
-    const to = {};
-    names.forEach((n, pi) => {
-      const p = props[n];
-      if (s === steps - 1) {
-        to[n] = p.around;
-        return;
-      }
-      const off = (rand(seed * 7919 + pi * 104729 + s * 31 + 1) * 2 - 1) * p.amp;
-      to[n] = typeof p.around === "number" ? p.around + off : `(${p.around}) ${off < 0 ? "-" : "+"} ${Math.abs(off)}`;
-    });
-    out.push({ at: at + s * stepLen, to, duration: stepLen, ease });
-  }
-  return out;
-}
-
-// src/presets/animateText.ts
-var TWEEN_KEYS = ["preset", "from", "to", "duration", "ease"];
-var TIME_KEYS = ["at", "delay", "start", "begin", "time"];
-var KEYS5 = ["by", "x", "y", "align", "name", "at", "duration", "in", "out", "stagger", "idle", "styleFor"];
-var PRESETS = {
-  rise: { from: { y: 40, alpha: 0 }, duration: 0.5, ease: "back.out(2)" },
-  drop: { from: { y: -50, alpha: 0 }, duration: 0.7, ease: "bounce.out" },
-  fade: { from: { alpha: 0 }, duration: 0.5, ease: "power1.out" },
-  pop: { from: { scale: 0, alpha: 0 }, duration: 0.45, ease: "back.out(2.4)" },
-  zoom: { from: { scale: 2.5, alpha: 0 }, duration: 0.6, ease: "power3.out" },
-  slide: { from: { x: -60, alpha: 0 }, duration: 0.5, ease: "power3.out" },
-  spin: { from: { rotation: -90, scale: 0, alpha: 0 }, duration: 0.6, ease: "back.out(1.7)" }
-};
-var PRESET_NAMES = Object.keys(PRESETS);
-function animateText(text, style, options) {
-  warnUnknownOptions("animateText()", options, KEYS5);
-  const { by = "chars", x = 0, y = 0, align = "left", name = "text", at = 0, duration, idle, styleFor } = options;
-  for (const [n, v] of [["x", x], ["y", y]]) {
-    if (typeof v !== "number" || !Number.isFinite(v)) {
-      throw new Error(`animateText(): ${n} must be a number of pixels (e.g. ${n}: 640), got ${JSON.stringify(v)}. The letters are measured once, when the layers are made, so an expression such as 'GW/2' cannot be used here: compute the number (W / 2) yourself. \`y\` is the TOP of the line.`);
-    }
-  }
-  if (!(Number.isFinite(duration) && duration > 0)) throw new Error(`animateText(): duration must be a positive number of seconds (how long until the last piece is gone), got ${duration}`);
-  const pieces = splitText(text, style, { by, x, y, align });
-  if (pieces.length === 0) return [];
-  const lineHeight = measureText("M", style).height;
-  const inTween = options.in === false ? null : resolveTween(options.in ?? "rise", "in");
-  const outTween = options.out === void 0 || options.out === false ? null : resolveTween(options.out, "out");
-  const delays = stagger(pieces.length, options.stagger ?? { each: 0.04 });
-  const wave = Math.max(...delays);
-  const need = (inTween?.duration ?? 0) + (outTween?.duration ?? 0) + wave;
-  if (duration < need - 1e-9) {
-    throw new Error(`animateText(): duration ${duration} is too short for this wave: the entrance${outTween ? ", the exit" : ""} and the stagger need at least ${+need.toFixed(3)} s`);
-  }
-  const end = at + duration;
-  return pieces.map((p, i) => {
-    const cx = p.x + p.width / 2, cy = p.y + lineHeight / 2;
-    const rest = { x: cx, y: cy, alpha: 1, scale: 1, scaleX: 1, scaleY: 1, rotation: 0 };
-    const start = at + delays[i];
-    const len = end - start;
-    const keyframes = [];
-    const place = (key, v) => key === "x" || key === "y" ? rest[key] + v : v;
-    if (inTween) {
-      keyframes.push({
-        at: 0,
-        duration: inTween.duration,
-        ease: inTween.ease,
-        from: Object.fromEntries(Object.entries(inTween.from).map(([k, v]) => [k, place(k, v)])),
-        to: Object.fromEntries(Object.keys(inTween.from).map((k) => [k, inTween.to[k] ?? rest[k]]))
-      });
-    }
-    let idleEnd = len;
-    if (outTween) {
-      const begin = outTween.duration + (wave - delays[i]);
-      idleEnd = len - begin;
-      keyframes.push({
-        at: -begin,
-        duration: outTween.duration,
-        ease: outTween.ease,
-        from: Object.fromEntries(Object.keys(outTween.from).map((k) => [k, outTween.to[k] ?? rest[k]])),
-        to: Object.fromEntries(Object.entries(outTween.from).map(([k, v]) => [k, place(k, v)]))
-      });
-    }
-    if (idle) {
-      const props = {};
-      for (const k of ["x", "y", "rotation", "scale"]) if (idle[k] !== void 0) props[k] = { around: rest[k], amp: idle[k] };
-      const freq = idle.freq ?? 1;
-      const from = inTween?.duration ?? 0;
-      if (Object.keys(props).length > 0 && idleEnd - from >= 1 / freq) {
-        keyframes.push(...wiggle({ at: from, duration: idleEnd - from, freq, seed: (idle.seed ?? 0) * 1e3 + i, props }));
-      }
-    }
-    return {
-      type: "text",
-      name: `${name}-${i}`,
-      text: p.text,
-      style: styleFor ? { ...style, ...styleFor(p) } : style,
-      at: start,
-      duration: len,
-      initial: { x: cx, y: cy, anchorX: 0.5, anchorY: 0.5 },
-      keyframes
-    };
-  });
-}
-function resolveTween(spec, which) {
-  const t = typeof spec === "string" ? { preset: spec } : spec;
-  if (typeof spec === "object" && spec) {
-    for (const key of Object.keys(spec)) {
-      if (TWEEN_KEYS.includes(key)) continue;
-      if (TIME_KEYS.includes(key)) {
-        console.warn(`pixi-effects: animateText(): ${which}.${key} ("${key}") is ignored: ${which === "out" ? "an out leaves from the END of the layer (at + duration), so to make the text gone at a time T set duration to T \u2212 at" : "the entrance starts when the piece starts (the options' at, plus the stagger)"}`);
-      } else warnUnknownOptions(`animateText() ${which}`, { [key]: 1 }, TWEEN_KEYS);
-    }
-  }
-  if (t.preset !== void 0 && !(t.preset in PRESETS)) {
-    const guess = suggestName(String(t.preset), PRESET_NAMES);
-    throw new Error(`animateText(): ${which} "${t.preset}" is not a preset${guess ? `; did you mean "${guess}"?` : ""} (presets: ${PRESET_NAMES.map((n) => `"${n}"`).join(", ")})`);
-  }
-  const base = t.preset ? PRESETS[t.preset] : void 0;
-  const from = { ...base?.from ?? {}, ...t.from ?? {} };
-  const to = t.to ?? {};
-  const known = /* @__PURE__ */ new Set(["x", "y", "alpha", "scale", "scaleX", "scaleY", "rotation"]);
-  for (const k of Object.keys(from)) {
-    if (!known.has(k) && to[k] === void 0) throw new Error(`animateText(): ${which}.from has "${k}", which has no resting value; give ${which}.to: { ${k}: \u2026 }`);
-  }
-  if (Object.keys(from).length === 0) throw new Error(`animateText(): ${which} needs a preset or a from`);
-  let ease = t.ease ?? base?.ease ?? "power2.out";
-  if (which === "out" && t.ease === void 0) ease = ease.replace(".out", ".in");
-  return { from, to: { ...to }, duration: t.duration ?? base?.duration ?? 0.5, ease };
-}
-
-// src/presets/react.ts
-var KEYS6 = ["at", "duration", "props", "audioOffset", "loop", "frameRate"];
-var PROP_KEYS = ["base", "amount", "band", "beats", "decay", "attack", "release", "invert", "curve"];
-var MAX_STEPS4 = 4e3;
-function react(env, options) {
-  warnUnknownOptions("react()", options, KEYS6);
-  const { at = 0, duration, props, audioOffset = 0, loop = false } = options;
-  const frameRate = options.frameRate ?? env.frameRate;
-  if (!(Number.isFinite(duration) && duration > 0)) throw new Error(`react(): duration must be a positive number of seconds, got ${duration}`);
-  if (!(Number.isFinite(frameRate) && frameRate > 0)) throw new Error(`react(): frameRate must be a positive number, got ${frameRate}`);
-  const names = Object.keys(props ?? {});
-  if (names.length === 0) throw new Error("react(): props is empty; name at least one property, e.g. props: { scale: { base: 1, amount: 0.3 } }");
-  for (const n of names) {
-    const p = props[n];
-    warnUnknownOptions(`react() props.${n}`, p, PROP_KEYS);
-    if (!Number.isFinite(p.amount)) throw new Error(`react(): props.${n}.amount must be a number, got ${p.amount}`);
-    if (!p.beats && p.band !== void 0 && !env.series[p.band]) throw new Error(`react(): props.${n}: band "${p.band}" is not in this envelope (it has: ${Object.keys(env.series).join(", ")})`);
-    if (p.beats && !(p.decay === void 0 || Number.isFinite(p.decay) && p.decay > 0)) throw new Error(`react(): props.${n}.decay must be a positive number of seconds, got ${p.decay}`);
-  }
-  const steps = Math.max(1, Math.round(duration * frameRate));
-  if (steps > MAX_STEPS4) throw new Error(`react(): too many keyframes (${steps} steps, max ${MAX_STEPS4}); lower frameRate (now ${frameRate}) or duration`);
-  const wrap = (a) => loop && env.duration > 0 ? (a % env.duration + env.duration) % env.duration : a;
-  const beatPulse = (a, decay) => {
-    const beats = env.beats;
-    let lo = 0, hi = beats.length - 1, found = -1;
-    while (lo <= hi) {
-      const mid = lo + hi >> 1;
-      if (beats[mid] <= a + 1e-9) {
-        found = mid;
-        lo = mid + 1;
-      } else hi = mid - 1;
-    }
-    if (found < 0) return 0;
-    return Math.exp(-(a - beats[found]) / decay);
-  };
-  const round3 = (v) => Math.round(v * 1e4) / 1e4;
-  const state = {};
-  const values = (k) => {
-    const t = k / frameRate, a = wrap(audioOffset + t);
-    const out2 = {};
-    for (const n of names) {
-      const p = props[n];
-      let x = p.beats ? beatPulse(a, p.decay ?? 0.2) : env.at(a, p.band ?? "level");
-      if (p.invert) x = 1 - x;
-      const prev = state[n];
-      if (prev !== void 0 && (p.attack || p.release)) {
-        const tau = x > prev ? p.attack ?? 0 : p.release ?? 0;
-        if (tau > 0) x = prev + (x - prev) * (1 - Math.exp(-(1 / frameRate) / tau));
-      }
-      state[n] = x;
-      const shaped = p.curve && p.curve !== 1 ? Math.pow(Math.max(0, x), p.curve) : x;
-      out2[n] = round3((p.base ?? 0) + p.amount * shaped);
-    }
-    return out2;
-  };
-  const out = [{ at, set: values(0) }];
-  const step = duration / steps;
-  for (let k = 1; k <= steps; k++) out.push({ at: round6(at + (k - 1) * step), to: values(k), duration: round6(step), ease: "none" });
-  return out;
-}
-var round6 = (v) => Math.round(v * 1e6) / 1e6;
-
-// src/audio/envelope.ts
-var DEFAULT_BANDS = { bass: [20, 150], mid: [150, 2e3], treble: [2e3, 1e4] };
-var WINDOW = 2048;
-var RANGE_DB = 36;
-var MIN_BEAT_GAP = 0.2;
-var OPTION_KEYS = ["frameRate", "bands", "beatBand", "beatSensitivity"];
-function makeAt(frameRate, series) {
-  return (time, name = "level") => {
-    const s = series[name];
-    if (!s) throw new Error(`pixi-effects: this envelope has no series "${name}" (it has: ${Object.keys(series).join(", ")})`);
-    const x = Math.min(Math.max(time * frameRate, 0), s.length - 1);
-    const i = Math.floor(x), f = x - i;
-    return i + 1 < s.length ? s[i] + (s[i + 1] - s[i]) * f : s[i];
-  };
-}
-function percentile(values, p) {
-  if (values.length === 0) return 0;
-  const sorted = Float64Array.from(values).sort();
-  return sorted[Math.min(sorted.length - 1, Math.floor(p * (sorted.length - 1)))];
-}
-function pickBeats(strength, frameRate, sensitivity) {
-  const n = strength.length;
-  const flux = new Float64Array(n);
-  for (let i = 1; i < n; i++) flux[i] = Math.max(0, strength[i] - strength[i - 1]);
-  const half = Math.max(2, Math.round(frameRate * 0.5));
-  const gap = Math.max(1, Math.round(MIN_BEAT_GAP * frameRate));
-  const beats = [];
-  let last = -gap;
-  for (let i = 1; i < n; i++) {
-    const v = flux[i];
-    if (v < 0.12 / sensitivity || v < flux[i - 1] || v <= (flux[i + 1] ?? 0)) continue;
-    let mean = 0, sq = 0, count = 0;
-    for (let j = Math.max(0, i - half); j <= Math.min(n - 1, i + half); j++) {
-      mean += flux[j];
-      sq += flux[j] * flux[j];
-      count++;
-    }
-    mean /= count;
-    const std = Math.sqrt(Math.max(0, sq / count - mean * mean));
-    if (v < mean + 1 * std / sensitivity) continue;
-    if (i - last < gap) {
-      if (beats.length && v > flux[last]) {
-        beats[beats.length - 1] = i / frameRate;
-        last = i;
-      }
-      continue;
-    }
-    beats.push(i / frameRate);
-    last = i;
-  }
-  return beats;
-}
-function tempo(beats) {
-  if (beats.length < 4) return null;
-  const gaps = beats.slice(1).map((b, i) => b - beats[i]).sort((a, b) => a - b);
-  const median = gaps[Math.floor(gaps.length / 2)];
-  return Math.round(60 / median * 10) / 10;
-}
-function computeEnvelope(audio, options = {}) {
-  warnUnknownOptions("audioEnvelope()", options, OPTION_KEYS);
-  const frameRate = options.frameRate ?? 30;
-  if (!(Number.isFinite(frameRate) && frameRate > 0)) throw new Error(`pixi-effects: audioEnvelope(): frameRate must be a positive number, got ${frameRate}`);
-  const bands = options.bands ?? DEFAULT_BANDS;
-  for (const [name, range2] of Object.entries(bands)) {
-    if (!(Array.isArray(range2) && range2.length === 2 && range2[0] >= 0 && range2[0] < range2[1])) throw new Error(`pixi-effects: audioEnvelope(): band "${name}" must be [from, to] in Hz with from < to, got ${JSON.stringify(range2)}`);
-  }
-  const sr = audio.sampleRate, length = audio.length;
-  const mono2 = new Float32Array(length);
-  for (let c = 0; c < audio.numberOfChannels; c++) {
-    const d = audio.getChannelData(c);
-    for (let i = 0; i < length; i++) mono2[i] += d[i] / audio.numberOfChannels;
-  }
-  const duration = length / sr;
-  const frames = Math.floor(duration * frameRate + 1e-9) + 1;
-  const hop = sr / frameRate;
-  const names = Object.keys(bands);
-  const raw = { level: new Float64Array(frames) };
-  for (const n of names) raw[n] = new Float64Array(frames);
-  const re = new Float64Array(WINDOW), im = new Float64Array(WINDOW);
-  const win = new Float64Array(WINDOW);
-  let winPower = 0;
-  for (let i = 0; i < WINDOW; i++) {
-    win[i] = 0.5 - 0.5 * Math.cos(2 * Math.PI * i / (WINDOW - 1));
-    winPower += win[i] * win[i];
-  }
-  winPower /= WINDOW;
-  const binHz = sr / WINDOW;
-  for (let f = 0; f < frames; f++) {
-    const center = Math.round(f / frameRate * sr);
-    let sum = 0, cnt = 0;
-    for (let i = Math.max(0, Math.round(center - hop / 2)); i < Math.min(length, Math.round(center + hop / 2)); i++) {
-      sum += mono2[i] * mono2[i];
-      cnt++;
-    }
-    raw.level[f] = cnt ? Math.sqrt(sum / cnt) : 0;
-    for (let i = 0; i < WINDOW; i++) {
-      const k = center - WINDOW / 2 + i;
-      re[i] = k >= 0 && k < length ? mono2[k] * win[i] : 0;
-      im[i] = 0;
-    }
-    fft(re, im);
-    for (const n of names) {
-      const [lo, hi] = bands[n];
-      let p = 0;
-      for (let b = Math.max(1, Math.ceil(lo / binHz)); b <= Math.min(WINDOW / 2 - 1, Math.floor(hi / binHz)); b++) p += re[b] * re[b] + im[b] * im[b];
-      raw[n][f] = Math.sqrt(2 * p / (WINDOW * WINDOW * winPower));
-    }
-  }
-  let ref = 0;
-  for (const s of Object.values(raw)) ref = Math.max(ref, percentile(s, 0.98));
-  const series = {};
-  for (const [name, s] of Object.entries(raw)) {
-    const out = new Float32Array(frames);
-    if (ref > 1e-7) for (let f = 0; f < frames; f++) {
-      const v = s[f];
-      out[f] = v > 0 ? Math.min(1, Math.max(0, 1 + 20 * Math.log10(v / ref) / RANGE_DB)) : 0;
-    }
-    series[name] = out;
-  }
-  const beatName = options.beatBand ?? (series.bass ? "bass" : "level");
-  if (!series[beatName]) throw new Error(`pixi-effects: audioEnvelope(): beatBand "${beatName}" is not one of ${Object.keys(series).join(", ")}`);
-  const beats = ref > 1e-7 ? pickBeats(series[beatName], frameRate, options.beatSensitivity ?? 1) : [];
-  return { frameRate, duration, frames, series, beats, bpm: tempo(beats), at: makeAt(frameRate, series) };
-}
-function bpmEnvelope(bpm, options) {
-  const { duration, frameRate = 30, swing = 0 } = options;
-  if (!(Number.isFinite(bpm) && bpm > 0)) throw new Error(`pixi-effects: bpmEnvelope(): bpm must be a positive number, got ${bpm}`);
-  if (!(Number.isFinite(duration) && duration > 0)) throw new Error(`pixi-effects: bpmEnvelope(): duration must be a positive number of seconds, got ${duration}`);
-  const beat = 60 / bpm;
-  const frames = Math.round(duration * frameRate) + 1;
-  const pulse = (hits, decay, t) => {
-    let v = 0;
-    for (let i = hits.length - 1; i >= 0; i--) {
-      if (hits[i] <= t + 1e-9) {
-        v = Math.exp(-(t - hits[i]) / decay);
-        break;
-      }
-    }
-    return v;
-  };
-  const beats = [], snares = [], hats = [];
-  for (let k = 0; k * beat < duration - 1e-9; k++) {
-    beats.push(round62(k * beat));
-    if (k % 2 === 1) snares.push(round62(k * beat));
-    hats.push(round62(k * beat), round62(k * beat + beat / 2 + swing * beat));
-  }
-  hats.sort((a, b) => a - b);
-  const series = { level: new Float32Array(frames), bass: new Float32Array(frames), mid: new Float32Array(frames), treble: new Float32Array(frames) };
-  for (let f = 0; f < frames; f++) {
-    const t = f / frameRate;
-    const b = pulse(beats, 0.14, t), m = pulse(snares, 0.1, t), h = pulse(hats, 0.045, t);
-    series.bass[f] = b;
-    series.mid[f] = m;
-    series.treble[f] = h;
-    series.level[f] = Math.max(b, m * 0.9, h * 0.55);
-  }
-  return { frameRate, duration, frames, series, beats, bpm, at: makeAt(frameRate, series) };
-}
-var round62 = (v) => Math.round(v * 1e6) / 1e6;
-async function audioEnvelope(source, options = {}) {
-  let audio;
-  if (typeof source.getChannelData === "function") audio = source;
-  else {
-    let data;
-    if (typeof source === "string" || source instanceof URL) {
-      const res = await fetch(String(source));
-      if (!res.ok) throw new Error(`pixi-effects: audioEnvelope(): could not fetch ${String(source)} (${res.status})`);
-      data = await res.arrayBuffer();
-    } else if (source instanceof Blob) data = await source.arrayBuffer();
-    else data = source;
-    const Ctx = globalThis.OfflineAudioContext ?? globalThis.webkitOfflineAudioContext;
-    if (!Ctx) throw new Error("pixi-effects: audioEnvelope() needs a browser with Web Audio (OfflineAudioContext)");
-    try {
-      audio = await new Ctx(1, 1, 44100).decodeAudioData(data.slice(0));
-    } catch (err) {
-      throw new Error(`pixi-effects: audioEnvelope(): could not decode the audio (${err instanceof Error ? err.message : String(err)}); is it an mp3, wav, ogg, m4a or webm file?`);
-    }
-  }
-  return computeEnvelope(audio, options);
-}
-
-// src/audio/musicEnvelope.ts
-async function musicEnvelope(music, options = {}) {
-  const { resolveMusic, renderMusic, musicLength, musicBeatTimes, TempoMap } = await import('./music-JKOM5YK6.js');
-  const messages = [];
-  const m = resolveMusic(music, "musicEnvelope()", (msg) => messages.push(msg));
-  if (!m) throw new Error(`pixi-effects: musicEnvelope(): ${messages.join(" ") || "the music has nothing to play"}`);
-  for (const msg of messages) console.warn(msg);
-  const sampleRate = 22050;
-  const [left, right] = renderMusic(m, sampleRate, musicLength(m), false);
-  const env = computeEnvelope({ sampleRate, numberOfChannels: 2, length: left.length, getChannelData: (c) => c === 0 ? left : right }, options);
-  return { ...env, beats: musicBeatTimes(m, env.duration), bpm: Math.round(new TempoMap(m.tempo).bpmAt(0) * 100) / 100 };
-}
-
-// src/audio/musicBuffer.ts
-async function musicBuffer(music, options = {}) {
-  const { resolveMusic, renderMusic, musicLength } = await import('./music-JKOM5YK6.js');
-  const messages = [];
-  const m = resolveMusic(music, "musicBuffer()", (msg) => messages.push(msg));
-  if (!m) throw new Error(`pixi-effects: musicBuffer(): ${messages.join(" ") || "the music has nothing to play"}`);
-  for (const msg of messages) console.warn(msg);
-  const sampleRate = options.sampleRate ?? 44100;
-  const length = options.duration ?? musicLength(m);
-  if (!(Number.isFinite(length) && length > 0)) throw new Error(`pixi-effects: musicBuffer(): duration must be a positive number of seconds, got ${String(options.duration)}`);
-  const [left, right] = renderMusic(m, sampleRate, length, !!options.loop);
-  const buffer = typeof AudioBuffer === "function" ? new AudioBuffer({ length: left.length, sampleRate, numberOfChannels: 2 }) : new OfflineAudioContext(2, left.length, sampleRate).createBuffer(2, left.length, sampleRate);
-  buffer.copyToChannel(left, 0);
-  buffer.copyToChannel(right, 1);
-  return buffer;
-}
-
-// src/audio/musicEvents.ts
-async function musicEvents(music) {
-  const { resolveMusic } = await import('./music-JKOM5YK6.js');
-  const { describeEvents } = await import('./events-KXBWR4IV.js');
-  const messages = [];
-  const m = resolveMusic(music, "musicEvents()", (msg) => messages.push(msg));
-  if (!m) throw new Error(`pixi-effects: musicEvents(): ${messages.join(" ") || "the music has nothing to play"}`);
-  for (const msg of messages) console.warn(msg);
-  return describeEvents(m);
-}
-
-// src/presets/deck.ts
-var PAGE_KEYS = ["name", "duration", "sequences", "stops", "notes", "advance", "initial", "keyframes", "filters", "filterArea", "blendMode", "mask", "maskInverted"];
-var DECK_KEYS = ["pages", "transition", "width", "height", "frameRate", "background", "canvas", "assets", "poster", "motionBlur", "loader"];
-function deck(options) {
-  if (!options || !Array.isArray(options.pages) || options.pages.length === 0) throw new Error("deck(): pages must be a list with at least one page: { pages: [{ name, duration, stops, sequences }] }");
-  warnUnknownOptions("deck()", options, DECK_KEYS);
-  const { pages, transition, ...movieOptions } = options;
-  pages.forEach((p, i) => {
-    if (!p || typeof p !== "object") throw new Error(`deck(): pages[${i}] must be an object`);
-    warnUnknownOptions(`deck() pages[${i}]`, p, PAGE_KEYS);
-    if (!(typeof p.duration === "number" && Number.isFinite(p.duration) && p.duration > 0)) throw new Error(`deck(): pages[${i}].duration must be a positive number of seconds, got ${String(p.duration)}`);
-    if (!Array.isArray(p.sequences)) throw new Error(`deck(): pages[${i}].sequences must be a list of layers (it may be empty), got ${typeof p.sequences}`);
-  });
-  let overlap = 0;
-  if (transition) {
-    if (!(typeof transition.duration === "number" && transition.duration > 0)) throw new Error("deck(): transition needs a duration in seconds: { kind: 'crossfade', duration: 0.6 }");
-    const shortest = Math.min(...pages.map((p) => p.duration));
-    if (pages.length > 1 && transition.duration >= shortest) throw new Error(`deck(): the transition (${transition.duration} s) must be shorter than every page (the shortest is ${shortest} s)`);
-    overlap = pages.length > 1 ? transition.duration : 0;
-  }
-  const sequences = [];
-  const transitions = [];
-  const stops = [];
-  let start = 0;
-  pages.forEach((page, i) => {
-    const id = `page-${i + 1}`;
-    const label = page.name ? `"${page.name}"` : `pages[${i}]`;
-    const isLast = i === pages.length - 1;
-    const entries = (page.stops ?? [isLast ? page.duration : page.duration - overlap]).map((e, k) => {
-      if (e && typeof e === "object") warnUnknownOptions(`deck() page ${label} stops[${k}]`, e, ["at", "pdf"]);
-      return typeof e === "object" && e !== null ? e : { at: e };
-    });
-    const local = entries.map((e) => e.at);
-    local.forEach((s, k) => {
-      if (!(typeof s === "number" && Number.isFinite(s) && s > 0 && s <= page.duration + 1e-9)) throw new Error(`deck(): page ${label} has stop ${String(s)}, outside the page (0 to ${page.duration} s)`);
-      if (k > 0 && s <= local[k - 1]) throw new Error(`deck(): page ${label} stops must be in order, earliest first (got ${local.join(", ")})`);
-    });
-    const { name: _n, duration: _d, sequences: inner, stops: _s, notes: _no, advance: _a, ...layerProps } = page;
-    sequences.push({ type: "composition", name: id, at: round2(start), duration: page.duration, ...layerProps, sequences: inner });
-    local.forEach((s, k) => {
-      const stop = { at: round2(start + s) };
-      if (k === 0) {
-        stop.page = page.name ?? true;
-        if (page.notes !== void 0) stop.notes = page.notes;
-      }
-      if (k === local.length - 1 && page.advance !== void 0) stop.advance = page.advance;
-      if (entries[k].pdf !== void 0) stop.pdf = entries[k].pdf;
-      stops.push(stop);
-    });
-    if (transition && !isLast) {
-      const next = start + page.duration - overlap;
-      transitions.push({ ...transition, from: id, to: `page-${i + 2}`, at: round2(next), duration: transition.duration });
-    }
-    start = start + page.duration - (isLast ? 0 : overlap);
-  });
-  const composition = { sequences, stops };
-  if (transitions.length > 0) composition.transitions = transitions;
-  return { ...movieOptions, duration: round2(start), composition };
-}
-var round2 = (v) => Math.round(v * 1e6) / 1e6;
-
-// src/transforms/withFade.ts
-function withFade(spec, opts) {
-  warnUnknownOptions("withFade()", opts, ["in", "out"]);
-  if (opts.in != null && opts.in > 0) {
-    spec.initial = { ...spec.initial ?? {}, alpha: 0 };
-    const kf = { at: 0, to: { alpha: 1 }, duration: opts.in };
-    spec.keyframes = [...spec.keyframes ?? [], kf];
-  }
-  if (opts.out != null && opts.out > 0) {
-    if (spec.duration == null) {
-      throw new Error(
-        "withFade(spec, { out }) requires spec.duration to be set so the fade-out can be anchored to the sequence end. Set spec.duration before passing the spec in."
-      );
-    }
-    const kf = { at: spec.duration - opts.out, to: { alpha: 0 }, duration: opts.out };
-    spec.keyframes = [...spec.keyframes ?? [], kf];
-  }
-  return spec;
-}
-
-export { Movie, animateText, audioEnvelope, bpmEnvelope, cameraPath, computeEnvelope, deck, dismissLoader, parseEase2 as ease, failLoader, followPath, kenBurns, measureText, musicBuffer, musicEnvelope, musicEvents, normalizeStops, orbit, particles, pictureStops, react, resolveLoader, splitText, stagger, wiggle, withFade };
+export { Movie, animateText, audioEnvelope, bpmEnvelope, cameraPath, computeEnvelope, dismissLoader, parseEase as ease, failLoader, followPath, kenBurns, measureText, musicBuffer, musicEnvelope, musicEvents, orbit, particles, react, resolveLoader, splitText, stagger, wiggle, withFade } from './chunk-CRQFDY7E.js';
+import './chunk-A3Q3SDSH.js';
+export { Sequence, noise, rand, random, registerSequenceType } from './chunk-ZAXYPXKW.js';
+import './chunk-4KB3GUEK.js';
+import './chunk-RCVZX2JP.js';
+export { warnUnknownOptions } from './chunk-BXOCEZ4U.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map