pixi-effects 0.48.2 → 0.50.0

package/dist/{chunk-IVKI6CPH.js → chunk-SSVHAF3Q.js}

@@ -1,6 +1,6 @@
-import { describeLayer, collectPropKeys } from './chunk-BFRWSV3R.js';
+import { describeLayer, collectPropKeys } from './chunk-J4ZP76IL.js';
 import { suggestName, warnUnknownOptions } from './chunk-WGRWFQOB.js';
-import { Rectangle, Container, FillGradient, Text, Color, GraphicsPath, Sprite, Texture, Graphics, Assets, Filter, GlProgram, defaultFilterVert, GpuProgram, UniformGroup, AlphaFilter, NoiseFilter, BlurFilter, TextStyle, CanvasTextMetrics, ColorMatrixFilter } from 'pixi.js';
+import { Rectangle, Container, FillGradient, Text, Color, GraphicsPath, RenderTexture, Sprite, Texture, Graphics, Assets, Filter, GlProgram, defaultFilterVert, GpuProgram, UniformGroup, AlphaFilter, NoiseFilter, BlurFilter, Point, Matrix, TextStyle, CanvasTextMetrics, ColorMatrixFilter } from 'pixi.js';
 
 // src/core/spring.ts
 var SETTLE_TOL = 5e-3;
@@ -512,9 +512,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);
@@ -1383,6 +1383,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 = {};
@@ -1405,7 +1408,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)) {
@@ -1417,7 +1420,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);
@@ -1430,7 +1433,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);
@@ -1451,16 +1454,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)]);
@@ -1493,7 +1496,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)) {
@@ -4005,7 +4008,7 @@ var AudioSequence = class extends Sequence {
     const raw = spec;
     if (raw.asset !== void 0) console.warn(`pixi-effects: ${who}: has both asset and music \u2014 the music plays; remove one`);
     if (raw.sfx !== void 0) console.warn(`pixi-effects: ${who}: has both sfx and music \u2014 the music plays; remove one`);
-    const { resolveMusic, renderMusic, renderMusicAsync, musicLength, musicKey, summarizeMusic } = await import('./music-P4JRT73P.js');
+    const { resolveMusic, renderMusic, renderMusicAsync, musicLength, musicKey, summarizeMusic } = await import('./music-ATX22VAT.js');
     const music = resolveMusic(spec.music, who);
     if (!music) return;
     const natural = musicLength(music);
@@ -5772,10 +5775,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 () => {
@@ -6066,17 +6073,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 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 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 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 = 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 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 (Assets.cache.has(name)) {
+    const t = 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 = [...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-5FKV2IBP.js')).CompositionSequence;
+    _CompositionSequence = (await import('./Composition-GVWWLFDL.js')).CompositionSequence;
   }
   return _CompositionSequence;
 }
 var _SpansSequence = null;
 async function getSpansSequence() {
-  if (!_SpansSequence) _SpansSequence = (await import('./Spans-6A3VLHRH.js')).SpansSequence;
+  if (!_SpansSequence) _SpansSequence = (await import('./Spans-3SEZSTQV.js')).SpansSequence;
   return _SpansSequence;
 }
 var staticTypes = {
@@ -6089,12 +6545,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];
@@ -6106,7 +6567,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;
     }
@@ -6121,6 +6584,6 @@ async function buildSequenceTree(specs, parent, root, out = []) {
   return out;
 }
 
-export { CameraSequence, DEFAULT_FOV, DEG3 as DEG, EXPRESSION_NAMES, FALLOFFS, LIGHT_KINDS, LIGHT_PROPS, LightSequence, MANY_BLURRED, MAX_BLUR, MAX_CASTERS, MAX_LIGHTS, MIN_BLUR, NEAR, NullSequence, SHADOW_TAPS, Sequence, TextSequence, bindClock, bindCounterKeyframes, blurRadius, buildScope, buildSequenceTree, cameraBasis, checkEase, clockTable, contentLength, createTimeline, ensureFilterLibrary, evaluateExpr, flattenSvgPath, focusProblems, homeCamera, homeDistance, layerInitialZ, layerToWorld, lengthen, lightLevel, noise, noise2, packLights, parseEase, parseSpring, projectLayer, projectPoint, rand, random, registerSequenceType, remapOf, resolveAt, resolveNumber, spansMeta, springDuration, timeRemapOf, trimPolylines };
-//# sourceMappingURL=chunk-IVKI6CPH.js.map
-//# sourceMappingURL=chunk-IVKI6CPH.js.map
+export { CameraSequence, DEFAULT_FOV, DEG3 as DEG, EXPRESSION_NAMES, FALLOFFS, LIGHT_KINDS, LIGHT_PROPS, LightSequence, MANY_BLURRED, MAX_BLUR, MAX_CASTERS, MAX_LIGHTS, MIN_BLUR, NEAR, NOT_PURE, NullSequence, SHADOW_TAPS, Sequence, SetupValues, TextSequence, bindClock, bindCounterKeyframes, blurRadius, buildScope, buildSequenceTree, cameraBasis, checkEase, clockTable, contentLength, createTimeline, ensureFilterLibrary, evaluateExpr, flattenSvgPath, focusProblems, homeCamera, homeDistance, layerInitialZ, layerToWorld, lengthen, lightLevel, noise, noise2, packLights, parseEase, parseSpring, projectLayer, projectPoint, rand, random, registerSequenceType, remapOf, resolveAt, resolveNumber, spansMeta, springDuration, timeRemapOf, trimPolylines };
+//# sourceMappingURL=chunk-SSVHAF3Q.js.map
+//# sourceMappingURL=chunk-SSVHAF3Q.js.map