pixi-effects 0.22.0 → 0.25.0

package/dist/chunk-UQDEDYVM.js

@@ -1,838 +0,0 @@
-import { Sequence, timeRemapOf, contentLength, remapOf, buildSequenceTree, CameraSequence, layerInitialZ, bindClock, clockTable, NullSequence, homeCamera, cameraBasis, projectPoint, NEAR, blurRadius, MANY_BLURRED, focusProblems, projectLayer, MIN_BLUR, MAX_BLUR, DEG } from './chunk-DC4JPY6A.js';
-import { maxConcurrentAdvanced, MANY_ADVANCED, applyBlendMode, blendProblem, isAdvancedBlend, blendFilterFor, blendUnavailableMessage } from './chunk-YEPDQ7I3.js';
-import { lintTiming, lintText, lintKeys, summarizeWarnings, describeLayer, collectPropKeys } from './chunk-E7RONUZ7.js';
-import { suggestName } from './chunk-NHICCDTC.js';
-import { Container, Rectangle, AlphaFilter, AlphaMask, PerspectiveMesh, Texture, Matrix, RenderTexture, Filter, UniformGroup, GpuProgram, GlProgram } from 'pixi.js';
-import { gsap } from 'gsap';
-
-// src/space/camera.ts
-function pickActiveCamera(cams, t, compEnd) {
-  for (let i = cams.length - 1; i >= 0; i--) {
-    const c = cams[i];
-    const inside = t >= c.start && (t < c.end || c.end >= compEnd && t <= compEnd);
-    if (inside) return c;
-  }
-  return null;
-}
-function findOverlap(cams) {
-  for (let i = 0; i < cams.length; i++) {
-    for (let j = i + 1; j < cams.length; j++) {
-      const a = cams[i];
-      const b = cams[j];
-      if (a.start < b.end && b.start < a.end) return [i, j];
-    }
-  }
-  return null;
-}
-
-// src/space/depth.ts
-var finite = (n) => Number.isFinite(n) ? n : 0;
-function assignDepthOrder(items) {
-  const out = items.map((i2) => i2.stackIndex);
-  let i = 0;
-  while (i < items.length) {
-    if (!items[i].threeD) {
-      i++;
-      continue;
-    }
-    let j = i;
-    while (j + 1 < items.length && items[j + 1].threeD) j++;
-    const run = items.slice(i, j + 1).map((it, k) => ({ it, pos: i + k }));
-    const slots = run.map((r) => r.it.stackIndex);
-    const farthestFirst = [...run].sort((a, b) => finite(b.it.depth) - finite(a.it.depth));
-    farthestFirst.forEach((r, k) => {
-      out[r.pos] = slots[k];
-    });
-    i = j + 1;
-  }
-  return out;
-}
-var DISC_TAPS = 48;
-var GL_VERTEX = `#version 300 es
-in vec2 aPosition;
-out vec2 vTextureCoord;
-uniform vec4 uInputSize;
-uniform vec4 uOutputFrame;
-uniform vec4 uOutputTexture;
-void main(void) {
-  vec2 position = aPosition * uOutputFrame.zw + uOutputFrame.xy;
-  position.x = position.x * (2.0 / uOutputTexture.x) - 1.0;
-  position.y = position.y * (2.0 * uOutputTexture.z / uOutputTexture.y) - uOutputTexture.z;
-  gl_Position = vec4(position, 0.0, 1.0);
-  vTextureCoord = aPosition * (uOutputFrame.zw * uInputSize.zw);
-}`;
-var GL_FRAGMENT = `#version 300 es
-precision highp float;
-in vec2 vTextureCoord;
-uniform sampler2D uTexture;
-uniform vec4 uInputSize;
-uniform float uRadius;
-out vec4 finalColor;
-void main(void) {
-  vec4 acc = vec4(0.0);
-  for (int i = 0; i < ${DISC_TAPS}; i++) {
-    float r = sqrt((float(i) + 0.5) / ${DISC_TAPS}.0) * uRadius;
-    float a = float(i) * 2.39996323;
-    acc += texture(uTexture, vTextureCoord + vec2(cos(a), sin(a)) * r * uInputSize.zw);
-  }
-  finalColor = acc / ${DISC_TAPS}.0;
-}`;
-var WGSL = `
-struct GlobalFilterUniforms {
-  uInputSize: vec4<f32>, uInputPixel: vec4<f32>, uInputClamp: vec4<f32>,
-  uOutputFrame: vec4<f32>, uGlobalFrame: vec4<f32>, uOutputTexture: vec4<f32>,
-};
-struct DiscUniforms { uRadius: 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> disc : DiscUniforms;
-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);
-}
-@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> {
-  var acc = vec4<f32>(0.0);
-  for (var i = 0; i < ${DISC_TAPS}; i++) {
-    let r = sqrt((f32(i) + 0.5) / ${DISC_TAPS}.0) * disc.uRadius;
-    let a = f32(i) * 2.39996323;
-    acc += textureSampleLevel(uTexture, uSampler, uv + vec2<f32>(cos(a), sin(a)) * r * gfu.uInputSize.zw, 0.0);
-  }
-  return acc / ${DISC_TAPS}.0;
-}`;
-var DiscBlurFilter = class extends Filter {
-  constructor(radius = 8) {
-    super({
-      glProgram: GlProgram.from({ vertex: GL_VERTEX, fragment: GL_FRAGMENT, name: "disc-blur" }),
-      gpuProgram: GpuProgram.from({ vertex: { source: WGSL, entryPoint: "mainVertex" }, fragment: { source: WGSL, entryPoint: "mainFragment" } }),
-      resources: { disc: new UniformGroup({ uRadius: { value: radius, type: "f32" } }) }
-    });
-    this.radius = radius;
-  }
-  /** Blur radius in pixels. The padding follows it, so the blurred edge is not cut off. */
-  get radius() {
-    return this.resources.disc.uniforms.uRadius;
-  }
-  set radius(v) {
-    const r = Math.max(0, v);
-    this.resources.disc.uniforms.uRadius = r;
-    this.padding = Math.ceil(r) + 2;
-  }
-};
-
-// src/space/Layer3D.ts
-var MAX_TEXTURE_SIZE = 4096;
-var SUPERSAMPLE = 2;
-var MAX_TEXTURE_PIXELS = 2048 * 2048;
-var ANTIALIAS_MAX_PIXELS = 1024 * 1024;
-var MESH_GRID = 20;
-function filterPadding(target) {
-  const filters = target.filters;
-  if (!Array.isArray(filters)) return 0;
-  let pad = 0;
-  for (const f of filters) pad += f?.padding ?? 0;
-  return Number.isFinite(pad) && pad > 0 ? Math.ceil(pad) : 0;
-}
-function readLayerTransform(target) {
-  const c = target;
-  return {
-    x: c.x,
-    y: c.y,
-    z: c.z ?? 0,
-    rotationX: (c.rotationX ?? 0) * DEG,
-    rotationY: (c.rotationY ?? 0) * DEG,
-    rotationZ: c.rotation,
-    scaleX: c.scale.x,
-    scaleY: c.scale.y,
-    pivotX: c.pivot.x,
-    pivotY: c.pivot.y
-  };
-}
-var Layer3D = class {
-  constructor(seq, frameOf2) {
-    this.seq = seq;
-    this.frameOf = frameOf2;
-    const target = seq.target;
-    target.z ??= 0;
-    target.rotationX ??= 0;
-    target.rotationY ??= 0;
-    this.display = new PerspectiveMesh({ texture: Texture.WHITE, verticesX: MESH_GRID, verticesY: MESH_GRID });
-    if (seq.spec.name) this.display.label = seq.spec.name;
-    this.display.visible = false;
-  }
-  seq;
-  frameOf;
-  display;
-  /** Camera-space depth from the last update (larger = farther). */
-  depth = 0;
-  rt = null;
-  /**
-   * Textures replaced by a bigger / smaller one. Destroying one right away warns "destroyed while still
-   * bound": the mesh's bind group still points at it until the next render. They go at the next update,
-   * by which time a frame has been drawn with the new texture.
-   */
-  retired = [];
-  size = null;
-  warnedBehind = false;
-  /** Depth-of-field blur radius (px) from the last `setBlur`; 0 = no filter. */
-  blur = 0;
-  blurFilter = null;
-  blendWas = "normal";
-  blendFilter = null;
-  update(host, basis) {
-    this.flushRetired();
-    const target = this.seq.target;
-    if (!target || !target.renderable || !target.visible) return this.hide();
-    const bounds = this.frameOf();
-    const pad = filterPadding(target);
-    const needW = Math.ceil(bounds.width + 2 * pad);
-    const needH = Math.ceil(bounds.height + 2 * pad);
-    if (!(needW >= 1 && needH >= 1) || !Number.isFinite(bounds.x) || !Number.isFinite(bounds.y)) return this.hide();
-    const size = this.sizeFor(needW, needH);
-    const frame = { x: bounds.x - pad, y: bounds.y - pad, width: size.w, height: size.h };
-    const projected = projectLayer(readLayerTransform(target), frame, basis);
-    this.depth = projected.depth;
-    if (!projected.visible) {
-      if (!this.warnedBehind) {
-        this.warnedBehind = true;
-        if (this.seq.spec.hideBehindCamera) return this.hide();
-        if (projected.depth > NEAR) {
-          console.warn(
-            `pixi-effects: ${describeLayer(this.seq.spec)}: part of it (a corner) reaches the camera plane (z = ${(target.z ?? 0).toFixed(0)}, rotationX ${(target.rotationX ?? 0).toFixed(0)}\xB0, rotationY ${(target.rotationY ?? 0).toFixed(0)}\xB0), and a layer is hidden whole when any corner is at or behind it. Tilt it less (rotationX / rotationY), make it smaller, or keep the camera further away from it (the default camera sits at z = (height/2)/tan(fov/2), about 989 for 720p at fov 40).`
-          );
-        } else {
-          console.warn(
-            `pixi-effects: ${describeLayer(this.seq.spec)} is at or behind the camera plane (z = ${(target.z ?? 0).toFixed(0)}) and is hidden. If that is unintended, lower its z or move the camera back (the default camera sits at z = (height/2)/tan(fov/2), about 989 for 720p at fov 40).`
-          );
-        }
-      }
-      return this.hide();
-    }
-    this.ensureTexture(size);
-    host.render({
-      container: target,
-      target: this.rt,
-      transform: new Matrix().translate(-frame.x, -frame.y),
-      clear: true,
-      clearColor: [0, 0, 0, 0]
-    });
-    this.display.geometry.setCorners(...projected.corners);
-    this.display.visible = true;
-  }
-  /**
-   * Depth-of-field blur on the projected mesh (screen space), so a tilted or scaled layer blurs by the size it is drawn at.
-   * A radius under MIN_BLUR removes the filter: a sharp layer costs nothing. A blend mode moves to the filter while it is on
-   * (a filtered object blends as a whole), and comes back when it goes.
-   */
-  setBlur(radius) {
-    const d = this.display;
-    const r = radius > MIN_BLUR ? Math.min(radius, MAX_BLUR) : 0;
-    this.blur = r;
-    if (r === 0) {
-      if (this.blurFilter) {
-        d.filters = null;
-        d.blendMode = this.blendWas;
-        this.blurFilter.destroy();
-        this.blurFilter = null;
-        this.blendFilter?.destroy();
-        this.blendFilter = null;
-      }
-      return;
-    }
-    if (!this.blurFilter) {
-      this.blurFilter = new DiscBlurFilter(r);
-      this.blendWas = d.blendMode ?? "normal";
-      const chain = [this.blurFilter];
-      if (isAdvancedBlend(this.blendWas)) {
-        this.blendFilter = blendFilterFor(this.blendWas);
-        if (this.blendFilter) {
-          chain.push(this.blendFilter);
-          d.blendMode = "normal";
-        }
-      } else if (this.blendWas !== "normal" && this.blendWas !== "inherit") {
-        this.blurFilter.blendMode = this.blendWas;
-        d.blendMode = "normal";
-      }
-      d.filters = chain;
-    }
-    this.blurFilter.radius = r;
-  }
-  destroy() {
-    this.setBlur(0);
-    this.display.destroy();
-    this.rt?.destroy(true);
-    this.rt = null;
-    this.flushRetired();
-  }
-  flushRetired() {
-    for (const t of this.retired) t.destroy(true);
-    this.retired = [];
-  }
-  hide() {
-    this.display.visible = false;
-  }
-  /**
-   * Texture size for content of w×h. An existing texture is kept while it is at
-   * least that big and at most 2x too big, so content whose bounds change every
-   * frame (typewriter text, growing shapes) does not reallocate each frame.
-   */
-  sizeFor(w, h) {
-    const cur = this.size;
-    if (cur && cur.w >= w && cur.h >= h && cur.w <= 2 * w && cur.h <= 2 * h) return cur;
-    const resolution = Math.min(
-      SUPERSAMPLE,
-      MAX_TEXTURE_SIZE / Math.max(w, h),
-      Math.sqrt(MAX_TEXTURE_PIXELS / (w * h))
-    );
-    const antialias = w * h * resolution * resolution <= ANTIALIAS_MAX_PIXELS;
-    return { w, h, resolution, antialias };
-  }
-  ensureTexture(size) {
-    if (this.rt && this.size === size) return;
-    if (this.rt && this.size && this.size.antialias === size.antialias) {
-      this.rt.resize(size.w, size.h, size.resolution);
-      this.size = size;
-      return;
-    }
-    const next = RenderTexture.create({
-      width: size.w,
-      height: size.h,
-      resolution: size.resolution,
-      antialias: size.antialias
-    });
-    this.display.texture = next;
-    if (this.rt) this.retired.push(this.rt);
-    this.rt = next;
-    this.size = size;
-  }
-};
-
-// src/space/lint.ts
-var defaultWarn = (m) => console.warn(m);
-var FOV_HINT = `perspective is the camera's "fov" \u2014 add a { type: "camera" } layer and set fov in its initial / keyframes`;
-var DOF_HINT = `depth of field is the camera's "focus" (the plane that is sharp: a layer name or a z) and "aperture" (how shallow: 0 = off, 30 = default) \u2014 put them in the camera's initial / keyframes`;
-var LAYER_ALIASES = {
-  rotateX: 'did you mean "rotationX"?',
-  rotateY: 'did you mean "rotationY"?',
-  rotateZ: 'did you mean "rotation"?',
-  rotationZ: 'did you mean "rotation" (it is the Z rotation)?',
-  translateZ: 'did you mean "z"?',
-  depth: 'did you mean "z"?',
-  posZ: 'did you mean "z"?',
-  perspective: FOV_HINT,
-  zoom: FOV_HINT
-};
-var CAMERA_ALIASES = {
-  pointOfInterest: 'did you mean "lookAtX / lookAtY / lookAtZ"?',
-  lookAt: 'did you mean "lookAtX / lookAtY / lookAtZ"?',
-  depthOfField: DOF_HINT,
-  dof: DOF_HINT,
-  focalDistance: DOF_HINT,
-  focusDistance: DOF_HINT,
-  fStop: DOF_HINT,
-  blurAmount: DOF_HINT
-};
-var CAMERA_PROPS = ["x", "y", "z", "fov", "focus", "aperture", "lookAtX", "lookAtY", "lookAtZ", "offsetX", "offsetY", "offsetZ", "lookOffsetX", "lookOffsetY", "lookOffsetZ"];
-var NEEDS_THREE_D = ["z", "rotationX", "rotationY"];
-var CAMERA_ONLY = ["focus", "aperture"];
-var SKEW_KEYS = ["skew", "skewX", "skewY"];
-function lintSequence(spec, warn = defaultWarn) {
-  const who = describeLayer(spec);
-  const keys = collectPropKeys(spec);
-  const explained = /* @__PURE__ */ new Set();
-  for (const k of keys) {
-    const hint = LAYER_ALIASES[k] ?? (spec.type === "camera" ? CAMERA_ALIASES[k] : void 0);
-    if (hint) {
-      explained.add(k);
-      warn(`pixi-effects: ${who}: "${k}" is not a property \u2014 ${hint}`);
-    }
-  }
-  if (spec.type === "camera") {
-    const raw = spec;
-    for (const p of CAMERA_PROPS) {
-      if (p in raw) warn(`pixi-effects: ${who}: "${p}" must go inside initial / keyframes, not on the camera itself`);
-    }
-    for (const k of Object.keys(raw)) {
-      const hint = CAMERA_ALIASES[k] ?? LAYER_ALIASES[k];
-      if (hint) warn(`pixi-effects: ${who}: "${k}" is not a property \u2014 ${hint} (inside initial)`);
-    }
-    for (const k of keys) {
-      if (!explained.has(k) && !CAMERA_PROPS.includes(k)) {
-        warn(`pixi-effects: ${who}: "${k}" has no effect on a camera (use ${CAMERA_PROPS.join(", ")})`);
-      }
-    }
-    return;
-  }
-  for (const k of CAMERA_ONLY) {
-    if (keys.has(k)) warn(`pixi-effects: ${who}: "${k}" is a camera property and does nothing on this layer: write it in the initial / keyframes of a { type: 'camera' } layer`);
-  }
-  if (spec.type === "audio") {
-    if (spec.threeD) warn(`pixi-effects: ${who}: threeD has no effect on audio`);
-    return;
-  }
-  if (!spec.threeD) {
-    for (const k of NEEDS_THREE_D) {
-      if (keys.has(k)) warn(`pixi-effects: ${who}: "${k}" needs threeD: true (it is ignored otherwise)`);
-    }
-  } else {
-    for (const k of SKEW_KEYS) {
-      if (keys.has(k)) warn(`pixi-effects: ${who}: "${k}" is ignored on threeD layers`);
-    }
-  }
-}
-function lintFocus(camera, siblings, warn = defaultWarn) {
-  if (camera.type !== "camera") return;
-  const who = describeLayer(camera);
-  for (const p of focusProblems(camera, siblings)) {
-    if (p.kind === "missing") {
-      warn(`pixi-effects: ${who}: focus: no layer named "${p.name}"${p.hint ? `; did you mean "${p.hint}"?` : ""} (the z = 0 plane is used). Write a threeD layer's name or a z number`);
-    } else if (p.kind === "not-threeD") {
-      warn(`pixi-effects: ${who}: focus "${p.name}" is not a threeD layer, so it has no depth (the z = 0 plane is used). Write a threeD layer's name or a z number`);
-    } else if (p.kind === "duplicate") {
-      warn(`pixi-effects: ${who}: focus "${p.name}": ${p.count} layers are named "${p.name}"; the first threeD one is used. Give the layers different names`);
-    } else {
-      warn(`pixi-effects: ${who}: focus "${p.name}" reads only the first z of that layer; its z moves later and the focus does not follow. Animate focus itself with numbers to follow it`);
-    }
-  }
-}
-
-// src/sequences/Composition.ts
-var CompositionSequence = class extends Sequence {
-  _innerContainer = null;
-  _compositionShape = null;
-  _children = [];
-  _cameras = [];
-  _layers3d = [];
-  _dofSaid = { behind: false, many: false };
-  /** What this composition made for blend modes (filters added to layers' chains, groups and their carrier filters): destroyed with it. */
-  _blendOwned = [];
-  /** Drawn children in stack order (cameras and target-less sequences excluded). */
-  _visual = [];
-  /** Layers drawn inside a null layer (`parent`): they are not in the composition's own stack. */
-  _nested = [];
-  /** The null layer each parented layer is drawn inside. */
-  _parentOf = /* @__PURE__ */ new Map();
-  /** Set when this composition's own time is remapped: the children live on `_inner` in LOCAL time, driven by `_clock`. */
-  _inner = null;
-  _clock = null;
-  _remap = null;
-  _childBase = 0;
-  _contentSpan = 0;
-  /** Where the children's time starts: the composition's absolute start, or 0 when their time is local (remapped). */
-  get childBase() {
-    return this._childBase;
-  }
-  /** How long the children's time runs: the composition's duration, or its content length when its time is remapped. */
-  get contentSpan() {
-    return this._contentSpan;
-  }
-  /** The time the children live in at movie time `t`: the movie's own, or this composition's local clock when it is remapped. */
-  childTime(t) {
-    return this._clock ? this._clock.time : t;
-  }
-  /** The clock reader for filters that want the time (grain), or null when the children run on the movie's time. */
-  localClock() {
-    return this._clock ? () => this._clock.time : null;
-  }
-  /** How the time is remapped, for the timeline chart: `×0.5`, `×-1`, `time keyframes`, or null. */
-  remapLabel() {
-    const r = this._remap;
-    if (!r) return null;
-    return r.timeKfs.length ? "time keyframes" : `\xD7${r.speed ?? 1}`;
-  }
-  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 Container();
-    wrapper.cullable = true;
-    wrapper.cullableChildren = true;
-    wrapper.cullArea = new Rectangle(0, 0, width, height);
-    const inner = new Container();
-    inner.cullable = true;
-    inner.cullableChildren = true;
-    wrapper.addChild(inner);
-    this.target = wrapper;
-    this.intrinsicWidth = width;
-    this.intrinsicHeight = height;
-    this._innerContainer = inner;
-    const base = timeRemapOf(this.spec);
-    const span = base ? contentLength(base, this.duration) : this.duration;
-    this._remap = base ? remapOf(this.spec, "time", span) : null;
-    this._contentSpan = span;
-    this._compositionShape = { width, height, duration: span };
-    const lateKeyframes = [];
-    for (const s of this.spec.sequences ?? []) {
-      lintSequence(s);
-      lintFocus(s, this.spec.sequences ?? []);
-      lintTiming(s, span, (message, kind) => kind === "late-keyframe" ? lateKeyframes.push(message) : console.warn(message));
-      lintText(s);
-      lintKeys(s);
-    }
-    for (const message of summarizeWarnings(lateKeyframes)) console.warn(message);
-    const crowd = maxConcurrentAdvanced(this.spec.sequences ?? [], span);
-    if (crowd >= MANY_ADVANCED) {
-      console.warn(`pixi-effects: ${describeLayer(this.spec)}: ${crowd} layers with an advanced blendMode are on screen at once (a composition with one counts each layer inside it, since its children blend one by one); each is a full-frame pass (about 2 ms on WebGL). Put fewer layers in the blend (or draw the glow as one layer), or use add / screen / multiply`);
-    }
-    this._children = await buildSequenceTree(
-      this.spec.sequences ?? [],
-      this._compositionShape,
-      this.root
-    );
-    this._resolveParents();
-    const layerNames = new Set(this._children.map((c) => c.spec.name).filter((n) => !!n));
-    for (const cam of this._children) {
-      if (!(cam instanceof CameraSequence)) continue;
-      cam.resolveFocusNames((name) => {
-        const hit = this._children.find((c) => c.spec.name === name && c.spec.threeD);
-        return hit ? layerInitialZ(hit.spec, hit.scope()) : void 0;
-      }, layerNames);
-    }
-    const blendSaid = /* @__PURE__ */ new Map();
-    const report = (message, spec) => {
-      const seen = blendSaid.get(message);
-      if (seen) seen.n++;
-      else blendSaid.set(message, { spec, n: 1 });
-    };
-    for (const child of this._children) {
-      if (child instanceof CameraSequence) {
-        this._cameras.push(child);
-        continue;
-      }
-      if (!child.target) continue;
-      const holder = this._parentOf.get(child);
-      const into = holder?.target ?? inner;
-      const maskSpec = child.spec.mask;
-      if (child.spec.threeD) {
-        const layer = new Layer3D(child, frameOf(child));
-        inner.addChild(layer.display);
-        this._layers3d.push(layer);
-        this._visual.push({ seq: child, layer });
-        const added3d = applyBlendMode(child.spec, layer.display, report);
-        if (added3d) this._blendOwned.push(added3d);
-        if (maskSpec) {
-          console.warn(`pixi-effects: ${describeLayer(child.spec)}: mask is not supported on threeD layers yet; ignored`);
-        }
-        continue;
-      }
-      const mode = child.spec.blendMode;
-      const eraseMask = !!maskSpec && child.spec.maskInverted === true && mode !== void 0 && mode !== "normal" && blendProblem(mode) === null;
-      const alphaMaskLosesBlend = !!maskSpec && (maskSpec.type === "text" || maskSpec.type === "image" || maskSpec.type === "video") && !eraseMask && mode !== void 0 && mode !== "normal" && blendProblem(mode) === null;
-      if (alphaMaskLosesBlend) {
-        report(`blendMode "${mode}" cannot be used together with ${maskSpec.type === "image" ? "an" : "a"} ${maskSpec.type} layer as the mask (the blend is lost); the layer is drawn normal. Put the ${maskSpec.type} on a layer of its own with the blendMode instead of masking with it, or use maskInverted`, child.spec);
-      }
-      let wrap;
-      if (eraseMask) {
-        wrap = new Container();
-        wrap.addChild(child.target);
-        let carrier = null;
-        if (isAdvancedBlend(mode)) carrier = blendFilterFor(mode);
-        else {
-          const f = new AlphaFilter({ alpha: 1 });
-          f.blendMode = mode;
-          carrier = f;
-        }
-        if (carrier) {
-          wrap.filters = [carrier];
-          this._blendOwned.push(carrier);
-        } else report(blendUnavailableMessage(mode), child.spec);
-        this._blendOwned.push(wrap);
-        into.addChild(wrap);
-      } else into.addChild(child.target);
-      if (holder) this._nested.push(child);
-      else this._visual.push({ seq: child, layer: null, wrap });
-      if (!wrap && !alphaMaskLosesBlend) {
-        const added = applyBlendMode(child.spec, child.target, report);
-        if (added) this._blendOwned.push(added);
-      }
-      if (maskSpec) {
-        const lifetime = maskSpec.at === void 0 ? { at: child.at, duration: maskSpec.duration ?? child.duration } : {};
-        const built = await buildSequenceTree([{ ...maskSpec, ...lifetime }], this._compositionShape, this.root);
-        const maskSeq = built[0];
-        if (maskSeq?.target) {
-          (wrap ?? into).addChild(maskSeq.target);
-          const inverse = child.spec.maskInverted ?? false;
-          const t = child.target;
-          if (wrap) {
-            const mt = maskSeq.target;
-            const mf = Array.isArray(mt.filters) && mt.filters.length > 0 ? mt.filters[mt.filters.length - 1] : null;
-            if (mf) mf.blendMode = "erase";
-            else mt.blendMode = "erase";
-          } else if (inverse || maskSpec.type === "text") {
-            const effect = new AlphaMask({ mask: maskSeq.target });
-            effect.inverse = inverse;
-            t.setMask?.({ mask: void 0, inverse });
-            t.addEffect(effect);
-          } else if (typeof t.setMask === "function") {
-            t.setMask({ mask: maskSeq.target, inverse });
-          } else {
-            t.mask = maskSeq.target;
-          }
-          child.maskSequence = maskSeq;
-          maskSeq.keepHidden = !wrap && (maskSpec.type === "image" || maskSpec.type === "video");
-        }
-      }
-    }
-    for (const [message, seen] of blendSaid) {
-      console.warn(`pixi-effects: ${describeLayer(seen.spec)}: ${message}${seen.n > 1 ? ` (and ${seen.n - 1} more layers have the same mistake)` : ""}`);
-    }
-    if (this._layers3d.length > 0) {
-      inner.sortableChildren = true;
-      this._visual.forEach((v, i) => {
-        (v.layer?.display ?? v.wrap ?? v.seq.target).zIndex = i;
-      });
-    } else if (this._cameras.length > 0) {
-      console.warn("pixi-effects: camera has no effect: this composition has no threeD layers");
-    }
-    this.buildFilters();
-  }
-  displayProps() {
-    const r = this._remap;
-    return r ? { initial: r.restInitial, keyframes: r.restKfs } : super.displayProps();
-  }
-  bindTimeline(timeline, offset = 0) {
-    super.bindTimeline(timeline, offset);
-    const remap = this._remap;
-    const childOffset = remap ? 0 : offset + this.at;
-    this._childBase = childOffset;
-    const target = remap ? gsap.timeline({ paused: true, defaults: { ease: "none" } }) : timeline;
-    for (const child of this._children) {
-      const own = gsap.timeline({ defaults: { ease: "none" } });
-      child.bindTimeline(own, childOffset);
-      child.maskSequence?.bindTimeline(own, childOffset);
-      target.add(own, 0);
-    }
-    if (remap) this._bindClock(timeline, target, remap, offset);
-    const overlap = findOverlap(this._cameras.map((c) => c.window()));
-    if (overlap) {
-      console.warn(`pixi-effects: cameras #${overlap[0] + 1} and #${overlap[1] + 1} overlap in time; the top-most one wins`);
-    }
-  }
-  /** Drive the local timeline `inner` from the clock, and put the clock's tweens on the outer `timeline`. */
-  _bindClock(timeline, inner, remap, offset) {
-    let last = NaN;
-    let cur = 0;
-    const clock = {
-      get time() {
-        return cur;
-      },
-      set time(v) {
-        cur = v;
-        if (v === last) return;
-        last = v;
-        inner.time(v);
-      }
-    };
-    this._inner = inner;
-    this._clock = clock;
-    const scope = this.scope();
-    if (remap.start !== void 0 && remap.timeKfs.length === 0) clock.time = remap.start;
-    bindClock(timeline, clock, "time", remap, this.duration, offset + this.at, scope);
-    inner.time(inner.duration());
-    inner.time(0);
-    last = NaN;
-    this._warnUnreachable(clockTable(remap, "time", this.duration, offset + this.at, scope, offset + this.at + this.duration), offset + this.at, offset + this.at + this.duration);
-  }
-  /**
-   * A child the clock never dwells in is never visible: say so. Its `at` is in THIS composition's local time, so the usual mistake is
-   * writing it in the outer time (or forgetting that speed 0.5 reaches only half as far). Decided by dwell, not by the clock's end
-   * points: a clock that arrives at the child's `at` and HOLDS there shows it for the whole hold; one that only touches it in a single
-   * instant (speed 0.5, a child at exactly the farthest local time) does not.
-   */
-  _warnUnreachable(table, from, to) {
-    const remap = this._remap;
-    const how = remap.timeKfs.length ? "time keyframes" : `speed ${remap.speed ?? 1}`;
-    const span = this._contentSpan;
-    const EPS = 1e-9;
-    for (const child of this._children) {
-      const at = child.at;
-      if (at >= span) continue;
-      const end = Math.min(at + (child.duration ?? span), span);
-      let dwell = 0;
-      for (let t = from; t <= to && dwell < 2; t += 1e-3) {
-        const v = table.at(t);
-        if (v >= at - EPS && v < end + EPS) dwell++;
-      }
-      if (dwell >= 2) continue;
-      console.warn(
-        `pixi-effects: ${describeLayer(child.spec)} starts at ${at}s of ${describeLayer(this.spec)}'s own time, but its clock only reaches ${Number(table.min.toFixed(3))}\u2013${Number(table.max.toFixed(3))}s (${how}), so it is never visible. Layers inside a remapped composition are placed in that composition's local time.`
-      );
-    }
-  }
-  /**
-   * Drawn children in stack order, with the display object that stands in for each (the mesh for a threeD layer).
-   * Null layers draw nothing and are left out; the layers inside them follow, with the null layers that carry them.
-   */
-  layers() {
-    const carriersOf = (seq) => {
-      const out = [];
-      for (let p = this._parentOf.get(seq); p; p = this._parentOf.get(p)) out.push(p);
-      return out;
-    };
-    return [...this._visual.map((v) => v.seq), ...this._nested].filter((seq) => !(seq instanceof NullSequence)).map((seq) => {
-      const layer = this._visual.find((v) => v.seq === seq)?.layer ?? null;
-      return {
-        seq,
-        display: layer?.display ?? seq.target,
-        threeD: layer !== null,
-        carriers: carriersOf(seq),
-        depthBlur: layer?.blur ?? 0
-      };
-    });
-  }
-  /** Match every `parent: 'name'` to a null layer; anything that cannot work is said out loud and drawn unparented. */
-  _resolveParents() {
-    const nulls = this._children.filter((c) => c instanceof NullSequence);
-    const nullNames = nulls.map((n) => n.spec.name).filter((n) => !!n);
-    const warned = /* @__PURE__ */ new Set();
-    for (const child of this._children) {
-      const want = child.spec.parent;
-      if (want === void 0) continue;
-      const who = describeLayer(child.spec);
-      if (child instanceof CameraSequence) {
-        console.warn(`pixi-effects: ${who}: a camera cannot have a parent; ignored`);
-        continue;
-      }
-      if (child.spec.threeD) {
-        console.warn(`pixi-effects: ${who}: a threeD layer cannot have a parent (parent "${want}" ignored)`);
-        continue;
-      }
-      const same = this._children.filter((c) => c.spec.name === want);
-      if (same.length === 0) {
-        const hint = suggestName(want, nullNames);
-        console.warn(`pixi-effects: ${who}: parent "${want}": no layer with that name${hint ? `; did you mean "${hint}"?` : ""} (the layer is drawn without a parent)`);
-        continue;
-      }
-      const holder = same.find((c) => c instanceof NullSequence);
-      if (!holder) {
-        console.warn(`pixi-effects: ${who}: parent "${want}" is a ${same[0].spec.type} layer; only { type: 'null' } layers can be parents (the layer is drawn without a parent)`);
-        continue;
-      }
-      if (same.length > 1 && !warned.has(want)) {
-        warned.add(want);
-        console.warn(`pixi-effects: ${same.length} layers are named "${want}"; parent "${want}" uses the first null layer with that name`);
-      }
-      if (holder === child) {
-        console.warn(`pixi-effects: ${who} is its own parent; ignored`);
-        continue;
-      }
-      this._parentOf.set(child, holder);
-    }
-    for (const start of this._children) {
-      const seen = /* @__PURE__ */ new Set([start]);
-      for (let p = this._parentOf.get(start); p; p = this._parentOf.get(p)) {
-        if (p === start) {
-          const names = [...seen].map((s) => s.spec.name ?? s.spec.type).join(" \u2192 ");
-          console.warn(`pixi-effects: parent cycle: ${names} \u2192 ${start.spec.name ?? start.spec.type}; the parent of "${start.spec.name ?? start.spec.type}" is ignored`);
-          this._parentOf.delete(start);
-          break;
-        }
-        if (seen.has(p)) break;
-        seen.add(p);
-      }
-    }
-  }
-  syncFrame() {
-    super.syncFrame();
-    for (const child of this._children) child.syncFrame();
-  }
-  updateSpace(t, host) {
-    const childT = this.childTime(t);
-    for (const child of this._children) child.updateSpace(childT, host);
-    if (this._layers3d.length === 0 || !this._compositionShape) return;
-    const { width, height } = this._compositionShape;
-    const compEnd = this._childBase + (this.duration ?? 0);
-    const active = pickActiveCamera(
-      this._cameras.map((cam2) => ({ cam: cam2, ...cam2.window() })),
-      childT,
-      compEnd
-    );
-    const cam = active ? active.cam.state() : homeCamera(width, height);
-    const basis = cameraBasis(cam, width, height);
-    for (const layer of this._layers3d) layer.update(host, basis);
-    this._applyDepthOfField(cam, basis);
-    const order = assignDepthOrder(
-      this._visual.map((v, i) => ({ stackIndex: i, threeD: v.layer !== null, depth: v.layer?.depth ?? 0 }))
-    );
-    this._visual.forEach((v, i) => {
-      if (v.layer) v.layer.display.zIndex = order[i];
-    });
-  }
-  /** Depth of field: each threeD layer is blurred by how far its depth is from the focal plane (a pure function of the camera and the layers). */
-  _applyDepthOfField(cam, basis) {
-    const aperture = cam.aperture ?? 0;
-    if (!(aperture > 0)) {
-      for (const l of this._layers3d) l.setBlur(0);
-      return;
-    }
-    const focusDepth = projectPoint(basis, { x: cam.lookAtX, y: cam.lookAtY, z: cam.focus ?? 0 }).depth;
-    if (!(focusDepth > NEAR)) {
-      if (!this._dofSaid.behind) {
-        this._dofSaid.behind = true;
-        console.warn(`pixi-effects: ${describeLayer(this.spec)}: the camera's focus (z = ${(cam.focus ?? 0).toFixed(0)}) is at or behind the camera, so nothing is blurred. Put focus in front of the camera (a z below the camera's z)`);
-      }
-      for (const l of this._layers3d) l.setBlur(0);
-      return;
-    }
-    let blurred = 0;
-    for (const l of this._layers3d) {
-      l.setBlur(l.display.visible ? blurRadius(aperture, basis.focal, l.depth, focusDepth) : 0);
-      if (l.blur > 0) blurred++;
-    }
-    if (blurred >= MANY_BLURRED && !this._dofSaid.many) {
-      this._dofSaid.many = true;
-      console.warn(`pixi-effects: ${describeLayer(this.spec)}: ${blurred} layers are blurred by depth of field at once; each costs a filter pass per frame (WebGPU more). Merge the far layers or lower aperture`);
-    }
-  }
-  collectAudio(out, baseTime) {
-    super.collectAudio(out, baseTime);
-    const remap = this._remap;
-    if (!remap) {
-      const childBase = baseTime + this.at;
-      for (const child of this._children) child.collectAudio(out, childBase);
-      return;
-    }
-    const inner = [];
-    for (const child of this._children) child.collectAudio(inner, 0);
-    const lo = baseTime + this.at, hi = lo + this.duration;
-    const table = clockTable(remap, "time", this.duration, lo, this.scope(), hi);
-    for (const d of inner) {
-      const prev = d.warp;
-      out.push({ ...d, warp: (t) => t < lo || t > hi ? NaN : prev ? prev(table.at(t)) : table.at(t) });
-    }
-  }
-  destroy() {
-    this._inner?.kill();
-    this._inner = null;
-    this._clock = null;
-    for (const l of this._layers3d) l.destroy();
-    this._layers3d = [];
-    for (const c of this._children) c.destroy();
-    for (const o of this._blendOwned) o.destroy();
-    this._blendOwned = [];
-    super.destroy();
-  }
-};
-function frameOf(child) {
-  if (child instanceof CompositionSequence) {
-    return () => ({ x: 0, y: 0, width: child.intrinsicWidth, height: child.intrinsicHeight });
-  }
-  return () => child.target.getLocalBounds();
-}
-
-export { CompositionSequence };
-//# sourceMappingURL=chunk-UQDEDYVM.js.map
-//# sourceMappingURL=chunk-UQDEDYVM.js.map