pixi-effects 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3045 @@
+'use strict';
+
+var gsap = require('gsap');
+var PIXI = require('pixi.js');
+var PixiPlugin = require('gsap/PixiPlugin');
+var mediabunny = require('mediabunny');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var PIXI__namespace = /*#__PURE__*/_interopNamespace(PIXI);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/expr/Parser.ts
+function isDigit(c) {
+  return c >= "0" && c <= "9";
+}
+function isIdStart(c) {
+  return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_";
+}
+function isIdCont(c) {
+  return isIdStart(c) || isDigit(c);
+}
+function tokenize(src) {
+  const out = [];
+  for (let i = 0; i < src.length; ) {
+    const c = src[i];
+    if (c === " " || c === "	" || c === "\n" || c === "\r") {
+      i++;
+      continue;
+    }
+    if (isDigit(c) || c === "." && isDigit(src[i + 1] ?? "")) {
+      let j = i + 1;
+      while (j < src.length && (isDigit(src[j]) || src[j] === ".")) j++;
+      const value = parseFloat(src.slice(i, j));
+      if (Number.isNaN(value)) throw new Error(`bad number at ${i}`);
+      out.push({ type: "num", value });
+      i = j;
+      continue;
+    }
+    if (isIdStart(c)) {
+      let j = i + 1;
+      while (j < src.length && isIdCont(src[j])) j++;
+      out.push({ type: "id", name: src.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (c === "+" || c === "-" || c === "*" || c === "/") {
+      out.push({ type: "op", op: c });
+      i++;
+      continue;
+    }
+    if (c === "(") {
+      out.push({ type: "lparen" });
+      i++;
+      continue;
+    }
+    if (c === ")") {
+      out.push({ type: "rparen" });
+      i++;
+      continue;
+    }
+    if (c === ",") {
+      out.push({ type: "comma" });
+      i++;
+      continue;
+    }
+    throw new Error(`unexpected character "${c}" at ${i}`);
+  }
+  return out;
+}
+function parseExpr(c) {
+  return parseAdd(c);
+}
+function parseAdd(c) {
+  let node = parseMul(c);
+  for (; ; ) {
+    const t = c.peek();
+    if (t?.type !== "op" || t.op !== "+" && t.op !== "-") break;
+    c.next();
+    node = { kind: "bin", op: t.op, left: node, right: parseMul(c) };
+  }
+  return node;
+}
+function parseMul(c) {
+  let node = parseUnary(c);
+  for (; ; ) {
+    const t = c.peek();
+    if (t?.type !== "op" || t.op !== "*" && t.op !== "/") break;
+    c.next();
+    node = { kind: "bin", op: t.op, left: node, right: parseUnary(c) };
+  }
+  return node;
+}
+function parseUnary(c) {
+  const t = c.peek();
+  if (t?.type === "op" && t.op === "-") {
+    c.next();
+    return { kind: "neg", child: parseUnary(c) };
+  }
+  if (t?.type === "op" && t.op === "+") {
+    c.next();
+    return parseUnary(c);
+  }
+  return parsePrimary(c);
+}
+function parsePrimary(c) {
+  const t = c.next();
+  if (!t) throw new Error("unexpected end of expression");
+  if (t.type === "num") return { kind: "num", value: t.value };
+  if (t.type === "lparen") {
+    const node = parseExpr(c);
+    const close = c.next();
+    if (close?.type !== "rparen") throw new Error('expected ")"');
+    return node;
+  }
+  if (t.type === "id") {
+    if (c.peek()?.type === "lparen") {
+      c.next();
+      const args = [];
+      if (c.peek()?.type !== "rparen") {
+        args.push(parseExpr(c));
+        while (c.peek()?.type === "comma") {
+          c.next();
+          args.push(parseExpr(c));
+        }
+      }
+      const close = c.next();
+      if (close?.type !== "rparen") throw new Error('expected ")"');
+      return { kind: "call", name: t.name, args };
+    }
+    return { kind: "var", name: t.name };
+  }
+  throw new Error(`unexpected token "${t.type}"`);
+}
+function parse(src) {
+  const c = new Cursor(tokenize(src));
+  const node = parseExpr(c);
+  if (c.peek()) throw new Error("trailing input");
+  return node;
+}
+function evalNode(node, scope) {
+  switch (node.kind) {
+    case "num":
+      return node.value;
+    case "var": {
+      const v = scope[node.name];
+      if (typeof v !== "number") throw new Error(`undefined variable: ${node.name}`);
+      return v;
+    }
+    case "neg":
+      return -evalNode(node.child, scope);
+    case "bin": {
+      const l = evalNode(node.left, scope);
+      const r = evalNode(node.right, scope);
+      switch (node.op) {
+        case "+":
+          return l + r;
+        case "-":
+          return l - r;
+        case "*":
+          return l * r;
+        case "/":
+          return l / r;
+      }
+    }
+    /* c8 ignore next 5 */
+    // eslint-disable-next-line no-fallthrough
+    case "call": {
+      const fn = FUNCS[node.name];
+      if (!fn) throw new Error(`unknown function: ${node.name}`);
+      return fn(...node.args.map((a) => evalNode(a, scope)));
+    }
+  }
+}
+function isExpr(v) {
+  return typeof v === "string" && v.length > 0;
+}
+function evaluateExpr(source, scope) {
+  let ast = astCache.get(source);
+  if (ast === void 0) {
+    try {
+      ast = parse(source);
+    } catch (e) {
+      console.warn(`pixi-effects: expression failed: ${source}`, e);
+      ast = ZERO_NODE;
+    }
+    astCache.set(source, ast);
+  }
+  try {
+    return evalNode(ast, scope);
+  } catch (e) {
+    console.warn(`pixi-effects: expression failed: ${source}`, e);
+    return 0;
+  }
+}
+var FUNCS, Cursor, ZERO_NODE, astCache;
+var init_Parser = __esm({
+  "src/expr/Parser.ts"() {
+    FUNCS = {
+      min: Math.min,
+      max: Math.max,
+      abs: Math.abs,
+      floor: Math.floor,
+      ceil: Math.ceil,
+      round: Math.round,
+      sqrt: Math.sqrt,
+      pow: Math.pow,
+      sin: Math.sin,
+      cos: Math.cos,
+      tan: Math.tan
+    };
+    Cursor = class {
+      constructor(tokens) {
+        this.tokens = tokens;
+      }
+      tokens;
+      i = 0;
+      peek() {
+        return this.tokens[this.i];
+      }
+      next() {
+        return this.tokens[this.i++];
+      }
+    };
+    ZERO_NODE = { kind: "num", value: 0 };
+    astCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/expr/normalizeProps.ts
+function normalizeProps(input, scope, options = {}) {
+  const skip = new Set(options.skipKeys ?? []);
+  return walk(input, scope, skip, null);
+}
+function walk(value, scope, skip, currentKey) {
+  if (Array.isArray(value)) {
+    return value.map((v) => walk(v, scope, skip, currentKey));
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const k of Object.keys(value)) {
+      out[k] = walk(value[k], scope, skip, k);
+    }
+    return out;
+  }
+  if (isExpr(value) && !(currentKey !== null && skip.has(currentKey))) {
+    if (looksLikeColorString(value)) return value;
+    return evaluateExpr(value, scope);
+  }
+  return value;
+}
+function looksLikeColorString(s) {
+  if (s.length === 0) return false;
+  if (s.charCodeAt(0) === 35) return true;
+  return /^(rgb|hsl|oklab|oklch|lab|lch)\b/i.test(s);
+}
+var init_normalizeProps = __esm({
+  "src/expr/normalizeProps.ts"() {
+    init_Parser();
+  }
+});
+function resolveAt(at, duration) {
+  if (at === void 0 || at === null) return 0;
+  return at < 0 ? duration + at : at;
+}
+function normalizeKeyframe(kf, parentDuration) {
+  const at = resolveAt(kf.at, parentDuration);
+  const duration = kf.duration ?? 0;
+  const ease = kf.ease ?? "none";
+  const hasSet = !!kf.set;
+  const hasFrom = !!kf.from;
+  const hasTo = !!kf.to;
+  let kind;
+  if (hasSet) kind = "set";
+  else if (hasFrom && hasTo) kind = "fromTo";
+  else if (hasFrom) kind = "from";
+  else if (hasTo) kind = "to";
+  else kind = "to";
+  return { at, duration, ease, kind, set: kf.set, from: kf.from, to: kf.to };
+}
+function partitionProps(props) {
+  const ownProps = {};
+  const filterProps = {};
+  for (const k of Object.keys(props)) {
+    const m = k.match(/^filters\.([^.]+)\.(.+)$/);
+    if (m) {
+      const [, name, sub] = m;
+      (filterProps[name] ??= {})[sub] = props[k];
+    } else {
+      ownProps[k] = props[k];
+    }
+  }
+  return { ownProps, filterProps };
+}
+function findFilter(target, name) {
+  if (!target?.filters) return null;
+  for (const f of target.filters) {
+    if (f?._name === name) return f;
+  }
+  return null;
+}
+function pixiwrap(props) {
+  const out = {};
+  const pixi = {};
+  let usedPixi = false;
+  for (const [k, v] of Object.entries(props)) {
+    if (PIXI_SHORTHANDS.has(k)) {
+      pixi[k] = v;
+      usedPixi = true;
+    } else {
+      out[k] = v;
+    }
+  }
+  if (usedPixi) out.pixi = pixi;
+  return out;
+}
+function applyKeyframes(timeline, target, keyframes, parentDuration, scope, skipKeys = [], offset = 0) {
+  for (const raw of keyframes ?? []) {
+    const kf = normalizeKeyframe(raw, parentDuration);
+    const at = offset + kf.at;
+    if (kf.kind === "set") {
+      const resolved = normalizeProps(kf.set, scope, { skipKeys });
+      const { ownProps, filterProps } = partitionProps(resolved);
+      if (Object.keys(ownProps).length > 0) timeline.set(target, pixiwrap(ownProps), at);
+      for (const [name, props] of Object.entries(filterProps)) {
+        const f = findFilter(target, name);
+        if (!f) continue;
+        timeline.set(f, props, at);
+      }
+    } else if (kf.kind === "to") {
+      const resolved = normalizeProps(kf.to, scope, { skipKeys });
+      const { ownProps, filterProps } = partitionProps(resolved);
+      if (Object.keys(ownProps).length > 0)
+        timeline.to(target, { ...pixiwrap(ownProps), duration: kf.duration, ease: kf.ease }, at);
+      for (const [name, props] of Object.entries(filterProps)) {
+        const f = findFilter(target, name);
+        if (!f) continue;
+        timeline.to(f, { ...props, duration: kf.duration, ease: kf.ease }, at);
+      }
+    } else if (kf.kind === "from") {
+      const resolved = normalizeProps(kf.from, scope, { skipKeys });
+      const { ownProps, filterProps } = partitionProps(resolved);
+      if (Object.keys(ownProps).length > 0)
+        timeline.from(target, { ...pixiwrap(ownProps), duration: kf.duration, ease: kf.ease }, at);
+      for (const [name, props] of Object.entries(filterProps)) {
+        const f = findFilter(target, name);
+        if (!f) continue;
+        timeline.from(f, { ...props, duration: kf.duration, ease: kf.ease }, at);
+      }
+    } else {
+      const fromResolved = normalizeProps(kf.from, scope, { skipKeys });
+      const toResolved = normalizeProps(kf.to, scope, { skipKeys });
+      const fromSplit = partitionProps(fromResolved);
+      const toSplit = partitionProps(toResolved);
+      const ownKeys = /* @__PURE__ */ new Set([...Object.keys(fromSplit.ownProps), ...Object.keys(toSplit.ownProps)]);
+      if (ownKeys.size > 0) {
+        timeline.fromTo(
+          target,
+          { ...pixiwrap(fromSplit.ownProps) },
+          { ...pixiwrap(toSplit.ownProps), duration: kf.duration, ease: kf.ease },
+          at
+        );
+      }
+      const filterNames = /* @__PURE__ */ new Set([
+        ...Object.keys(fromSplit.filterProps),
+        ...Object.keys(toSplit.filterProps)
+      ]);
+      for (const name of filterNames) {
+        const f = findFilter(target, name);
+        if (!f) continue;
+        timeline.fromTo(
+          f,
+          { ...fromSplit.filterProps[name] ?? {} },
+          { ...toSplit.filterProps[name] ?? {}, duration: kf.duration, ease: kf.ease },
+          at
+        );
+      }
+    }
+  }
+}
+function applyInitial(target, initial, scope, skipKeys = []) {
+  if (!initial) return;
+  const resolved = normalizeProps(initial, scope, { skipKeys });
+  const { ownProps, filterProps } = partitionProps(resolved);
+  if (Object.keys(ownProps).length > 0) gsap.gsap.set(target, pixiwrap(ownProps));
+  for (const [name, props] of Object.entries(filterProps)) {
+    const f = findFilter(target, name);
+    if (!f) continue;
+    gsap.gsap.set(f, props);
+  }
+}
+var PIXI_SHORTHANDS;
+var init_Timeline = __esm({
+  "src/core/Timeline.ts"() {
+    init_normalizeProps();
+    PIXI_SHORTHANDS = /* @__PURE__ */ new Set([
+      "scale",
+      "scaleX",
+      "scaleY",
+      "anchor",
+      "anchorX",
+      "anchorY",
+      "pivot",
+      "pivotX",
+      "pivotY",
+      "skew",
+      "skewX",
+      "skewY",
+      "rotation",
+      "position",
+      "positionX",
+      "positionY",
+      "tilePosition",
+      "tilePositionX",
+      "tilePositionY",
+      "tileScale",
+      "tileScaleX",
+      "tileScaleY",
+      "tint",
+      "colorize",
+      "colorizeAmount",
+      "colorMatrixFilter",
+      "blur",
+      "blurX",
+      "blurY",
+      "blurPadding",
+      "autoAlpha",
+      "lineColor",
+      "lineAlpha",
+      "fillColor",
+      "fillAlpha"
+    ]);
+  }
+});
+
+// src/expr/Scope.ts
+function buildScope(sequence, parent, root) {
+  const w = sequence.intrinsicWidth || 0;
+  const h = sequence.intrinsicHeight || 0;
+  const W = parent?.width ?? root.width;
+  const H = parent?.height ?? root.height;
+  const GW = root.width;
+  const GH = root.height;
+  const contain = w === 0 || h === 0 ? 1 : Math.min(W / w, H / h);
+  const cover = w === 0 || h === 0 ? 1 : Math.max(W / w, H / h);
+  return {
+    w,
+    h,
+    W,
+    H,
+    GW,
+    GH,
+    contain,
+    cover,
+    t: sequence.at ?? 0,
+    d: sequence.duration ?? parent?.duration ?? root.duration,
+    T: parent?.duration ?? root.duration
+  };
+}
+var init_Scope = __esm({
+  "src/expr/Scope.ts"() {
+  }
+});
+function toRgb01(input) {
+  if (Array.isArray(input)) return [input[0], input[1], input[2]];
+  const c = new PIXI.Color(input);
+  return [c.red, c.green, c.blue];
+}
+var GL_FRAGMENT, WGSL_SOURCE, ChromaKeyFilter;
+var init_ChromaKey = __esm({
+  "src/filters/ChromaKey.ts"() {
+    GL_FRAGMENT = `
+in vec2 vTextureCoord;
+uniform sampler2D uTexture;
+uniform vec3 uKeyColor;
+uniform float uThreshold;
+uniform float uSmoothing;
+uniform float uSpill;
+
+out vec4 finalColor;
+
+void main(void) {
+    vec4 raw = texture(uTexture, vTextureCoord);
+
+    // Pixi passes pre-multiplied alpha into filters. Un-premultiply so the
+    // chromakey distance is computed against the source color, not a darkened
+    // version that drifts away from the key as sprite.alpha drops.
+    vec3 rgb = raw.a > 0.0 ? raw.rgb / raw.a : vec3(0.0);
+
+    vec3 ycbcr = vec3(
+        0.299 * rgb.r + 0.587 * rgb.g + 0.114 * rgb.b,
+        -0.169 * rgb.r - 0.331 * rgb.g + 0.5 * rgb.b + 0.5,
+        0.5 * rgb.r - 0.419 * rgb.g - 0.081 * rgb.b + 0.5
+    );
+    vec3 keyYcbcr = vec3(
+        0.299 * uKeyColor.r + 0.587 * uKeyColor.g + 0.114 * uKeyColor.b,
+        -0.169 * uKeyColor.r - 0.331 * uKeyColor.g + 0.5 * uKeyColor.b + 0.5,
+        0.5 * uKeyColor.r - 0.419 * uKeyColor.g - 0.081 * uKeyColor.b + 0.5
+    );
+
+    float dist = length(ycbcr - keyYcbcr);
+    float alpha = smoothstep(uThreshold - uSmoothing, uThreshold + uSmoothing, dist);
+
+    vec3 despilled = rgb;
+    if (uSpill > 0.0) {
+        float spillAmount = max(0.0, rgb.g - max(rgb.r, rgb.b));
+        despilled.g -= spillAmount * uSpill;
+    }
+
+    float outA = raw.a * alpha;
+    finalColor = vec4(despilled * outA, outA);
+}
+`;
+    WGSL_SOURCE = `
+struct GlobalFilterUniforms {
+  uInputSize: vec4<f32>,
+  uInputPixel: vec4<f32>,
+  uInputClamp: vec4<f32>,
+  uOutputFrame: vec4<f32>,
+  uGlobalFrame: vec4<f32>,
+  uOutputTexture: vec4<f32>,
+};
+
+struct ChromaUniforms {
+  uKeyColor: vec3<f32>,
+  uThreshold: f32,
+  uSmoothing: f32,
+  uSpill: 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> chromaUniforms : ChromaUniforms;
+
+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),
+  );
+}
+
+@fragment
+fn mainFragment(@location(0) uv : vec2<f32>) -> @location(0) vec4<f32> {
+  let raw = textureSample(uTexture, uSampler, uv);
+
+  // Un-premultiply (see comment in the GLSL version above).
+  var rgb: vec3<f32>;
+  if (raw.a > 0.0) {
+    rgb = raw.rgb / raw.a;
+  } else {
+    rgb = vec3<f32>(0.0);
+  }
+
+  let key = chromaUniforms.uKeyColor;
+
+  let ycbcr = vec3<f32>(
+    0.299 * rgb.r + 0.587 * rgb.g + 0.114 * rgb.b,
+    -0.169 * rgb.r - 0.331 * rgb.g + 0.5 * rgb.b + 0.5,
+    0.5 * rgb.r - 0.419 * rgb.g - 0.081 * rgb.b + 0.5,
+  );
+  let keyYcbcr = vec3<f32>(
+    0.299 * key.r + 0.587 * key.g + 0.114 * key.b,
+    -0.169 * key.r - 0.331 * key.g + 0.5 * key.b + 0.5,
+    0.5 * key.r - 0.419 * key.g - 0.081 * key.b + 0.5,
+  );
+
+  let dist = length(ycbcr - keyYcbcr);
+  let alpha = smoothstep(
+    chromaUniforms.uThreshold - chromaUniforms.uSmoothing,
+    chromaUniforms.uThreshold + chromaUniforms.uSmoothing,
+    dist,
+  );
+
+  var despilled = rgb;
+  if (chromaUniforms.uSpill > 0.0) {
+    let spillAmount = max(0.0, rgb.g - max(rgb.r, rgb.b));
+    despilled.g = despilled.g - spillAmount * chromaUniforms.uSpill;
+  }
+
+  let outA = raw.a * alpha;
+  return vec4<f32>(despilled * outA, outA);
+}
+`;
+    ChromaKeyFilter = class extends PIXI.Filter {
+      constructor(options = {}) {
+        const {
+          keyColor = "#00ff00",
+          threshold = 0.4,
+          smoothing = 0.1,
+          spill = 0.2
+        } = options;
+        const glProgram = PIXI.GlProgram.from({
+          vertex: PIXI.defaultFilterVert,
+          fragment: GL_FRAGMENT,
+          name: "chroma-key-filter"
+        });
+        const gpuProgram = PIXI.GpuProgram.from({
+          vertex: { source: WGSL_SOURCE, entryPoint: "mainVertex" },
+          fragment: { source: WGSL_SOURCE, entryPoint: "mainFragment" }
+        });
+        super({
+          glProgram,
+          gpuProgram,
+          resources: {
+            chromaUniforms: new PIXI.UniformGroup({
+              uKeyColor: { value: toRgb01(keyColor), type: "vec3<f32>" },
+              uThreshold: { value: threshold, type: "f32" },
+              uSmoothing: { value: smoothing, type: "f32" },
+              uSpill: { value: spill, type: "f32" }
+            })
+          }
+        });
+      }
+      get threshold() {
+        return this.resources.chromaUniforms.uniforms.uThreshold;
+      }
+      set threshold(v) {
+        this.resources.chromaUniforms.uniforms.uThreshold = v;
+      }
+      get smoothing() {
+        return this.resources.chromaUniforms.uniforms.uSmoothing;
+      }
+      set smoothing(v) {
+        this.resources.chromaUniforms.uniforms.uSmoothing = v;
+      }
+      get spill() {
+        return this.resources.chromaUniforms.uniforms.uSpill;
+      }
+      set spill(v) {
+        this.resources.chromaUniforms.uniforms.uSpill = v;
+      }
+      setKeyColor(input) {
+        const rgb = toRgb01(input);
+        const u = this.resources.chromaUniforms.uniforms.uKeyColor;
+        u[0] = rgb[0];
+        u[1] = rgb[1];
+        u[2] = rgb[2];
+      }
+    };
+  }
+});
+
+// src/filters/index.ts
+function looksLikePixiFilter(x) {
+  return !!x && typeof x === "object" && typeof x.apply === "function";
+}
+function createFilter(spec) {
+  if (spec.type === "custom") {
+    const inst2 = spec.filter;
+    if (!looksLikePixiFilter(inst2)) {
+      throw new Error('pixi-effects: { type: "custom" } requires a `filter` that is a PIXI Filter instance (duck-typed: must have an `apply` method).');
+    }
+    const named = inst2;
+    named._name = spec.name;
+    return named;
+  }
+  const Cls = registry[spec.type];
+  if (!Cls) throw new Error(`pixi-effects: unknown filter type "${spec.type}"`);
+  const { type: _t, name, ...params } = spec;
+  const inst = new Cls(params);
+  inst._name = name;
+  return inst;
+}
+var registry;
+var init_filters = __esm({
+  "src/filters/index.ts"() {
+    init_ChromaKey();
+    registry = {
+      chromaKey: ChromaKeyFilter
+    };
+  }
+});
+var Sequence;
+var init_Base = __esm({
+  "src/sequences/Base.ts"() {
+    init_Timeline();
+    init_Scope();
+    init_filters();
+    Sequence = class {
+      spec;
+      parent;
+      root;
+      target = null;
+      intrinsicWidth = 0;
+      intrinsicHeight = 0;
+      at;
+      duration;
+      filters = [];
+      /**
+       * Mask sequence built from `spec.mask`, if any. Built and added to the
+       * scene graph by the parent CompositionSequence; rendered as a mask
+       * (not a normal child) by PIXI when `target.mask = maskSequence.target`.
+       */
+      maskSequence = null;
+      constructor(spec, parent, root) {
+        this.spec = spec;
+        this.parent = parent;
+        this.root = root;
+        this.at = spec.at ?? 0;
+        this.duration = spec.duration;
+      }
+      buildFilters() {
+        const specs = this.spec.filters ?? [];
+        this.filters = specs.map(createFilter);
+        if (this.target && "filters" in this.target) {
+          this.target.filters = this.filters;
+        }
+        const fa = this.spec.filterArea;
+        if (fa && this.target) {
+          this.target.filterArea = new PIXI.Rectangle(fa.x, fa.y, fa.width, fa.height);
+        }
+      }
+      scope() {
+        return buildScope(this, this.parent, this.root);
+      }
+      bindTimeline(timeline, offset = 0) {
+        if (!this.target) return;
+        const scope = this.scope();
+        applyInitial(this.target, this.spec.initial, scope);
+        applyKeyframes(timeline, this.target, this.spec.keyframes, this.duration, scope, [], offset);
+        const startTime = offset + this.at;
+        const endTime = startTime + this.duration;
+        this.target.renderable = startTime <= 0;
+        timeline.set(this.target, { renderable: true }, startTime);
+        timeline.set(this.target, { renderable: false }, endTime);
+      }
+      collectAudio(_out, _baseTime) {
+      }
+      destroy() {
+        this.maskSequence?.destroy();
+        this.maskSequence = null;
+        this.target?.destroy?.();
+        this.target = null;
+      }
+    };
+  }
+});
+
+// src/expr/colorInterp.ts
+function buildColorInterp(from, to, space) {
+  const fromRGBA = parseToRGBA(from);
+  const toRGBA = parseToRGBA(to);
+  const fromOk = rgbToOklab(fromRGBA);
+  const toOk = rgbToOklab(toRGBA);
+  if (space === "oklab") {
+    return (t) => {
+      const L = lerp(fromOk.L, toOk.L, t);
+      const a = lerp(fromOk.a, toOk.a, t);
+      const b = lerp(fromOk.b, toOk.b, t);
+      const alpha = lerp(fromRGBA.a, toRGBA.a, t);
+      return rgbaString(oklabToRgb({ L, a, b }), alpha);
+    };
+  }
+  const fromLCH = oklabToOklch(fromOk);
+  const toLCH = oklabToOklch(toOk);
+  if (fromLCH.C < 1e-4) fromLCH.h = toLCH.h;
+  if (toLCH.C < 1e-4) toLCH.h = fromLCH.h;
+  const hueDelta = shortestHueDelta(fromLCH.h, toLCH.h);
+  return (t) => {
+    const L = lerp(fromLCH.L, toLCH.L, t);
+    const C = lerp(fromLCH.C, toLCH.C, t);
+    const h = fromLCH.h + hueDelta * t;
+    const alpha = lerp(fromRGBA.a, toRGBA.a, t);
+    const ab = oklchToOklab({ L, C, h });
+    return rgbaString(oklabToRgb(ab), alpha);
+  };
+}
+function parseToRGBA(input) {
+  if (typeof input === "number") {
+    return { r: (input >> 16 & 255) / 255, g: (input >> 8 & 255) / 255, b: (input & 255) / 255, a: 1 };
+  }
+  const s = input.trim();
+  if (s.startsWith("#")) return parseHex(s);
+  if (s.startsWith("rgb")) return parseRgbFunc(s);
+  return { r: 0, g: 0, b: 0, a: 1 };
+}
+function parseHex(s) {
+  const hex = s.slice(1);
+  let r = 0, g = 0, b = 0, a = 1;
+  if (hex.length === 3 || hex.length === 4) {
+    r = parseInt(hex[0] + hex[0], 16) / 255;
+    g = parseInt(hex[1] + hex[1], 16) / 255;
+    b = parseInt(hex[2] + hex[2], 16) / 255;
+    if (hex.length === 4) a = parseInt(hex[3] + hex[3], 16) / 255;
+  } else if (hex.length === 6 || hex.length === 8) {
+    r = parseInt(hex.slice(0, 2), 16) / 255;
+    g = parseInt(hex.slice(2, 4), 16) / 255;
+    b = parseInt(hex.slice(4, 6), 16) / 255;
+    if (hex.length === 8) a = parseInt(hex.slice(6, 8), 16) / 255;
+  }
+  return { r, g, b, a };
+}
+function parseRgbFunc(s) {
+  const inner = s.replace(/^rgba?\(/, "").replace(/\)$/, "");
+  const parts = inner.split(/[,\s/]+/).filter(Boolean).map(parseFloat);
+  return {
+    r: (parts[0] ?? 0) / 255,
+    g: (parts[1] ?? 0) / 255,
+    b: (parts[2] ?? 0) / 255,
+    a: parts.length > 3 ? parts[3] ?? 1 : 1
+  };
+}
+function rgbaString(rgb, alpha) {
+  const r = Math.round(clamp01(rgb.r) * 255);
+  const g = Math.round(clamp01(rgb.g) * 255);
+  const b = Math.round(clamp01(rgb.b) * 255);
+  return `rgba(${r},${g},${b},${alpha})`;
+}
+function srgbToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function linearToSrgb(c) {
+  return c <= 31308e-7 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+}
+function rgbToOklab(rgba) {
+  const r = srgbToLinear(rgba.r);
+  const g = srgbToLinear(rgba.g);
+  const b = srgbToLinear(rgba.b);
+  const l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
+  const m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
+  const s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
+  const l_ = Math.cbrt(l);
+  const m_ = Math.cbrt(m);
+  const s_ = Math.cbrt(s);
+  return {
+    L: 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,
+    a: 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,
+    b: 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_
+  };
+}
+function oklabToRgb(lab) {
+  const l_ = lab.L + 0.3963377774 * lab.a + 0.2158037573 * lab.b;
+  const m_ = lab.L - 0.1055613458 * lab.a - 0.0638541728 * lab.b;
+  const s_ = lab.L - 0.0894841775 * lab.a - 1.291485548 * lab.b;
+  const l = l_ * l_ * l_;
+  const m = m_ * m_ * m_;
+  const s = s_ * s_ * s_;
+  return {
+    r: linearToSrgb(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s),
+    g: linearToSrgb(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s),
+    b: linearToSrgb(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s)
+  };
+}
+function oklabToOklch(lab) {
+  return { L: lab.L, C: Math.hypot(lab.a, lab.b), h: Math.atan2(lab.b, lab.a) };
+}
+function oklchToOklab(lch) {
+  return { L: lch.L, a: lch.C * Math.cos(lch.h), b: lch.C * Math.sin(lch.h) };
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function clamp01(v) {
+  return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+function shortestHueDelta(from, to) {
+  const TWO_PI = Math.PI * 2;
+  let d = (to - from) % TWO_PI;
+  if (d > Math.PI) d -= TWO_PI;
+  if (d < -Math.PI) d += TWO_PI;
+  return d;
+}
+var init_colorInterp = __esm({
+  "src/expr/colorInterp.ts"() {
+  }
+});
+function tweenColor(timeline, target, key, fromValue, toValue, duration, ease, at, colorSpace, onUpdate) {
+  let interp = null;
+  const proxy = { p: 0 };
+  timeline.fromTo(
+    proxy,
+    { p: 0 },
+    {
+      p: 1,
+      duration,
+      ease,
+      onStart: () => {
+        const start = fromValue !== void 0 ? fromValue : target[key];
+        if (start === void 0) return;
+        interp = colorSpace === "rgb" ? gsap.gsap.utils.interpolate(start, toValue) : buildColorInterp(start, toValue, colorSpace);
+      },
+      onUpdate: () => {
+        if (interp) {
+          target[key] = interp(proxy.p);
+          if (onUpdate) onUpdate();
+        }
+      }
+    },
+    at
+  );
+}
+var init_colorTween = __esm({
+  "src/expr/colorTween.ts"() {
+    init_colorInterp();
+  }
+});
+function stripKeys(props, keys) {
+  if (!props) return props;
+  const drop = new Set(keys);
+  const out = {};
+  let changed = false;
+  for (const k of Object.keys(props)) {
+    if (drop.has(k)) {
+      changed = true;
+      continue;
+    }
+    out[k] = props[k];
+  }
+  return changed ? out : props;
+}
+function stripKeysInKeyframe(kf, keys) {
+  return {
+    ...kf,
+    set: stripKeys(kf.set, keys),
+    to: stripKeys(kf.to, keys),
+    from: stripKeys(kf.from, keys)
+  };
+}
+var ImageSequence;
+var init_Image = __esm({
+  "src/sequences/Image.ts"() {
+    init_Base();
+    init_Timeline();
+    init_colorTween();
+    ImageSequence = class extends Sequence {
+      async build() {
+        const texture = await PIXI.Assets.get(this.spec.asset);
+        const sprite = new PIXI.Sprite({ texture, label: this.spec.name });
+        sprite.cullable = true;
+        this.target = sprite;
+        this.intrinsicWidth = texture.width;
+        this.intrinsicHeight = texture.height;
+        if (this.duration === void 0) {
+          this.duration = this.parent?.duration ?? this.root.duration;
+        }
+        this.buildFilters();
+      }
+      bindTimeline(timeline, offset = 0) {
+        if (!this.target) return;
+        const colorSpace = this.spec.colorSpace;
+        if (!colorSpace || colorSpace === "rgb") {
+          super.bindTimeline(timeline, offset);
+          return;
+        }
+        const scope = this.scope();
+        const initial = stripKeys(this.spec.initial, ["tint"]);
+        const keyframes = this.spec.keyframes ? this.spec.keyframes.map((kf) => stripKeysInKeyframe(kf, ["tint"])) : void 0;
+        applyInitial(this.target, initial, scope);
+        applyKeyframes(timeline, this.target, keyframes, this.duration, scope, [], offset);
+        const initTint = this.spec.initial?.tint;
+        if (initTint !== void 0) this.target.tint = initTint;
+        for (const kf of this.spec.keyframes ?? []) {
+          const at = offset + resolveAt(kf.at, this.duration);
+          const duration = kf.duration ?? 0;
+          const ease = kf.ease ?? "none";
+          const fromTint = kf.from?.tint;
+          const toTint = kf.to?.tint;
+          const setTint = kf.set?.tint;
+          if (setTint !== void 0) {
+            timeline.call(() => {
+              this.target.tint = setTint;
+            }, [], at);
+          }
+          if (toTint !== void 0) {
+            tweenColor(
+              timeline,
+              this.target,
+              "tint",
+              fromTint,
+              toTint,
+              duration,
+              ease,
+              at,
+              colorSpace
+            );
+          }
+        }
+        const startTime = offset + this.at;
+        const endTime = startTime + this.duration;
+        this.target.renderable = startTime <= 0;
+        timeline.set(this.target, { renderable: true }, startTime);
+        timeline.set(this.target, { renderable: false }, endTime);
+      }
+    };
+  }
+});
+function runSuperWithStrippedSpec(inst, strippedSpec, timeline, offset) {
+  const originalSpec = inst.spec;
+  inst.spec = strippedSpec;
+  try {
+    Sequence.prototype.bindTimeline.call(inst, timeline, offset);
+  } finally {
+    inst.spec = originalSpec;
+  }
+}
+function stripFill(spec) {
+  return {
+    ...spec,
+    initial: stripKey(spec.initial, "fill"),
+    keyframes: spec.keyframes ? spec.keyframes.map((kf) => ({
+      ...kf,
+      set: stripKey(kf.set, "fill"),
+      to: stripKey(kf.to, "fill"),
+      from: stripKey(kf.from, "fill")
+    })) : void 0
+  };
+}
+function stripKey(props, key) {
+  if (!props) return props;
+  if (!(key in props)) return props;
+  const out = {};
+  for (const k of Object.keys(props)) if (k !== key) out[k] = props[k];
+  return out;
+}
+function bindFillKeyframes(timeline, text, keyframes, parentDuration, offset, colorSpace) {
+  const state = { fill: text.style.fill };
+  const writeFill = () => {
+    text.style.fill = state.fill;
+  };
+  for (const kf of keyframes) {
+    const at = offset + resolveAt(kf.at, parentDuration);
+    const duration = kf.duration ?? 0;
+    const ease = kf.ease ?? "none";
+    const setFill = pickFill(kf.set);
+    const fromFill = pickFill(kf.from);
+    const toFill = pickFill(kf.to);
+    if (setFill !== void 0) {
+      timeline.call(() => {
+        state.fill = setFill;
+        writeFill();
+      }, [], at);
+    }
+    if (toFill !== void 0) {
+      tweenColor(
+        timeline,
+        state,
+        "fill",
+        fromFill,
+        toFill,
+        duration,
+        ease,
+        at,
+        colorSpace,
+        writeFill
+      );
+    }
+  }
+}
+function pickFill(props) {
+  if (!props) return void 0;
+  const v = props.fill;
+  if (typeof v === "string" || typeof v === "number") return v;
+  return void 0;
+}
+var STYLE_OPAQUE_KEYS, TextSequence;
+var init_Text = __esm({
+  "src/sequences/Text.ts"() {
+    init_Base();
+    init_normalizeProps();
+    init_Timeline();
+    init_colorTween();
+    STYLE_OPAQUE_KEYS = ["fontFamily", "fill", "align", "fontStyle", "fontWeight"];
+    TextSequence = class extends Sequence {
+      async build() {
+        const baseStyle = {
+          fontFamily: "Arial",
+          fontSize: 36,
+          fill: "#ffffff",
+          align: "center"
+        };
+        const text = new PIXI.Text({
+          text: this.spec.text ?? "",
+          style: baseStyle,
+          label: this.spec.name
+        });
+        text.cullable = true;
+        this.target = text;
+        this.intrinsicWidth = text.width;
+        this.intrinsicHeight = text.height;
+        if (this.duration === void 0) {
+          this.duration = this.parent?.duration ?? this.root.duration;
+        }
+        if (this.spec.style) {
+          const scope = this.scope();
+          const resolved = normalizeProps(
+            this.spec.style,
+            scope,
+            { skipKeys: STYLE_OPAQUE_KEYS }
+          );
+          for (const k of Object.keys(resolved)) {
+            text.style[k] = resolved[k];
+          }
+        }
+        this.buildFilters();
+      }
+      bindTimeline(timeline, offset = 0) {
+        if (!this.target) return;
+        const colorSpace = this.spec.colorSpace ?? "rgb";
+        const stripped = stripFill(this.spec);
+        runSuperWithStrippedSpec(this, stripped, timeline, offset);
+        bindFillKeyframes(timeline, this.target, this.spec.keyframes ?? [], this.duration, offset, colorSpace);
+      }
+    };
+  }
+});
+var AudioSequence;
+var init_Audio = __esm({
+  "src/sequences/Audio.ts"() {
+    init_Base();
+    init_Timeline();
+    AudioSequence = class extends Sequence {
+      _audioBuffer = null;
+      async build() {
+        const data = await PIXI.Assets.get(this.spec.asset);
+        this._audioBuffer = data.audioBuffer;
+        if (this.duration === void 0) {
+          this.duration = this.spec.duration ?? data.duration ?? this.root.duration;
+        }
+        this.target = null;
+      }
+      bindTimeline(_timeline) {
+      }
+      collectAudio(out, baseTime) {
+        if (!this._audioBuffer) return;
+        const initialVolume = this.spec.volume ?? 1;
+        const volumeKeyframes = [];
+        const dur = this.duration;
+        for (const raw of this.spec.keyframes ?? []) {
+          const kf = normalizeKeyframe(raw, dur);
+          const set = kf.set;
+          const to = kf.to;
+          const from = kf.from;
+          if (kf.kind === "set" && set && "volume" in set) {
+            volumeKeyframes.push({ time: baseTime + this.at + kf.at, value: set.volume });
+          } else if (kf.kind === "to" && to && "volume" in to) {
+            volumeKeyframes.push({ time: baseTime + this.at + kf.at + kf.duration, value: to.volume });
+          } else if (kf.kind === "fromTo" && to && "volume" in to) {
+            volumeKeyframes.push({ time: baseTime + this.at + kf.at, value: from?.volume ?? initialVolume });
+            volumeKeyframes.push({ time: baseTime + this.at + kf.at + kf.duration, value: to.volume });
+          } else if (kf.kind === "from" && from && "volume" in from) {
+            volumeKeyframes.push({ time: baseTime + this.at + kf.at, value: from.volume });
+            volumeKeyframes.push({ time: baseTime + this.at + kf.at + kf.duration, value: initialVolume });
+          }
+        }
+        out.push({
+          buffer: this._audioBuffer,
+          loop: !!this.spec.loop,
+          start: baseTime + this.at,
+          end: baseTime + this.at + dur,
+          initialVolume,
+          volumeKeyframes
+        });
+      }
+      destroy() {
+        this._audioBuffer = null;
+      }
+    };
+  }
+});
+
+// src/core/FrameCache.ts
+var FrameCache;
+var init_FrameCache = __esm({
+  "src/core/FrameCache.ts"() {
+    FrameCache = class {
+      sink;
+      capacity;
+      cache = /* @__PURE__ */ new Map();
+      _pending = /* @__PURE__ */ new Map();
+      constructor(sink, options = {}) {
+        this.sink = sink;
+        this.capacity = options.capacity ?? 30;
+      }
+      _key(time) {
+        return Math.round(time * 1e3);
+      }
+      async getFrameAt(time) {
+        const key = this._key(time);
+        if (this.cache.has(key)) {
+          const v = this.cache.get(key);
+          this.cache.delete(key);
+          this.cache.set(key, v);
+          return v;
+        }
+        const pending = this._pending.get(key);
+        if (pending) return pending;
+        const promise = this._fetch(time);
+        this._pending.set(key, promise);
+        try {
+          const frame = await promise;
+          if (frame) {
+            if (this.cache.has(key)) {
+              frame.close?.();
+              const existing = this.cache.get(key);
+              this.cache.delete(key);
+              this.cache.set(key, existing);
+              return existing;
+            }
+            this.cache.set(key, frame);
+            this._evictIfNeeded();
+          }
+          return frame;
+        } finally {
+          this._pending.delete(key);
+        }
+      }
+      async _fetch(time) {
+        try {
+          const sample = await this.sink.getSample(time);
+          if (!sample) return null;
+          const frame = sample.toVideoFrame();
+          sample.close?.();
+          return frame;
+        } catch (err) {
+          const isTransient = err instanceof DOMException && (err.name === "EncodingError" || err.name === "NotSupportedError");
+          if (isTransient) {
+            console.debug("pixi-effects: transient video decode failure at", time, "s \u2014", err.name);
+          } else {
+            console.warn("pixi-effects: video frame decode failed at", time, "s \u2014", err);
+          }
+          return null;
+        }
+      }
+      _evictIfNeeded() {
+        while (this.cache.size > this.capacity) {
+          const oldestKey = this.cache.keys().next().value;
+          if (oldestKey === void 0) break;
+          const oldestFrame = this.cache.get(oldestKey);
+          oldestFrame?.close?.();
+          this.cache.delete(oldestKey);
+        }
+      }
+      dispose() {
+        for (const f of this.cache.values()) f?.close?.();
+        this.cache.clear();
+        this._pending.clear();
+      }
+    };
+  }
+});
+var VideoSequence;
+var init_Video = __esm({
+  "src/sequences/Video.ts"() {
+    init_Base();
+    init_FrameCache();
+    VideoSequence = class extends Sequence {
+      _sourceDuration = 0;
+      _audioBuffer = null;
+      _cache = null;
+      _canvas = null;
+      _ctx = null;
+      _drawSeq = 0;
+      async build() {
+        const data = await PIXI.Assets.get(this.spec.asset);
+        this._sourceDuration = data.duration;
+        this._audioBuffer = this.spec.audio !== false ? data.audioBuffer : null;
+        this._cache = new FrameCache(data.sink, { capacity: 30 });
+        const probeFrame = await this._cache.getFrameAt(0);
+        const w = probeFrame?.displayWidth ?? 1920;
+        const h = probeFrame?.displayHeight ?? 1080;
+        const canvas = document.createElement("canvas");
+        canvas.width = w;
+        canvas.height = h;
+        this._canvas = canvas;
+        this._ctx = canvas.getContext("2d", { alpha: true });
+        if (probeFrame && this._ctx) this._ctx.drawImage(probeFrame, 0, 0);
+        const texture = PIXI.Texture.from(canvas);
+        const sprite = new PIXI.Sprite({ texture, label: this.spec.name });
+        sprite.cullable = true;
+        this.target = sprite;
+        this.intrinsicWidth = w;
+        this.intrinsicHeight = h;
+        if (this.duration === void 0) {
+          this.duration = this.spec.duration ?? data.duration ?? this.root.duration;
+        }
+        let currentTime = 0;
+        const seq = this;
+        Object.defineProperty(sprite, "currentTime", {
+          get() {
+            return currentTime;
+          },
+          set(v) {
+            currentTime = v;
+            const mySeq = ++seq._drawSeq;
+            const lookup = seq.spec.loop && seq._sourceDuration > 0 ? v % seq._sourceDuration : v;
+            seq._cache.getFrameAt(lookup).then((frame) => {
+              if (mySeq !== seq._drawSeq) return;
+              if (!frame || !seq._ctx) return;
+              seq._ctx.drawImage(frame, 0, 0);
+              texture.source.update();
+            }).catch((err) => {
+              console.warn("pixi-effects: video frame draw failed:", err);
+            });
+          }
+        });
+        this.buildFilters();
+      }
+      bindTimeline(timeline) {
+        super.bindTimeline(timeline);
+        const playDuration = this.spec.loop ? this.duration : Math.min(this.duration, this._sourceDuration);
+        timeline.fromTo(
+          this.target,
+          { currentTime: 0 },
+          { currentTime: playDuration, duration: playDuration, ease: "none" },
+          this.at
+        );
+      }
+      collectAudio(out, baseTime) {
+        if (!this._audioBuffer) return;
+        const initialVolume = this.spec.volume ?? 1;
+        out.push({
+          buffer: this._audioBuffer,
+          loop: !!this.spec.loop,
+          start: baseTime + this.at,
+          end: baseTime + this.at + this.duration,
+          initialVolume,
+          volumeKeyframes: []
+        });
+      }
+      async awaitFrameAt(time) {
+        const mySeq = ++this._drawSeq;
+        const lookup = this.spec.loop && this._sourceDuration > 0 ? time % this._sourceDuration : time;
+        let frame = null;
+        try {
+          frame = await this._cache.getFrameAt(lookup);
+        } catch (err) {
+          console.warn("pixi-effects: awaitFrameAt failed at", time, "s \u2014", err);
+          return;
+        }
+        if (mySeq !== this._drawSeq) return;
+        if (frame && this._ctx) {
+          try {
+            this._ctx.drawImage(frame, 0, 0);
+            this.target.texture.source.update();
+          } catch (err) {
+            console.warn("pixi-effects: drawImage failed at", time, "s \u2014", err);
+          }
+        }
+      }
+      destroy() {
+        this._cache?.dispose();
+        this._cache = null;
+        super.destroy();
+      }
+    };
+  }
+});
+function seedGeometry(state, spec, scope) {
+  const keys = GEOMETRY_KEYS_BY_SHAPE[spec.shape];
+  for (const k of keys) {
+    const v = spec[k];
+    if (v !== void 0) state[k] = num(v, scope);
+  }
+}
+function seedStyle(state, initial, scope) {
+  for (const k of STYLE_KEYS) {
+    const v = initial[k];
+    if (v === void 0) continue;
+    state[k] = COLOR_KEYS.has(k) ? v : numOrZero(v, scope);
+  }
+}
+function stripLive(props, liveKeys) {
+  if (!props) return props;
+  const out = {};
+  let changed = false;
+  for (const k of Object.keys(props)) {
+    if (liveKeys.has(k)) {
+      changed = true;
+      continue;
+    }
+    out[k] = props[k];
+  }
+  return changed ? out : props;
+}
+function stripLiveKeyframe(kf, liveKeys) {
+  return {
+    ...kf,
+    set: stripLive(kf.set, liveKeys),
+    to: stripLive(kf.to, liveKeys),
+    from: stripLive(kf.from, liveKeys)
+  };
+}
+function pickLive(props, liveKeys) {
+  if (!props) return null;
+  const out = {};
+  let any = false;
+  for (const k of Object.keys(props)) {
+    if (liveKeys.has(k)) {
+      out[k] = props[k];
+      any = true;
+    }
+  }
+  return any ? out : null;
+}
+function resolveLiveValue(key, value, scope) {
+  if (COLOR_KEYS.has(key)) return value;
+  return numOrZero(value, scope);
+}
+function applyState(g, s) {
+  if (s.fillColor !== void 0) {
+    g.fill({ color: s.fillColor, alpha: s.fillAlpha });
+  }
+  if (s.strokeColor !== void 0 && s.strokeWidth > 0) {
+    g.stroke({ color: s.strokeColor, alpha: s.strokeAlpha, width: s.strokeWidth });
+  }
+}
+function drawRectFromState(g, s) {
+  const w = s.width ?? 0;
+  const h = s.height ?? 0;
+  const r = s.cornerRadius ?? 0;
+  const ax = s.anchorX ?? 0.5;
+  const ay = s.anchorY ?? 0.5;
+  const x = 0 - ax * w;
+  const y = 0 - ay * h;
+  if (r > 0) g.roundRect(x, y, w, h, r);
+  else g.rect(x, y, w, h);
+}
+function drawCircleFromState(g, s) {
+  const r = s.radius ?? 0;
+  const ax = s.anchorX ?? 0.5;
+  const ay = s.anchorY ?? 0.5;
+  g.circle((0.5 - ax) * 2 * r, (0.5 - ay) * 2 * r, r);
+}
+function drawEllipseFromState(g, s) {
+  const rx = s.radiusX ?? 0;
+  const ry = s.radiusY ?? 0;
+  const ax = s.anchorX ?? 0.5;
+  const ay = s.anchorY ?? 0.5;
+  g.ellipse((0.5 - ax) * 2 * rx, (0.5 - ay) * 2 * ry, rx, ry);
+}
+function makeLineDraw(spec, scope) {
+  const fx = num(spec.from[0], scope);
+  const fy = num(spec.from[1], scope);
+  const tx = num(spec.to[0], scope);
+  const ty = num(spec.to[1], scope);
+  return (g) => {
+    g.moveTo(fx, fy);
+    g.lineTo(tx, ty);
+  };
+}
+function makePolygonDraw(spec, scope) {
+  if (spec.points.length === 0) return () => {
+  };
+  const flat = [];
+  for (const [x, y] of spec.points) flat.push(num(x, scope), num(y, scope));
+  const closed = !spec.open;
+  return (g) => {
+    g.poly(flat, closed);
+  };
+}
+function makePathDraw(spec) {
+  return (g) => {
+    g.path(new PIXI.GraphicsPath(spec.d));
+  };
+}
+function makeDrawGeometry(spec, scope, state) {
+  const stateDrawer = STATE_DRAWERS[spec.shape];
+  if (stateDrawer) return (g) => stateDrawer(g, state);
+  switch (spec.shape) {
+    case "line":
+      return makeLineDraw(spec, scope);
+    case "polygon":
+      return makePolygonDraw(spec, scope);
+    case "path":
+      return makePathDraw(spec);
+  }
+  return () => {
+  };
+}
+function bindLiveKeyframes(timeline, state, liveKeys, keyframes, parentDuration, scope, offset, colorSpace) {
+  for (const kf of keyframes) {
+    const at = offset + resolveAt(kf.at, parentDuration);
+    const duration = kf.duration ?? 0;
+    const ease = kf.ease ?? "none";
+    if (kf.set) {
+      const live = pickLive(kf.set, liveKeys);
+      if (live) {
+        for (const [k, v] of Object.entries(live)) {
+          const resolved = resolveLiveValue(k, v, scope);
+          timeline.call(() => {
+            state[k] = resolved;
+          }, [], at);
+        }
+      }
+    }
+    const fromLive = pickLive(kf.from, liveKeys);
+    const toLive = pickLive(kf.to, liveKeys);
+    const allKeys = /* @__PURE__ */ new Set([
+      ...fromLive ? Object.keys(fromLive) : [],
+      ...toLive ? Object.keys(toLive) : []
+    ]);
+    for (const k of allKeys) {
+      const key = k;
+      const fromRaw = fromLive?.[key];
+      const toRaw = toLive?.[key];
+      const fromValue = fromRaw !== void 0 ? resolveLiveValue(key, fromRaw, scope) : void 0;
+      const toValue = toRaw !== void 0 ? resolveLiveValue(key, toRaw, scope) : void 0;
+      tweenLiveKey(timeline, state, key, fromValue, toValue, duration, ease, at, colorSpace);
+    }
+  }
+}
+function tweenLiveKey(timeline, state, key, fromValue, toValue, duration, ease, at, colorSpace) {
+  if (COLOR_KEYS.has(key) && toValue !== void 0) {
+    tweenColor(
+      timeline,
+      state,
+      key,
+      fromValue,
+      toValue,
+      duration,
+      ease,
+      at,
+      colorSpace
+    );
+  } else if (toValue !== void 0) {
+    if (fromValue !== void 0) {
+      timeline.fromTo(state, { [key]: fromValue }, { [key]: toValue, duration, ease }, at);
+    } else {
+      timeline.to(state, { [key]: toValue, duration, ease }, at);
+    }
+  }
+}
+function num(v, scope) {
+  if (typeof v === "number") return v;
+  if (isExpr(v)) return evaluateExpr(v, scope);
+  const parsed = parseFloat(v);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+function numOrZero(v, scope) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") return num(v, scope);
+  return 0;
+}
+var STYLE_KEYS, COLOR_KEYS, GEOMETRY_KEYS_BY_SHAPE, ANCHORED_SHAPES, ShapeSequence, STATE_DRAWERS;
+var init_Shape = __esm({
+  "src/sequences/Shape.ts"() {
+    init_Base();
+    init_Parser();
+    init_Timeline();
+    init_colorTween();
+    STYLE_KEYS = ["fillColor", "fillAlpha", "strokeColor", "strokeAlpha", "strokeWidth"];
+    COLOR_KEYS = /* @__PURE__ */ new Set(["fillColor", "strokeColor"]);
+    GEOMETRY_KEYS_BY_SHAPE = {
+      rect: ["width", "height", "cornerRadius", "anchorX", "anchorY"],
+      circle: ["radius", "anchorX", "anchorY"],
+      ellipse: ["radiusX", "radiusY", "anchorX", "anchorY"],
+      line: [],
+      polygon: [],
+      path: []
+    };
+    ANCHORED_SHAPES = /* @__PURE__ */ new Set(["rect", "circle", "ellipse"]);
+    ShapeSequence = class extends Sequence {
+      _state = {
+        fillColor: void 0,
+        fillAlpha: 1,
+        strokeColor: void 0,
+        strokeAlpha: 1,
+        strokeWidth: 0
+      };
+      // Closure that draws the path commands for this shape kind from the
+      // (possibly tweened) `_state`. Bound once at build; called on every frame
+      // by `Container.onRender`.
+      _drawGeometry = () => {
+      };
+      _liveKeys = new Set(STYLE_KEYS);
+      async build() {
+        const graphics = new PIXI.Graphics({ label: this.spec.name });
+        graphics.cullable = true;
+        this.target = graphics;
+        if (this.duration === void 0) {
+          this.duration = this.parent?.duration ?? this.root.duration;
+        }
+        const scope = this.scope();
+        const geomKeys = GEOMETRY_KEYS_BY_SHAPE[this.spec.shape];
+        for (const k of geomKeys) this._liveKeys.add(k);
+        seedGeometry(this._state, this.spec, scope);
+        seedStyle(this._state, this.spec.initial ?? {}, scope);
+        this._drawGeometry = makeDrawGeometry(this.spec, scope, this._state);
+        this._drawGeometry(graphics);
+        applyState(graphics, this._state);
+        const bounds = graphics.getLocalBounds();
+        this.intrinsicWidth = bounds.width;
+        this.intrinsicHeight = bounds.height;
+        if (!ANCHORED_SHAPES.has(this.spec.shape)) {
+          graphics.pivot.set(bounds.x + bounds.width / 2, bounds.y + bounds.height / 2);
+        }
+        graphics.onRender = () => {
+          graphics.clear();
+          this._drawGeometry(graphics);
+          applyState(graphics, this._state);
+        };
+        this.buildFilters();
+      }
+      bindTimeline(timeline, offset = 0) {
+        if (!this.target) return;
+        const scope = this.scope();
+        const initial = stripLive(this.spec.initial, this._liveKeys);
+        const keyframes = this.spec.keyframes ? this.spec.keyframes.map((kf) => stripLiveKeyframe(kf, this._liveKeys)) : void 0;
+        applyInitial(this.target, initial, scope);
+        applyKeyframes(timeline, this.target, keyframes, this.duration, scope, [], offset);
+        const colorSpace = this.spec.colorSpace ?? "rgb";
+        bindLiveKeyframes(timeline, this._state, this._liveKeys, this.spec.keyframes ?? [], this.duration, scope, offset, colorSpace);
+        const startTime = offset + this.at;
+        const endTime = startTime + this.duration;
+        this.target.renderable = startTime <= 0;
+        timeline.set(this.target, { renderable: true }, startTime);
+        timeline.set(this.target, { renderable: false }, endTime);
+      }
+    };
+    STATE_DRAWERS = {
+      rect: drawRectFromState,
+      circle: drawCircleFromState,
+      ellipse: drawEllipseFromState
+    };
+  }
+});
+
+// src/core/Composition.ts
+async function getCompositionSequence() {
+  if (!_CompositionSequence) {
+    _CompositionSequence = (await Promise.resolve().then(() => (init_Composition2(), Composition_exports))).CompositionSequence;
+  }
+  return _CompositionSequence;
+}
+async function buildSequenceTree(specs, parent, root) {
+  const out = [];
+  for (const spec of specs) {
+    let Cls = staticTypes[spec.type];
+    if (!Cls && spec.type === "composition") {
+      Cls = await getCompositionSequence();
+    }
+    if (!Cls) {
+      console.warn(`pixi-effects: unknown sequence type "${spec.type}"`);
+      continue;
+    }
+    const seq = new Cls(spec, parent, root);
+    await seq.build();
+    if (seq.duration === void 0) {
+      seq.duration = parent?.duration ?? root.duration;
+    }
+    out.push(seq);
+  }
+  return out;
+}
+var _CompositionSequence, staticTypes;
+var init_Composition = __esm({
+  "src/core/Composition.ts"() {
+    init_Image();
+    init_Text();
+    init_Audio();
+    init_Video();
+    init_Shape();
+    _CompositionSequence = null;
+    staticTypes = {
+      image: ImageSequence,
+      text: TextSequence,
+      audio: AudioSequence,
+      video: VideoSequence,
+      shape: ShapeSequence
+    };
+  }
+});
+
+// src/sequences/Composition.ts
+var Composition_exports = {};
+__export(Composition_exports, {
+  CompositionSequence: () => CompositionSequence
+});
+var CompositionSequence;
+var init_Composition2 = __esm({
+  "src/sequences/Composition.ts"() {
+    init_Base();
+    init_Composition();
+    CompositionSequence = class extends Sequence {
+      _innerContainer = null;
+      _compositionShape = null;
+      _children = [];
+      async build() {
+        const width = this.spec.width ?? this.parent?.width ?? this.root.width;
+        const height = this.spec.height ?? this.parent?.height ?? this.root.height;
+        if (this.duration === void 0) {
+          this.duration = this.spec.duration ?? this.parent?.duration ?? this.root.duration;
+        }
+        const wrapper = new PIXI.Container();
+        wrapper.cullable = true;
+        wrapper.cullableChildren = true;
+        wrapper.cullArea = new PIXI.Rectangle(0, 0, width, height);
+        const inner = new PIXI.Container();
+        inner.cullable = true;
+        inner.cullableChildren = true;
+        wrapper.addChild(inner);
+        this.target = wrapper;
+        this.intrinsicWidth = width;
+        this.intrinsicHeight = height;
+        this._innerContainer = inner;
+        this._compositionShape = { width, height, duration: this.duration };
+        this._children = await buildSequenceTree(
+          this.spec.sequences ?? [],
+          this._compositionShape,
+          this.root
+        );
+        for (const child of this._children) {
+          if (child.target) inner.addChild(child.target);
+          const maskSpec = child.spec.mask;
+          if (maskSpec && child.target) {
+            const built = await buildSequenceTree([maskSpec], this._compositionShape, this.root);
+            const maskSeq = built[0];
+            if (maskSeq?.target) {
+              inner.addChild(maskSeq.target);
+              const inverse = child.spec.maskInverted ?? false;
+              const t = child.target;
+              if (typeof t.setMask === "function") {
+                t.setMask({ mask: maskSeq.target, inverse });
+              } else {
+                t.mask = maskSeq.target;
+              }
+              child.maskSequence = maskSeq;
+            }
+          }
+        }
+        this.buildFilters();
+      }
+      bindTimeline(timeline, offset = 0) {
+        super.bindTimeline(timeline, offset);
+        const childOffset = offset + this.at;
+        for (const child of this._children) {
+          child.bindTimeline(timeline, childOffset);
+          child.maskSequence?.bindTimeline(timeline, childOffset);
+        }
+      }
+      collectAudio(out, baseTime) {
+        super.collectAudio(out, baseTime);
+        const childBase = baseTime + this.at;
+        for (const child of this._children) child.collectAudio(out, childBase);
+      }
+      destroy() {
+        for (const c of this._children) c.destroy();
+        super.destroy();
+      }
+    };
+  }
+});
+var registered = false;
+function ensureLoadersRegistered(audioContext) {
+  if (registered) return;
+  registered = true;
+  PIXI.extensions.add({
+    extension: { type: PIXI.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 };
+    }
+  });
+  PIXI.extensions.add({
+    extension: { type: PIXI.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 mediabunny.Input({ source: new mediabunny.BlobSource(blob), formats: mediabunny.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 mediabunny.Output({ format: new mediabunny.WavOutputFormat(), target: new mediabunny.BufferTarget() });
+          const conv = await mediabunny.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 mediabunny.VideoSampleSink(videoTrack)
+      };
+    }
+  });
+}
+async function loadAssetBundle(assets, audioContext) {
+  ensureLoadersRegistered(audioContext);
+  const bundle = assets.map((a) => ({ alias: a.name, src: a.src }));
+  PIXI.Assets.addBundle("pixi-effects", bundle);
+  return await PIXI.Assets.loadBundle("pixi-effects");
+}
+
+// src/core/Movie.ts
+init_Composition2();
+
+// src/core/AudioMixer.ts
+async function mixdown(audios, totalDuration, sampleRate = 44100) {
+  if (audios.length === 0) return null;
+  const ctx = new OfflineAudioContext(2, Math.ceil(sampleRate * totalDuration), sampleRate);
+  for (const a of audios) {
+    const src = ctx.createBufferSource();
+    src.buffer = a.buffer;
+    src.loop = !!a.loop;
+    const gain = ctx.createGain();
+    gain.gain.setValueAtTime(a.initialVolume ?? 1, a.start);
+    for (const kf of a.volumeKeyframes ?? []) {
+      gain.gain.linearRampToValueAtTime(kf.value, kf.time);
+    }
+    src.connect(gain).connect(ctx.destination);
+    src.start(a.start);
+    src.stop(a.end);
+  }
+  return await ctx.startRendering();
+}
+var VIDEO_CODEC_BY_FORMAT = {
+  mp4: "avc",
+  mov: "avc",
+  webm: "vp9",
+  mkv: "vp9"
+};
+var AUDIO_CODEC_BY_FORMAT = {
+  mp4: "aac",
+  mov: "aac",
+  webm: "opus",
+  mkv: "opus"
+};
+var qualityMap = {
+  "very-low": mediabunny.QUALITY_VERY_LOW,
+  "low": mediabunny.QUALITY_LOW,
+  "medium": mediabunny.QUALITY_MEDIUM,
+  "high": mediabunny.QUALITY_HIGH,
+  "very-high": mediabunny.QUALITY_VERY_HIGH
+};
+function makeOutputFormat(name) {
+  switch (name) {
+    case "mp4":
+      return new mediabunny.Mp4OutputFormat({ fastStart: "in-memory" });
+    case "mov":
+      return new mediabunny.MovOutputFormat({ fastStart: "in-memory" });
+    case "webm":
+      return new mediabunny.WebMOutputFormat();
+    case "mkv":
+      return new mediabunny.MkvOutputFormat();
+  }
+}
+async function exportFrames(movie, options = {}) {
+  const fmt = options.format ?? "mp4";
+  const opts = {
+    format: fmt,
+    video: {
+      codec: options.video?.codec ?? VIDEO_CODEC_BY_FORMAT[fmt],
+      bitrate: qualityMap[options.video?.bitrate ?? "high"] ?? mediabunny.QUALITY_HIGH
+    },
+    audio: {
+      codec: options.audio?.codec ?? AUDIO_CODEC_BY_FORMAT[fmt],
+      bitrate: qualityMap[options.audio?.bitrate ?? "high"] ?? mediabunny.QUALITY_HIGH
+    }
+  };
+  const output = new mediabunny.Output({
+    format: makeOutputFormat(opts.format),
+    target: new mediabunny.BufferTarget()
+  });
+  const canvasSource = new mediabunny.CanvasSource(movie.app.canvas, {
+    codec: opts.video.codec,
+    bitrate: opts.video.bitrate
+  });
+  output.addVideoTrack(canvasSource, { frameRate: movie.frameRate });
+  if (movie.audioBuffer) {
+    const audioSource = new mediabunny.AudioBufferSource({
+      codec: opts.audio.codec,
+      bitrate: opts.audio.bitrate
+    });
+    output.addAudioTrack(audioSource);
+    await output.start();
+    await audioSource.add(movie.audioBuffer);
+    await audioSource.close();
+  } else {
+    await output.start();
+  }
+  movie.app.ticker.stop();
+  const keyframeIntervalFrames = Math.max(1, Math.round(2 * movie.frameRate));
+  try {
+    for (let frame = 0; frame <= movie.totalFrames; frame++) {
+      await movie.gotoFrame(frame, true);
+      const isKey = frame === 0 || frame % keyframeIntervalFrames === 0;
+      const addOpts = isKey ? { keyFrame: true } : void 0;
+      await canvasSource.add(frame / movie.frameRate, 1 / movie.frameRate, addOpts);
+      const progress = Math.floor(frame / movie.totalFrames * 100);
+      movie.emit("progress", { progress, frame, totalFrames: movie.totalFrames });
+    }
+    await canvasSource.close();
+    await output.finalize();
+    return new Blob([output.target.buffer], { type: output.format.mimeType });
+  } finally {
+    movie.app.ticker.start();
+  }
+}
+
+// src/core/Transitions.ts
+init_Timeline();
+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_FRAGMENT2 = `
+in vec2 vTextureCoord;
+uniform sampler2D uTexture;
+uniform vec4 uInputSize;     // PIXI-bound: xy = sprite render texture size (with padding)
+uniform vec4 uInputClamp;    // PIXI-bound: xy = min uv of unpadded content, zw = max uv
+uniform vec4 uOutputFrame;   // PIXI-bound: xy = sprite top-left on output, zw = bbox size in px
+uniform 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_SOURCE2 = `
+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 PIXI.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: PIXI.GlProgram.from({
+        vertex: PIXI.defaultFilterVert,
+        fragment: GL_FRAGMENT2,
+        name: "transition-mask-filter"
+      }),
+      gpuProgram: PIXI.GpuProgram.from({
+        vertex: { source: WGSL_SOURCE2, entryPoint: "mainVertex" },
+        fragment: { source: WGSL_SOURCE2, entryPoint: "mainFragment" }
+      }),
+      resources: {
+        transitionUniforms: new PIXI.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;
+  }
+};
+
+// src/core/Transitions.ts
+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 parentDuration = out.duration ?? Infinity;
+  const compW = out.width;
+  const compH = out.height;
+  const masksParticipants = /* @__PURE__ */ new Set();
+  for (const t of transitions) {
+    if (t.kind === "wipe" || t.kind === "iris" || t.kind === "dissolve" || t.kind === "zoom") {
+      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 || tEnd > fromEnd) {
+      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 || tEnd > toEnd) {
+      throw new Error(`pixi-effects: ${tag} window [${tStart}, ${tEnd}] is not covered by \`to\` "${t.to}" (lives [${toStart}, ${toEnd}], so it starts at ${toStart})`);
+    }
+    switch (t.kind) {
+      case "crossfade":
+        expandCrossfade(out, t, fromEntry.seq, toEntry.seq);
+        break;
+      case "wipe":
+        expandMask(out, t, fromEntry.seq, toEntry.seq, i, wipeMode(t.direction), t.smoothing);
+        break;
+      case "iris":
+        expandMask(out, t, fromEntry.seq, toEntry.seq, i, t.mode === "out" ? "iris-out" : "iris-in", t.smoothing);
+        break;
+      case "slide":
+        expandSlide(out, t, fromEntry.seq, toEntry.seq);
+        break;
+      case "dip":
+        expandDip(out, t, fromEntry.seq, toEntry.seq);
+        break;
+      case "zoom":
+        expandZoom(out, t, fromEntry.seq, toEntry.seq);
+        break;
+      case "dissolve":
+        expandDissolve(out, t, fromEntry.seq, toEntry.seq, i);
+        break;
+    }
+  }
+  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;
+  return {
+    type: "composition",
+    name: seq.name,
+    at: seq.at,
+    duration: seq.duration,
+    width: compW,
+    height: compH,
+    initial: centring,
+    sequences: [inner]
+  };
+}
+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;
+}
+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/Movie.ts
+PIXI.extensions.add(PIXI.CullerPlugin);
+gsap.gsap.registerPlugin(PixiPlugin.PixiPlugin);
+PixiPlugin.PixiPlugin.registerPIXI(PIXI__namespace);
+var Movie = class {
+  _events = {};
+  _initState = "idle";
+  app = null;
+  timeline = null;
+  audioBuffer = null;
+  audioSource = null;
+  gainNode = null;
+  _volume = 1;
+  _muted = false;
+  isPlaying = false;
+  currentFrame = 0;
+  totalFrames = 0;
+  width = 0;
+  height = 0;
+  duration = 0;
+  frameRate = 30;
+  background = "#000000";
+  _audioContext = null;
+  _rootSequence = null;
+  _rootContainer = null;
+  _raf = 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";
+  }
+  _ensureAudioContext() {
+    if (!this._audioContext) {
+      const Ctx = window.AudioContext ?? window.webkitAudioContext;
+      this._audioContext = new Ctx();
+    }
+    return this._audioContext;
+  }
+  async init(options = {}) {
+    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);
+      this.background = options.background ?? "#000000";
+      this.timeline = gsap.gsap.timeline({ paused: true, defaults: { ease: "none" } });
+      this.timeline.add(gsap.gsap.to({}, { duration: 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 PIXI.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 PIXI.Application();
+        await this.app.init({ ...baseAppOptions, preference: "webgl" });
+      }
+      const root = new PIXI.Container();
+      root.cullable = true;
+      root.cullableChildren = true;
+      root.cullArea = new PIXI.Rectangle(0, 0, this.width, this.height);
+      this.app.stage.addChild(root);
+      this._rootContainer = root;
+      const audioContext = this._ensureAudioContext();
+      await loadAssetBundle(options.assets ?? [], audioContext);
+      const rootShape = { width: this.width, height: this.height, duration: this.duration };
+      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;
+      const userComposition = seededComposition ? expandTransitions(seededComposition) : void 0;
+      const rootSeqSpec = {
+        type: "composition",
+        width: this.width,
+        height: this.height,
+        duration: this.duration,
+        ...userComposition
+      };
+      const composition = new CompositionSequence(rootSeqSpec, null, rootShape);
+      await composition.build();
+      this._rootSequence = composition;
+      if (composition.target) root.addChild(composition.target);
+      composition.bindTimeline(this.timeline);
+      const audios = [];
+      composition.collectAudio(audios, 0);
+      if (audios.length > 0) {
+        this.audioBuffer = await mixdown(audios, this.duration, audioContext.sampleRate);
+      }
+      this.timeline.progress(1).progress(0);
+      this.app.renderer.render({ container: this.app.stage });
+      this._initState = "ready";
+      this.emit("ready");
+    } catch (err) {
+      try {
+        await this.destroy();
+      } catch (cleanupErr) {
+        console.warn("pixi-effects: cleanup after init failure also threw:", cleanupErr);
+      }
+      throw err;
+    }
+  }
+  async gotoFrame(frame, force = false) {
+    if (this._initState !== "ready") return;
+    if (!force && this.currentFrame === frame) return;
+    this.currentFrame = Math.max(0, Math.min(frame, this.totalFrames));
+    this.timeline.time(this.currentFrame / this.frameRate);
+    await this._awaitVideoFrames();
+    this.app?.renderer?.render({ container: this.app.stage });
+    this.emit("frame", { frame: this.currentFrame, totalFrames: this.totalFrames });
+  }
+  async _awaitVideoFrames() {
+    if (!this._rootSequence) return;
+    const collected = [];
+    collectVideoSequences(this._rootSequence, collected);
+    const t = this.currentFrame / this.frameRate;
+    await Promise.all(collected.map((v) => {
+      const local = t - v.at;
+      if (local < 0 || local > (v.duration ?? 0)) return Promise.resolve();
+      return v.awaitFrameAt(local);
+    }));
+  }
+  play() {
+    if (this._initState !== "ready") return;
+    if (this.currentFrame >= this.totalFrames) this.currentFrame = 0;
+    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 (frame <= this.totalFrames) {
+        inFlight = true;
+        this.gotoFrame(frame).catch((err) => {
+          console.warn("pixi-effects: gotoFrame failed during playback:", err);
+        }).finally(() => {
+          inFlight = false;
+        });
+        this._raf = requestAnimationFrame(tick);
+      } else {
+        this.pause();
+        this.gotoFrame(this.totalFrames).catch((err) => {
+          console.warn("pixi-effects: final gotoFrame failed:", err);
+        });
+      }
+    };
+    this._raf = requestAnimationFrame(tick);
+    if (this.audioBuffer) {
+      const ctx = this._ensureAudioContext();
+      this.audioSource = ctx.createBufferSource();
+      this.audioSource.buffer = this.audioBuffer;
+      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, this.currentFrame / this.frameRate);
+    }
+  }
+  pause() {
+    const wasPlaying = this.isPlaying;
+    this.isPlaying = false;
+    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");
+  }
+  set volume(v) {
+    this._volume = Math.max(0, Math.min(1, v));
+    if (this.gainNode) this.gainNode.gain.value = this._muted ? 0 : this._volume;
+  }
+  get volume() {
+    return this._volume;
+  }
+  set muted(v) {
+    this._muted = !!v;
+    if (this.gainNode) this.gainNode.gain.value = this._muted ? 0 : this._volume;
+  }
+  get muted() {
+    return this._muted;
+  }
+  toggleMute() {
+    this.muted = !this.muted;
+    return this.muted;
+  }
+  async render(options) {
+    return await exportFrames(this, options);
+  }
+  async destroy() {
+    safeRun(() => this.pause());
+    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;
+    safeRun(() => this._audioContext?.close().catch(() => {
+    }));
+    this._audioContext = null;
+    this._initState = "destroyed";
+  }
+};
+function safeRun(fn) {
+  try {
+    fn();
+  } catch (e) {
+    console.warn("pixi-effects: cleanup step threw, continuing:", e);
+  }
+}
+function collectVideoSequences(seq, out) {
+  if (typeof seq.awaitFrameAt === "function") {
+    out.push(seq);
+  }
+  for (const child of seq._children ?? []) {
+    collectVideoSequences(child, out);
+  }
+}
+
+// src/presets/kenBurns.ts
+function kenBurns(opts) {
+  const {
+    asset,
+    name,
+    at,
+    duration,
+    fit = "cover",
+    ease = "sine.inOut"
+  } = opts;
+  const baseScale = fit;
+  const baseAt = at ?? 0;
+  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/2 - (${baseScale}) * ${fromZ} * w * ${0.5 - origin[0]}`;
+    const yExpr = `H/2 - (${baseScale}) * ${fromZ} * h * ${0.5 - origin[1]}`;
+    initial = {
+      x: xExpr,
+      y: yExpr,
+      pivotX: pivotXExpr,
+      pivotY: pivotYExpr,
+      scale: initialScale
+    };
+    keyframes = [
+      { at: baseAt, 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: baseAt + 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: baseAt, 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));
+}
+
+exports.Movie = Movie;
+exports.kenBurns = kenBurns;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map