pixi-effects 0.48.2 → 0.50.0

package/dist/{chunk-Z3DM4ETD.cjs → chunk-VVUSZVP7.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkNGJXVJB7_cjs = require('./chunk-NGJXVJB7.cjs');
+var chunk3FCDRLW3_cjs = require('./chunk-3FCDRLW3.cjs');
 var chunkDOLTCXCL_cjs = require('./chunk-DOLTCXCL.cjs');
 var pixi_js = require('pixi.js');
 
@@ -514,9 +514,9 @@ var PureTimeline = class _PureTimeline {
     };
     const ends = given(vars);
     const starts = fromVars ? given(fromVars) : /* @__PURE__ */ new Map();
-    const ids = kind === "fromTo" ? [.../* @__PURE__ */ new Set([...starts.keys(), ...ends.keys()])] : [...ends.keys()];
+    const ids2 = kind === "fromTo" ? [.../* @__PURE__ */ new Set([...starts.keys(), ...ends.keys()])] : [...ends.keys()];
     let lastAlpha;
-    for (const id of ids) {
+    for (const id of ids2) {
       const e = ends.get(id), f = starts.get(id);
       const acc = (e ?? f).acc;
       const ch = this.channel(t, acc);
@@ -1385,6 +1385,9 @@ var PIXI_SHORTHANDS = /* @__PURE__ */ new Set([
   "fillColor",
   "fillAlpha"
 ]);
+function routedProp(prop, value) {
+  return prop === "tint" ? { pixi: { tint: value } } : { [prop]: value };
+}
 function pixiwrap(props) {
   const out = {};
   const pixi = {};
@@ -1407,7 +1410,7 @@ function applyKeyframes(timeline, target, keyframes, parentDuration, scope, skip
     if (kf.kind === "set") {
       const resolved = normalizeProps(kf.set, scope, { skipKeys, relative: "allow" });
       const { rest, routed } = splitRouted(resolved, routers);
-      for (const r of routed) timeline.set(r.target, { [r.prop]: r.value }, at);
+      for (const r of routed) timeline.set(r.target, routedProp(r.prop, r.value), at);
       const { ownProps, filterProps } = partitionProps(rest);
       if (Object.keys(ownProps).length > 0) timeline.set(target, pixiwrap(ownProps), at);
       for (const [name, props] of Object.entries(filterProps)) {
@@ -1419,7 +1422,7 @@ function applyKeyframes(timeline, target, keyframes, parentDuration, scope, skip
       const resolved = normalizeProps(kf.to, scope, { skipKeys, relative: "allow" });
       const { rest, routed } = splitRouted(resolved, routers);
       for (const r of routed)
-        timeline.to(r.target, { [r.prop]: r.value, duration: kf.duration, ease: kf.ease, ...kf.loop }, at);
+        timeline.to(r.target, { ...routedProp(r.prop, r.value), duration: kf.duration, ease: kf.ease, ...kf.loop }, at);
       const { ownProps, filterProps } = partitionProps(rest);
       if (Object.keys(ownProps).length > 0)
         timeline.to(target, { ...pixiwrap(ownProps), duration: kf.duration, ease: kf.ease, ...kf.loop }, at);
@@ -1432,7 +1435,7 @@ function applyKeyframes(timeline, target, keyframes, parentDuration, scope, skip
       const resolved = normalizeProps(kf.from, scope, { skipKeys, relative: "allow" });
       const { rest, routed } = splitRouted(resolved, routers);
       for (const r of routed)
-        timeline.from(r.target, { [r.prop]: r.value, duration: kf.duration, ease: kf.ease, ...kf.loop }, at);
+        timeline.from(r.target, { ...routedProp(r.prop, r.value), duration: kf.duration, ease: kf.ease, ...kf.loop }, at);
       const { ownProps, filterProps } = partitionProps(rest);
       if (Object.keys(ownProps).length > 0)
         timeline.from(target, { ...pixiwrap(ownProps), duration: kf.duration, ease: kf.ease, ...kf.loop }, at);
@@ -1453,16 +1456,16 @@ function applyKeyframes(timeline, target, keyframes, parentDuration, scope, skip
         if (f) {
           timeline.fromTo(
             r.target,
-            { [r.prop]: f.value },
-            { [r.prop]: r.value, duration: kf.duration, ease: kf.ease, ...kf.loop },
+            routedProp(r.prop, f.value),
+            { ...routedProp(r.prop, r.value), duration: kf.duration, ease: kf.ease, ...kf.loop },
             at
           );
         } else {
-          timeline.to(r.target, { [r.prop]: r.value, duration: kf.duration, ease: kf.ease, ...kf.loop }, at);
+          timeline.to(r.target, { ...routedProp(r.prop, r.value), duration: kf.duration, ease: kf.ease, ...kf.loop }, at);
         }
       }
       for (const f of fromByKey.values())
-        timeline.from(f.target, { [f.prop]: f.value, duration: kf.duration, ease: kf.ease, ...kf.loop }, at);
+        timeline.from(f.target, { ...routedProp(f.prop, f.value), duration: kf.duration, ease: kf.ease, ...kf.loop }, at);
       const fromSplit = partitionProps(fromRouted.rest);
       const toSplit = partitionProps(toRouted.rest);
       const ownKeys = /* @__PURE__ */ new Set([...Object.keys(fromSplit.ownProps), ...Object.keys(toSplit.ownProps)]);
@@ -1495,7 +1498,7 @@ function applyInitial(target, initial, scope, skipKeys = [], routers) {
   if (!initial) return;
   const resolved = normalizeProps(initial, scope, { skipKeys, where: "initial" });
   const { rest, routed } = splitRouted(resolved, routers);
-  for (const r of routed) setNow(r.target, { [r.prop]: r.value });
+  for (const r of routed) setNow(r.target, routedProp(r.prop, r.value));
   const { ownProps, filterProps } = partitionProps(rest);
   if (Object.keys(ownProps).length > 0) setNow(target, pixiwrap(ownProps));
   for (const [name, props] of Object.entries(filterProps)) {
@@ -2976,7 +2979,7 @@ var TextSequence = class extends Sequence {
     if (this.spec.resolution !== void 0) {
       const r = this.spec.resolution;
       if (typeof r === "number" && r >= 1 && r <= 8) text.resolution = r;
-      else console.warn(`pixi-effects: ${chunkNGJXVJB7_cjs.describeLayer(this.spec)}: resolution must be a number from 1 to 8 (the text is drawn at that many times the pixels), got ${JSON.stringify(r)}: ignored`);
+      else console.warn(`pixi-effects: ${chunk3FCDRLW3_cjs.describeLayer(this.spec)}: resolution must be a number from 1 to 8 (the text is drawn at that many times the pixels), got ${JSON.stringify(r)}: ignored`);
     }
     this.target = text;
     this.intrinsicWidth = text.width;
@@ -2992,7 +2995,7 @@ var TextSequence = class extends Sequence {
         { skipKeys: STYLE_OPAQUE_KEYS }
       );
       const unset = Object.keys(resolved).filter((k) => resolved[k] === void 0);
-      if (unset.length) console.warn(`pixi-effects: ${chunkNGJXVJB7_cjs.describeLayer(this.spec)}: ${unset.map((k) => `style.${k}`).join(", ")} ${unset.length > 1 ? "are" : "is"} undefined (a variable that was never set?), so ${unset.length > 1 ? "they are" : "it is"} ignored and the default is used: omit the key instead`);
+      if (unset.length) console.warn(`pixi-effects: ${chunk3FCDRLW3_cjs.describeLayer(this.spec)}: ${unset.map((k) => `style.${k}`).join(", ")} ${unset.length > 1 ? "are" : "is"} undefined (a variable that was never set?), so ${unset.length > 1 ? "they are" : "it is"} ignored and the default is used: omit the key instead`);
       const outline = resolved.stroke;
       if (outline && typeof outline === "object" && !("join" in outline) && !("lineJoin" in outline)) resolved.stroke = { ...outline, join: "round" };
       for (const k of Object.keys(resolved)) {
@@ -3004,7 +3007,7 @@ var TextSequence = class extends Sequence {
     }
     const startFill = initialProps.fill;
     if (typeof startFill === "string" || typeof startFill === "number") text.style.fill = startFill;
-    validateGradientKeyframes(this.spec, chunkNGJXVJB7_cjs.describeLayer(this.spec), void 0, "text");
+    validateGradientKeyframes(this.spec, chunk3FCDRLW3_cjs.describeLayer(this.spec), void 0, "text");
     const gradientSpec = this.spec.fillGradient ?? initialProps.fillGradient;
     if (gradientSpec) {
       this._grad = { grad: gradStateFrom(gradientSpec) };
@@ -3040,7 +3043,7 @@ var TextSequence = class extends Sequence {
     bindTextKeyframes(timeline, keyframes, this.duration, origin, () => this._template, (t) => {
       this._template = t;
       refresh();
-    }, chunkNGJXVJB7_cjs.describeLayer(this.spec));
+    }, chunk3FCDRLW3_cjs.describeLayer(this.spec));
   }
 };
 function runSuperWithStrippedSpec(inst, strippedSpec, timeline, offset) {
@@ -3490,7 +3493,7 @@ var CameraSequence = class extends Sequence {
     carrier.fogColor = "#000000";
     carrier.fogAmount = 1;
     this.target = carrier;
-    const keys = chunkNGJXVJB7_cjs.collectPropKeys(this.spec);
+    const keys = chunk3FCDRLW3_cjs.collectPropKeys(this.spec);
     this.autoZ = !keys.has("z");
     this.dof = keys.has("focus") || keys.has("aperture");
     this.fog = keys.has("fogNear") || keys.has("fogFar") || keys.has("fogColor") || keys.has("fogAmount");
@@ -3811,7 +3814,7 @@ function resolveSpansStyle(style, scope, who, warn = defaultWarn) {
 var TEXT_ONLY = ["type", "spans", "text", "style", "format", "colorSpace", "fillGradient", "initial", "keyframes", "resolution"];
 var NOT_FOR_A_GROUP = ["fill", "text", "value", "fillGradient"];
 function expandSpans(spec, warn = defaultWarn, scope) {
-  const who = chunkNGJXVJB7_cjs.describeLayer(spec);
+  const who = chunk3FCDRLW3_cjs.describeLayer(spec);
   const s = spec;
   if (s.text !== void 0) warn(`pixi-effects: ${who}: "text" is ignored when the layer has spans: write the text as spans`);
   const style = resolveSpansStyle(s.style ?? {}, scope, who, warn);
@@ -3870,7 +3873,7 @@ var ImageSequence = class extends Sequence {
     const source = texture.source;
     if (source && !ORIGINAL_SCALE_MODE.has(source)) ORIGINAL_SCALE_MODE.set(source, source.scaleMode);
     const mode = this.spec.scaleMode;
-    if (mode !== void 0 && mode !== "nearest" && mode !== "linear") console.warn(`pixi-effects: ${chunkNGJXVJB7_cjs.describeLayer(this.spec)}: scaleMode "${String(mode)}" is not "nearest" or "linear": ignored`);
+    if (mode !== void 0 && mode !== "nearest" && mode !== "linear") console.warn(`pixi-effects: ${chunk3FCDRLW3_cjs.describeLayer(this.spec)}: scaleMode "${String(mode)}" is not "nearest" or "linear": ignored`);
     if (source) source.scaleMode = mode === "nearest" || mode === "linear" ? mode : ORIGINAL_SCALE_MODE.get(source);
     const sprite = new pixi_js.Sprite({ texture, label: this.spec.name });
     sprite.cullable = true;
@@ -3979,12 +3982,12 @@ var AudioSequence = class extends Sequence {
     const playable = this._remap && this._remap.timeKfs.length > 0 ? Infinity : (data.duration ?? Infinity) / constant;
     if (!spec.loop && Number.isFinite(playable) && this.duration > playable + 0.05) {
       console.warn(
-        `pixi-effects: ${chunkNGJXVJB7_cjs.describeLayer(spec)}: audio asset "${spec.asset}" plays for ${playable.toFixed(1)}s (${data.duration.toFixed(1)}s at speed ${constant}) but the layer lasts ${this.duration.toFixed(1)}s, so it goes silent after ${playable.toFixed(1)}s. Add loop: true, or shorten the layer's duration.`
+        `pixi-effects: ${chunk3FCDRLW3_cjs.describeLayer(spec)}: audio asset "${spec.asset}" plays for ${playable.toFixed(1)}s (${data.duration.toFixed(1)}s at speed ${constant}) but the layer lasts ${this.duration.toFixed(1)}s, so it goes silent after ${playable.toFixed(1)}s. Add loop: true, or shorten the layer's duration.`
       );
     }
   }
   async _buildSfx(spec) {
-    const who = chunkNGJXVJB7_cjs.describeLayer(spec);
+    const who = chunk3FCDRLW3_cjs.describeLayer(spec);
     const raw = spec;
     if (raw.asset !== void 0) console.warn(`pixi-effects: ${who}: has both asset and sfx \u2014 the sfx plays; remove one`);
     if (raw.loop) console.warn(`pixi-effects: ${who}: loop has no effect on an sfx \u2014 to repeat it, add one audio layer per hit (a JS loop)`);
@@ -4003,11 +4006,11 @@ var AudioSequence = class extends Sequence {
     });
   }
   async _buildMusic(spec) {
-    const who = chunkNGJXVJB7_cjs.describeLayer(spec);
+    const who = chunk3FCDRLW3_cjs.describeLayer(spec);
     const raw = spec;
     if (raw.asset !== void 0) console.warn(`pixi-effects: ${who}: has both asset and music \u2014 the music plays; remove one`);
     if (raw.sfx !== void 0) console.warn(`pixi-effects: ${who}: has both sfx and music \u2014 the music plays; remove one`);
-    const { resolveMusic, renderMusic, renderMusicAsync, musicLength, musicKey, summarizeMusic } = await import('./music-XQEPBIDT.cjs');
+    const { resolveMusic, renderMusic, renderMusicAsync, musicLength, musicKey, summarizeMusic } = await import('./music-OFVM3PYH.cjs');
     const music = resolveMusic(spec.music, who);
     if (!music) return;
     const natural = musicLength(music);
@@ -4038,7 +4041,7 @@ var AudioSequence = class extends Sequence {
     out.push({
       ...sourceMap ? { sourceMap } : {},
       ...this._audioBuffer ? { buffer: this._audioBuffer } : { synth: this._synth },
-      layer: chunkNGJXVJB7_cjs.describeLayer(this.spec),
+      layer: chunk3FCDRLW3_cjs.describeLayer(this.spec),
       source: this._source,
       ...this._music ? { music: this._music } : {},
       loop: !this._synth && !!this.spec.loop,
@@ -4580,7 +4583,7 @@ var VideoSequence = class extends Sequence {
     out.push({
       ...sourceMap ? { sourceMap } : {},
       buffer: this._audioBuffer,
-      layer: chunkNGJXVJB7_cjs.describeLayer(this.spec),
+      layer: chunk3FCDRLW3_cjs.describeLayer(this.spec),
       source: `video "${this.spec.asset}"`,
       loop: !!this.spec.loop,
       start: baseTime + this.at,
@@ -4890,20 +4893,20 @@ var ShapeSequence = class extends Sequence {
     for (const k of geomKeys) this._liveKeys.add(k);
     seedGeometry(this._state, this.spec, scope);
     seedStyle(this._state, this.spec.initial ?? {}, scope);
-    seedStrokeStyle(this._state, this.spec, this.spec.initial ?? {}, chunkNGJXVJB7_cjs.describeLayer(this.spec));
+    seedStrokeStyle(this._state, this.spec, this.spec.initial ?? {}, chunk3FCDRLW3_cjs.describeLayer(this.spec));
     if (this.spec.shape === "arc") {
       this._state.startAngle ??= 0;
       this._state.endAngle ??= 360;
       const top = this.spec, ini = this.spec.initial ?? {};
       if ("trimStart" in top || "trimEnd" in top || "trimStart" in ini || "trimEnd" in ini) {
-        console.warn(`pixi-effects: ${chunkNGJXVJB7_cjs.describeLayer(this.spec)}: trimStart / trimEnd do not apply to an arc: animate its endAngle (and startAngle) instead`);
+        console.warn(`pixi-effects: ${chunk3FCDRLW3_cjs.describeLayer(this.spec)}: trimStart / trimEnd do not apply to an arc: animate its endAngle (and startAngle) instead`);
       }
     } else {
       this._state.trimStart ??= 0;
       this._state.trimEnd ??= 1;
     }
     const gradientSpec = this.spec.fillGradient ?? this.spec.initial?.fillGradient;
-    validateGradientKeyframes(this.spec, chunkNGJXVJB7_cjs.describeLayer(this.spec));
+    validateGradientKeyframes(this.spec, chunk3FCDRLW3_cjs.describeLayer(this.spec));
     if (gradientSpec) {
       if (hasGradientKeys(this.spec.keyframes)) {
         this._grad = { grad: gradStateFrom(gradientSpec) };
@@ -4947,9 +4950,9 @@ var ShapeSequence = class extends Sequence {
   }
   /** The prepared morph between `d` and `morphTo`, or null (and a warning when the spec asked for one that cannot work). */
   _setupMorph() {
-    const who = chunkNGJXVJB7_cjs.describeLayer(this.spec);
+    const who = chunk3FCDRLW3_cjs.describeLayer(this.spec);
     const top = this.spec;
-    const wanted = this.spec.shape === "path" && (this._state.morph !== void 0 || chunkNGJXVJB7_cjs.collectPropKeys(this.spec).has("morph"));
+    const wanted = this.spec.shape === "path" && (this._state.morph !== void 0 || chunk3FCDRLW3_cjs.collectPropKeys(this.spec).has("morph"));
     if (this.spec.shape !== "path") {
       if ("morphTo" in top) console.warn(`pixi-effects: ${who}: morphTo only works on a path shape (shape: 'path'); ignored`);
       return null;
@@ -5585,7 +5588,7 @@ var ShaderSequence = class extends Sequence {
   }
   async build() {
     const spec = this.shaderSpec;
-    const who = chunkNGJXVJB7_cjs.describeLayer(spec);
+    const who = chunk3FCDRLW3_cjs.describeLayer(spec);
     for (const m of shaderProblems(spec)) console.warn(`pixi-effects: ${who}: ${m}`);
     if (this.duration === void 0) this.duration = this.parent?.duration ?? this.root.duration;
     const scope = buildScope(this, this.parent, this.root);
@@ -5629,7 +5632,7 @@ var ShaderSequence = class extends Sequence {
     const warn = (why) => {
       if (this.warnedPaths.has(path)) return;
       this.warnedPaths.add(path);
-      console.warn(`pixi-effects: ${chunkNGJXVJB7_cjs.describeLayer(this.spec)}: keyframe path uniforms.${path} ${why}; skipped`);
+      console.warn(`pixi-effects: ${chunk3FCDRLW3_cjs.describeLayer(this.spec)}: keyframe path uniforms.${path} ${why}; skipped`);
     };
     if (slot === void 0) {
       const guess = chunkDOLTCXCL_cjs.suggestName(name, Object.keys(this.carrier));
@@ -5664,7 +5667,7 @@ var ShaderSequence = class extends Sequence {
     this.failed = true;
     if (!this.warnedNoGl) {
       this.warnedNoGl = true;
-      console.warn(`pixi-effects: ${chunkNGJXVJB7_cjs.describeLayer(this.spec)}: this browser has no WebGL2, so the shader cannot run; the layer is drawn as a checkerboard`);
+      console.warn(`pixi-effects: ${chunk3FCDRLW3_cjs.describeLayer(this.spec)}: this browser has no WebGL2, so the shader cannot run; the layer is drawn as a checkerboard`);
     }
   }
   compile() {
@@ -5695,7 +5698,7 @@ var ShaderSequence = class extends Sequence {
       gl.deleteProgram(p);
       this.failed = true;
       this.prog = null;
-      console.warn(`pixi-effects: ${chunkNGJXVJB7_cjs.describeLayer(this.spec)}: the fragment shader did not compile (the line numbers are the lines of your code):
+      console.warn(`pixi-effects: ${chunk3FCDRLW3_cjs.describeLayer(this.spec)}: the fragment shader did not compile (the line numbers are the lines of your code):
 ${glslErrors(log).join("\n")}
 The layer is drawn as a checkerboard until it is fixed.`);
       return;
@@ -5774,10 +5777,14 @@ function resolveDim(v, scope) {
   if (typeof v === "number") return v;
   return evaluateExpr(v, scope);
 }
+
+// src/core/purity.ts
+var NOT_PURE = /\bMath\s*\.\s*random\s*\(|\bDate\s*\.\s*now\s*\(|\bperformance\s*\.\s*now\s*\(|\bnew\s+Date\s*\(/;
+
+// src/sequences/Canvas.ts
 var MAX_SIZE = 8192;
 var MIN_RESOLUTION = 0.25;
 var MAX_RESOLUTION = 4;
-var NOT_PURE = /\bMath\s*\.\s*random\s*\(|\bDate\s*\.\s*now\s*\(|\bperformance\s*\.\s*now\s*\(|\bnew\s+Date\s*\(/;
 function seeded(seed) {
   let a = seed >>> 0;
   return () => {
@@ -5822,7 +5829,7 @@ var CanvasSequence = class extends Sequence {
   }
   async build() {
     const spec = this.canvasSpec;
-    const who = chunkNGJXVJB7_cjs.describeLayer(spec);
+    const who = chunk3FCDRLW3_cjs.describeLayer(spec);
     if (this.duration === void 0) this.duration = this.parent?.duration ?? this.root.duration;
     const scope = buildScope(this, this.parent, this.root);
     this.layerW = this.size("width", spec.width, scope, this.parent?.width ?? this.root.width, who);
@@ -5907,7 +5914,7 @@ var CanvasSequence = class extends Sequence {
   say(why) {
     if (this.warnedDraw) return;
     this.warnedDraw = true;
-    console.warn(`pixi-effects: ${chunkNGJXVJB7_cjs.describeLayer(this.spec)}: ${why}`);
+    console.warn(`pixi-effects: ${chunk3FCDRLW3_cjs.describeLayer(this.spec)}: ${why}`);
   }
   info(local) {
     const duration = this.duration ?? 0;
@@ -5934,7 +5941,7 @@ var CanvasSequence = class extends Sequence {
     if (!this.warnedPaths.has(path)) {
       this.warnedPaths.add(path);
       const guess = chunkDOLTCXCL_cjs.suggestName(path.split(".")[0], Object.keys(this.carrier));
-      console.warn(`pixi-effects: ${chunkNGJXVJB7_cjs.describeLayer(this.spec)}: keyframe path params.${path} names no param "${path}"${guess ? `; did you mean "${guess}"?` : ""} (declare it in params with a starting value); skipped`);
+      console.warn(`pixi-effects: ${chunk3FCDRLW3_cjs.describeLayer(this.spec)}: keyframe path params.${path} names no param "${path}"${guess ? `; did you mean "${guess}"?` : ""} (declare it in params with a starting value); skipped`);
     }
     return null;
   }
@@ -6068,17 +6075,466 @@ var CanvasSequence = class extends Sequence {
   }
 };
 
+// src/core/setupValues.ts
+var SetupValues = class {
+  values = /* @__PURE__ */ new Map();
+  /** The value `target[prop]` has now, noted the first time only. */
+  note(target, prop) {
+    let props = this.values.get(target);
+    if (!props) {
+      props = /* @__PURE__ */ new Map();
+      this.values.set(target, props);
+    }
+    if (!props.has(prop)) props.set(prop, target[prop]);
+  }
+  /** For a layer that borrowed: a one-property stand-in for `target[prop]`, the noted value while `borrowed()`, the object itself after. */
+  view(target, prop, borrowed) {
+    this.note(target, prop);
+    const noted = () => this.values.get(target).get(prop);
+    let held = null;
+    const view = {};
+    Object.defineProperty(view, prop, {
+      enumerable: true,
+      get: () => borrowed() ? held ? held.v : noted() : target[prop],
+      set: (v) => {
+        if (borrowed()) held = { v };
+        else target[prop] = v;
+      }
+    });
+    return { target: view, prop };
+  }
+  /** The swap: every noted property back to the value setup left. */
+  restore() {
+    for (const [target, props] of this.values) {
+      for (const [prop, v] of props) {
+        try {
+          target[prop] = v;
+        } catch {
+        }
+      }
+    }
+  }
+};
+
+// src/sequences/Scene2D.ts
+var Scene2DBox = class extends pixi_js.Container {
+  boxWidth = 1;
+  boxHeight = 1;
+  _ax = 0;
+  _ay = 0;
+  anchor = /* @__PURE__ */ (() => {
+    const box = this;
+    return {
+      get x() {
+        return box._ax;
+      },
+      set x(v) {
+        box._ax = v;
+        box.pivot.x = v * box.boxWidth;
+      },
+      get y() {
+        return box._ay;
+      },
+      set y(v) {
+        box._ay = v;
+        box.pivot.y = v * box.boxHeight;
+      },
+      set(x, y = x) {
+        this.x = x;
+        this.y = y;
+      }
+    };
+  })();
+};
+var isFlipbook = (n) => {
+  const f = n;
+  return typeof f.gotoAndStop === "function" && typeof f.totalFrames === "number" && typeof f.animationSpeed === "number" && "autoUpdate" in n;
+};
+var DEFAULT_LABELS = /* @__PURE__ */ new Set([
+  "Container",
+  "Graphics",
+  "Sprite",
+  "AnimatedSprite",
+  "TilingSprite",
+  "NineSliceSprite",
+  "Text",
+  "BitmapText",
+  "HTMLText",
+  "Mesh",
+  "MeshSimple",
+  "MeshPlane",
+  "MeshRope",
+  "PerspectiveMesh",
+  "ParticleContainer",
+  "RenderContainer",
+  "DOMContainer"
+]);
+var ids = /* @__PURE__ */ new WeakMap();
+var lastId = 0;
+function idOf(fn) {
+  if (typeof fn !== "function") return 0;
+  let id = ids.get(fn);
+  if (id === void 0) {
+    id = ++lastId;
+    ids.set(fn, id);
+  }
+  return id;
+}
+var Scene2DSequence = class extends Sequence {
+  _box = null;
+  _ctx = null;
+  _objects = {};
+  _flipbooks = [];
+  _warned = /* @__PURE__ */ new Set();
+  /** What a rebuild matches this layer by; null: never kept (`reuse: false`, no `name`). */
+  _key = null;
+  /** The layer of the tree being replaced whose scene this one takes over at the swap (`commitReuse`): until then it is not this layer's. */
+  _borrowed = null;
+  /** True once another layer took this layer's scene: destroying this one must not let it go. */
+  _donated = false;
+  /** What setup left on the objects the keyframes reach, shared with a layer that takes the scene over (core/setupValues.ts). */
+  _setupValues = new SetupValues();
+  get _spec() {
+    return this.spec;
+  }
+  _who() {
+    const name = this._spec.name;
+    return `pixi-effects: scene2d layer${name ? ` "${name}"` : ""}`;
+  }
+  _say(key, message) {
+    if (this._warned.has(key)) return;
+    this._warned.add(key);
+    console.warn(`${this._who()}: ${message}`);
+  }
+  pathRouters() {
+    return { scene2d: (path) => this._resolvePath(path) };
+  }
+  async build() {
+    const spec = this._spec;
+    if (this.duration === void 0) this.duration = this.parent?.duration ?? this.root.duration;
+    if (typeof spec.setup !== "function") {
+      throw new Error(`${this._who()}: a scene2d layer needs setup: ({ root }) => { \u2026 } (a function that adds PixiJS display objects to root)`);
+    }
+    if (typeof spec.update === "function" && NOT_PURE.test(spec.update.toString())) {
+      this._say("pure", "update calls Math.random, Date.now, performance.now or new Date, so it is not deterministic: the same frame would draw differently in playback, in a seek and in an export. Derive the value from t (random(seed) from pixi-effects is repeatable)");
+    }
+    const scope = buildScope(this, this.parent, this.root);
+    const width = dim(spec.width, scope) ?? this.parent?.width ?? this.root.width;
+    const height = dim(spec.height, scope) ?? this.parent?.height ?? this.root.height;
+    const box = new Scene2DBox({ label: spec.name ?? "scene2d" });
+    box.boxWidth = width;
+    box.boxHeight = height;
+    this._box = box;
+    this.target = box;
+    this.intrinsicWidth = width;
+    this.intrinsicHeight = height;
+    this._key = spec.reuse === false || !spec.name ? null : JSON.stringify(["scene2d", spec.name, idOf(spec.setup), width, height]);
+    const donor = this._key !== null ? this.root.reuse?.claim(this._key, this) : null;
+    if (donor && donor._lendable()) {
+      this._borrowed = donor;
+      this._objects = donor._objects;
+      this._flipbooks = donor._flipbooks;
+      this._setupValues = donor._setupValues;
+      this._ctx = { ...donor._ctx, width, height };
+      this.buildFilters();
+      return;
+    }
+    const root = new pixi_js.Container({ label: "root" });
+    box.addChild(root);
+    const renderer = this.root.pixiRenderer;
+    const objects = {};
+    const ctx = { root, renderer, width, height, objects, texture: (name) => textureOf(name) };
+    let result;
+    try {
+      result = await spec.setup(ctx);
+    } catch (err) {
+      box.destroy({ children: true });
+      this._box = null;
+      this.target = null;
+      throw new Error(`${this._who()}: setup failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
+    Object.assign(objects, result?.objects ?? {});
+    if (!("root" in objects)) objects.root = root;
+    this._objects = objects;
+    this._ctx = ctx;
+    this._stopSelfUpdating(root);
+    this.buildFilters();
+  }
+  /** Reuse (core/reuse.ts): the key this layer is matched by, while it can still lend its scene. */
+  reuseKey() {
+    return this._lendable() ? this._key : null;
+  }
+  _lendable() {
+    return !!this._box && !!this._ctx && !this._donated && !this._borrowed;
+  }
+  /** The new tree is on stage: the old layer's scene moves into this layer's box, for good. */
+  commitReuse() {
+    const d = this._borrowed, box = this._box;
+    if (!d || !box || !this._ctx) return;
+    this._setupValues.restore();
+    box.addChild(this._ctx.root);
+    d._donated = true;
+    this._borrowed = null;
+  }
+  /**
+   * Anything that would move on PixiJS's shared ticker instead of the video's time is turned off: an AnimatedSprite is posed by the layer from its time (so a sprite left
+   * playing still plays, frame for frame the same in a seek and an export); anything else with `autoUpdate` is said once (drive it from update). A sprite showing a
+   * `<video>` plays by the browser's clock: said once.
+   */
+  _stopSelfUpdating(root) {
+    const stopped = [];
+    const visit = (node) => {
+      const n = node;
+      if (isFlipbook(node)) {
+        if (!this._flipbooks.includes(node)) this._flipbooks.push(node);
+        if (node.autoUpdate) node.autoUpdate = false;
+      } else if (n.autoUpdate === true) {
+        n.autoUpdate = false;
+        stopped.push(n.label || n.constructor?.name || "a node");
+      }
+      const resource = n.texture?.source?.resource;
+      if (typeof HTMLVideoElement !== "undefined" && resource instanceof HTMLVideoElement) {
+        this._say("video", `a sprite shows a <video> texture, which plays by the browser's clock, not the video's time: use a video layer (type: 'video') for footage`);
+      }
+      for (const c of node.children ?? []) visit(c);
+    };
+    visit(root);
+    if (stopped.length) {
+      this._say("autoUpdate", `turned off autoUpdate on ${stopped.join(", ")}: a video draws from the time, so drive them from update(t)`);
+    }
+  }
+  /** An AnimatedSprite still playing after `update` is posed from the layer's time: frame floor(t × 60 × animationSpeed) (PixiJS counts ticks of 1/60 s), its loop and frame times kept. */
+  _poseFlipbooks(t) {
+    for (const f of this._flipbooks) {
+      if (!f.playing || f.totalFrames <= 0) continue;
+      const n = f.totalFrames;
+      let frame;
+      const durations = f._durations;
+      if (durations && durations.length === n) {
+        const total = durations.reduce((a, b) => a + b, 0);
+        let ms = t * 1e3 * Math.abs(f.animationSpeed);
+        ms = f.loop && total > 0 ? ms % total : Math.min(ms, total);
+        frame = 0;
+        for (let acc = durations[0]; frame < n - 1 && acc <= ms; acc += durations[++frame]) {
+        }
+      } else {
+        const ticks = Math.floor(t * 60 * Math.abs(f.animationSpeed) + 1e-9);
+        frame = f.loop ? ticks % n : Math.min(ticks, n - 1);
+      }
+      if (f.animationSpeed < 0) frame = n - 1 - frame;
+      f.gotoAndStop(frame);
+      f.play();
+    }
+  }
+  /** Per-frame hook, duck-typed by the movie (as the video, canvas and 3D layers are). */
+  async awaitFrameAt(local) {
+    if (!this._ctx || this._borrowed) return;
+    this._frame(Math.max(0, Math.min(local, this.duration ?? local)));
+  }
+  _frame(t) {
+    const update = this._spec.update;
+    if (update) {
+      try {
+        update(t, this._ctx);
+      } catch (err) {
+        this._say("update", `update threw (reported once): ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    this._poseFlipbooks(t);
+  }
+  /**
+   * `movie.pick`: the top object of the scene under a canvas point, by PixiJS's own `containsPoint` (a Graphics by its shape, a Sprite or Text by its box) or its `hitArea`.
+   * `eventMode: 'none'` and `interactiveChildren: false` are honoured; hidden, unrenderable and clear nodes are not hit. null: nothing of the scene is there (the point falls through).
+   */
+  pick2d(global) {
+    const root = this._ctx?.root;
+    if (!root || this._borrowed) return null;
+    const hitIn = (node2) => {
+      if (!node2.visible || !node2.renderable || node2.alpha <= 0 || node2.measurable === false) return null;
+      const mode = node2.eventMode;
+      if (mode === "none") return null;
+      const local = node2.toLocal(global);
+      const area = node2 === root ? null : node2.hitArea;
+      if (area && !area.contains(local.x, local.y)) return null;
+      if (node2.interactiveChildren !== false) {
+        for (let i = node2.children.length - 1; i >= 0; i--) {
+          const h = hitIn(node2.children[i]);
+          if (h) return h;
+        }
+      }
+      if (node2 === root) return null;
+      if (area) return node2;
+      const contains = node2.containsPoint;
+      return typeof contains === "function" && contains.call(node2, new pixi_js.Point(local.x, local.y)) ? node2 : null;
+    };
+    const node = hitIn(root);
+    if (!node) return null;
+    let name = "";
+    for (let n = node; n && n !== root; n = n.parent) {
+      if (n.label && !DEFAULT_LABELS.has(n.label) && n.label !== n.constructor?.name) {
+        name = n.label;
+        break;
+      }
+    }
+    const p = root.toLocal(global);
+    return { object: name, node, point: [p.x, p.y] };
+  }
+  /** `hit.scene2d.grab()`: for a canvas point, where it is in the grabbed node's parent's pixels and how far that is from where it was grabbed (`node.x += delta[0]`). */
+  dragFrom(node, global) {
+    const space = node.parent ?? node;
+    const from = space.toLocal(global);
+    return (x, y) => {
+      const p = space.toLocal({ x, y });
+      return { point: [p.x, p.y], delta: [p.x - from.x, p.y - from.y] };
+    };
+  }
+  /**
+   * The determinism check (`check`, `movie.review()`): the scene set by `update` and drawn at a few moments in two orders, with one draw thrown away first, as the canvas and 3D
+   * layers are. It draws the root alone into a texture of the box's size with PixiJS's renderer; the next real frame sets the scene again.
+   */
+  checkDeterminism(times) {
+    const none = { differs: [], drawMs: 0, threw: [] };
+    const ctx = this._ctx;
+    const renderer = this.root.pixiRenderer;
+    if (!ctx || !renderer || this._borrowed) return none;
+    const root = ctx.root;
+    const w = Math.max(1, Math.ceil(ctx.width)), h = Math.max(1, Math.ceil(ctx.height));
+    const rt = pixi_js.RenderTexture.create({ width: w, height: h });
+    const wasGroup = root.isRenderGroup;
+    const keep = w * h * 4 * times.length <= 96e6;
+    const hash = (d) => {
+      let x = 2166136261;
+      for (let i = 0; i < d.length; i++) {
+        x ^= d[i];
+        x = Math.imul(x, 16777619);
+      }
+      return x >>> 0;
+    };
+    const ms = [];
+    const threw = /* @__PURE__ */ new Set();
+    const update = this._spec.update;
+    const once = (t, timed) => {
+      const from = performance.now();
+      let pixels = new Uint8Array(0);
+      try {
+        update?.(t, ctx);
+        this._poseFlipbooks(t);
+        renderer.render({ container: root, target: rt, clear: true, transform: new pixi_js.Matrix() });
+        pixels = renderer.extract.pixels(rt).pixels;
+      } catch {
+        threw.add(t);
+      }
+      if (timed) ms.push(performance.now() - from);
+      return pixels;
+    };
+    try {
+      for (const t of times) once(t, false);
+      const first = times.map((t) => {
+        const d = once(t, true);
+        return keep ? d.slice() : hash(d);
+      });
+      const second = [...times].reverse().map((t) => once(t, false)).reverse();
+      const differs = [];
+      times.forEach((t, i) => {
+        const a = first[i], b = second[i];
+        if (typeof a === "number") {
+          if (a !== hash(b)) differs.push({ t, pixels: -1, maxDiff: -1 });
+          return;
+        }
+        let pixels = 0, maxDiff = 0;
+        for (let k = 0; k < a.length; k++) {
+          const d = Math.abs(a[k] - b[k]);
+          if (d) {
+            pixels++;
+            if (d > maxDiff) maxDiff = d;
+          }
+        }
+        if (pixels) differs.push({ t, pixels, maxDiff });
+      });
+      ms.sort((x, y) => x - y);
+      return { differs: differs.filter((d) => !threw.has(d.t)), drawMs: ms.length ? ms[Math.floor(ms.length / 2)] : 0, threw: times.filter((t) => threw.has(t)) };
+    } finally {
+      rt.destroy(true);
+      if (!wasGroup && root.isRenderGroup) root.disableRenderGroup();
+    }
+  }
+  _resolvePath(path) {
+    const segs = path.split(".");
+    if (segs.length < 2) {
+      this._warnPath(path, "needs at least <object>.<prop>");
+      return null;
+    }
+    let obj = this._objects[segs[0]];
+    if (obj == null) {
+      this._warnPath(path, `unknown object "${segs[0]}" (known: ${Object.keys(this._objects).join(", ")}): expose it in setup's { objects }`);
+      return null;
+    }
+    for (let i = 1; i < segs.length - 1; i++) {
+      obj = obj[segs[i]];
+      if (obj == null) {
+        this._warnPath(path, `"${segs[i]}" is undefined along the path`);
+        return null;
+      }
+    }
+    const prop = segs[segs.length - 1];
+    if (typeof obj !== "object" || !(prop in obj)) {
+      this._warnPath(path, `no property "${prop}"`);
+      return null;
+    }
+    return this._borrowed ? this._setupValues.view(obj, prop, () => this._borrowed !== null) : (this._setupValues.note(obj, prop), { target: obj, prop });
+  }
+  _warnPath(path, why) {
+    this._say(`path:${path}`, `keyframe path scene2d.${path}: ${why}; skipped`);
+  }
+  destroy() {
+    const kept = this._donated || this._borrowed !== null;
+    if (!kept && this._ctx && this._spec.dispose) {
+      try {
+        this._spec.dispose(this._ctx);
+      } catch (err) {
+        console.warn(`${this._who()}: dispose() threw \u2014`, err);
+      }
+    }
+    const box = this._box;
+    this._box = null;
+    if (this.target === box) this.target = null;
+    try {
+      box?.destroy({ children: true });
+    } catch (err) {
+      console.warn(`${this._who()}: destroying the scene threw \u2014`, err);
+    }
+    this._ctx = null;
+    this._objects = {};
+    this._flipbooks = [];
+    this._borrowed = null;
+    super.destroy();
+  }
+};
+function textureOf(name) {
+  if (pixi_js.Assets.cache.has(name)) {
+    const t = pixi_js.Assets.get(name);
+    if (t && typeof t.source === "object") return t;
+    throw new Error(`asset "${name}" is not a picture (ctx.texture gives the texture of an image asset)`);
+  }
+  const known = [...pixi_js.Assets.cache._cache?.keys() ?? []].filter((k) => !/[/:.]/.test(k) && !k.startsWith("pixi-effects-"));
+  throw new Error(`no asset named "${name}"${known.length ? ` (assets: ${known.join(", ")})` : ""}: list it in movie.init({ assets: [{ name, src }] })`);
+}
+function dim(v, scope) {
+  if (v === void 0) return void 0;
+  return typeof v === "number" ? v : evaluateExpr(v, scope);
+}
+
 // src/core/Composition.ts
 var _CompositionSequence = null;
 async function getCompositionSequence() {
   if (!_CompositionSequence) {
-    _CompositionSequence = (await import('./Composition-TJ5D7Z63.cjs')).CompositionSequence;
+    _CompositionSequence = (await import('./Composition-47U5U637.cjs')).CompositionSequence;
   }
   return _CompositionSequence;
 }
 var _SpansSequence = null;
 async function getSpansSequence() {
-  if (!_SpansSequence) _SpansSequence = (await import('./Spans-5ENZ3XGS.cjs')).SpansSequence;
+  if (!_SpansSequence) _SpansSequence = (await import('./Spans-R426NVY3.cjs')).SpansSequence;
   return _SpansSequence;
 }
 var staticTypes = {
@@ -6091,12 +6547,17 @@ var staticTypes = {
   light: LightSequence,
   shader: ShaderSequence,
   canvas: CanvasSequence,
+  scene2d: Scene2DSequence,
   null: NullSequence
 };
 var registry2 = {};
 function registerSequenceType(type, ctor) {
   registry2[type] = ctor;
 }
+var OPTIONAL_ENTRIES = {
+  scene3d: { from: "pixi-effects/3d", call: "register3D" },
+  three: { from: "pixi-effects/three", call: "registerThree" }
+};
 async function buildSequenceTree(specs, parent, root, out = []) {
   for (let spec of specs) {
     let Cls = staticTypes[spec.type] ?? registry2[spec.type];
@@ -6108,7 +6569,9 @@ async function buildSequenceTree(specs, parent, root, out = []) {
       Cls = await getCompositionSequence();
     }
     if (!Cls) {
-      console.warn(`pixi-effects: unknown sequence type "${spec.type}"`);
+      const type = spec.type;
+      const entry = OPTIONAL_ENTRIES[type];
+      console.warn(`pixi-effects: unknown sequence type "${type}"${entry ? `: import { ${entry.call} } from '${entry.from}' and call ${entry.call}() before movie.init` : ""}`);
       await root.onLayerBuilt?.();
       continue;
     }
@@ -6137,9 +6600,11 @@ exports.MAX_CASTERS = MAX_CASTERS;
 exports.MAX_LIGHTS = MAX_LIGHTS;
 exports.MIN_BLUR = MIN_BLUR;
 exports.NEAR = NEAR;
+exports.NOT_PURE = NOT_PURE;
 exports.NullSequence = NullSequence;
 exports.SHADOW_TAPS = SHADOW_TAPS;
 exports.Sequence = Sequence;
+exports.SetupValues = SetupValues;
 exports.TextSequence = TextSequence;
 exports.bindClock = bindClock;
 exports.bindCounterKeyframes = bindCounterKeyframes;
@@ -6178,5 +6643,5 @@ exports.spansMeta = spansMeta;
 exports.springDuration = springDuration;
 exports.timeRemapOf = timeRemapOf;
 exports.trimPolylines = trimPolylines;
-//# sourceMappingURL=chunk-Z3DM4ETD.cjs.map
-//# sourceMappingURL=chunk-Z3DM4ETD.cjs.map
+//# sourceMappingURL=chunk-VVUSZVP7.cjs.map
+//# sourceMappingURL=chunk-VVUSZVP7.cjs.map