pixi-effects 0.22.0 → 0.25.0

package/dist/chunk-SY27HZC5.cjs

@@ -0,0 +1,1727 @@
+'use strict';
+
+var chunkDP37TTMO_cjs = require('./chunk-DP37TTMO.cjs');
+var chunk3DLYAPK7_cjs = require('./chunk-3DLYAPK7.cjs');
+var chunkECA2WNRX_cjs = require('./chunk-ECA2WNRX.cjs');
+var chunkTWZNOUM7_cjs = require('./chunk-TWZNOUM7.cjs');
+var pixi_js = require('pixi.js');
+var gsap = require('gsap');
+
+// src/space/lightChecks.ts
+var SOFT_LIGHTS = 3;
+var bagsOf = (spec) => {
+  const s = spec;
+  const out = [];
+  if (s.initial) out.push(s.initial);
+  for (const k of s.keyframes ?? []) for (const b of [k.set, k.to, k.from]) if (b) out.push(b);
+  return out;
+};
+var numbersOf = (spec, key) => bagsOf(spec).map((b) => b[key]).filter((v) => typeof v === "number" && Number.isFinite(v));
+var nameOf = (s, i) => s.name ? `"${s.name}"` : `#${i + 1}`;
+var KIND_ALIASES = {
+  directional: "parallel",
+  sun: "parallel",
+  sunlight: "parallel",
+  distant: "parallel",
+  omni: "point",
+  lamp: "point",
+  bulb: "point",
+  pointlight: "point",
+  spotlight: "spot",
+  cone: "spot",
+  ambience: "ambient",
+  global: "ambient",
+  fill: "ambient"
+};
+function lightKindProblem(kind) {
+  if (kind === void 0 || typeof kind === "string" && chunkDP37TTMO_cjs.LIGHT_KINDS.includes(kind)) return null;
+  const guess = typeof kind === "string" ? KIND_ALIASES[kind.toLowerCase()] ?? chunkTWZNOUM7_cjs.suggestName(kind, chunkDP37TTMO_cjs.LIGHT_KINDS) : null;
+  const shown = typeof kind === "string" ? `"${kind}"` : String(kind);
+  return `kind ${shown} is not a light kind${guess ? `; did you mean "${guess}"?` : ""} (use ${chunkDP37TTMO_cjs.LIGHT_KINDS.join(", ")}); point is used`;
+}
+var LIGHT_ALIASES = {
+  pointOfInterest: 'did you mean "lookAtX / lookAtY / lookAtZ"?',
+  target: 'did you mean "lookAtX / lookAtY / lookAtZ"?',
+  lookAt: 'did you mean "lookAtX / lookAtY / lookAtZ"?',
+  angle: 'did you mean "coneAngle"?',
+  cone: 'did you mean "coneAngle"?',
+  spread: 'did you mean "coneAngle"?',
+  feather: 'did you mean "coneFeather"?',
+  penumbra: 'did you mean "coneFeather" (the cone edge) or "shadowDiffusion" (the shadow edge)?',
+  castShadows: 'did you mean "castsShadows"?',
+  castShadow: 'did you mean "castsShadows"?',
+  shadows: 'did you mean "castsShadows"?',
+  shadow: 'did you mean "castsShadows"?',
+  brightness: 'did you mean "intensity"?',
+  strength: 'did you mean "intensity"?',
+  distance: 'did you mean "radius" (where the falloff starts) or "falloffDistance"?',
+  range: 'did you mean "radius" or "falloffDistance"?'
+};
+function lightLayerProblems(spec) {
+  const out = [];
+  const raw = spec;
+  const kind = lightKindProblem(raw.kind);
+  if (kind) out.push(kind);
+  if (raw.falloff !== void 0 && !chunkDP37TTMO_cjs.FALLOFFS.includes(raw.falloff)) {
+    const guess = typeof raw.falloff === "string" ? chunkTWZNOUM7_cjs.suggestName(raw.falloff, chunkDP37TTMO_cjs.FALLOFFS) : null;
+    out.push(`falloff ${JSON.stringify(raw.falloff)} is not supported${guess ? `; did you mean "${guess}"?` : ""} (use ${chunkDP37TTMO_cjs.FALLOFFS.join(", ")}); none is used`);
+  }
+  for (const k of Object.keys(raw)) {
+    if (chunkDP37TTMO_cjs.LIGHT_PROPS.includes(k) || k === "intensity" || k === "shadowDarkness" || k === "shadowDiffusion") {
+      out.push(`"${k}" must go inside initial / keyframes, not on the light itself`);
+    } else if (LIGHT_ALIASES[k]) out.push(`"${k}" is not a property \u2014 ${LIGHT_ALIASES[k]}`);
+  }
+  const explained = new Set(Object.keys(LIGHT_ALIASES));
+  for (const k of chunkECA2WNRX_cjs.collectPropKeys(spec)) {
+    if (LIGHT_ALIASES[k]) out.push(`"${k}" is not a property \u2014 ${LIGHT_ALIASES[k]}`);
+    else if (!explained.has(k) && !chunkDP37TTMO_cjs.LIGHT_PROPS.includes(k)) out.push(`"${k}" has no effect on a light (use ${chunkDP37TTMO_cjs.LIGHT_PROPS.join(", ")})`);
+  }
+  if (numbersOf(spec, "coneFeather").some((v) => v > 1 || v < 0)) out.push("coneFeather is 0..1 (the soft part of the cone edge, as a fraction of the half angle); it is clamped");
+  const big = numbersOf(spec, "intensity").find((v) => v > 10);
+  if (big !== void 0) out.push(`intensity ${big} looks like a percentage: it is a multiplier (1 = full, 0.25 = a quarter); did you mean ${big / 100}?`);
+  const kindNow = typeof raw.kind === "string" && chunkDP37TTMO_cjs.LIGHT_KINDS.includes(raw.kind) ? raw.kind : "point";
+  const has = (...keys) => keys.filter((k) => bagsOf(spec).some((b) => b[k] !== void 0));
+  const falloffOn = raw.falloff === "smooth" || raw.falloff === "inverseSquare";
+  if (kindNow === "ambient" && raw.castsShadows) out.push("an ambient light has no direction, so it makes no shadow: castsShadows is ignored (put it on a point, spot or parallel light)");
+  const dist = has("radius", "falloffDistance");
+  if (dist.length && !falloffOn && kindNow !== "ambient" && kindNow !== "parallel") out.push(`${dist.join(" / ")} only matter with falloff: 'smooth' or 'inverseSquare' (the default 'none' does not fade with distance): write falloff on the layer`);
+  const shadowNums = has("shadowDarkness", "shadowDiffusion");
+  if (shadowNums.length && !raw.castsShadows) out.push(`${shadowNums.join(" / ")} only matter with castsShadows: true on the light (and on the layers that cast)`);
+  const cone = has("coneAngle", "coneFeather");
+  if (cone.length && kindNow !== "spot") out.push(`${cone.join(" / ")} only matter for kind: 'spot' (this light is ${kindNow})`);
+  if (kindNow === "parallel" && raw.falloff !== void 0 && raw.falloff !== "none") out.push("a parallel light has no distance, so falloff has no effect on it");
+  const init = spec.initial ?? {};
+  const pos = ["x", "y", "z"].map((k) => init[k]), look = ["lookAtX", "lookAtY", "lookAtZ"].map((k) => init[k]);
+  if ((kindNow === "spot" || kindNow === "parallel") && pos.every((v) => typeof v === "number") && pos.every((v, i) => v === look[i])) {
+    out.push("lookAt equals the position, so the light has no direction and lights nothing: move lookAtX / lookAtY / lookAtZ to where it should point");
+  }
+  if (spec.threeD) out.push("a light has no picture, so threeD has no effect on it (write it without threeD)");
+  return out;
+}
+function lightSetProblems(layers) {
+  const lights = layers.filter((l) => l.type === "light");
+  if (lights.length === 0) return [];
+  const out = [];
+  const kindOf = (l) => l.kind ?? "point";
+  if (!lights.some((l) => kindOf(l) === "ambient")) {
+    out.push("there is no ambient light, so what no light reaches is black; add { type: 'light', kind: 'ambient', initial: { intensity: 0.25 } }");
+  }
+  const direct = lights.filter((l) => kindOf(l) !== "ambient");
+  if (direct.length > chunkDP37TTMO_cjs.MAX_LIGHTS) {
+    const dropped = direct.slice(chunkDP37TTMO_cjs.MAX_LIGHTS).map((l) => nameOf(l, layers.indexOf(l)));
+    out.push(`${direct.length} lights, but at most ${chunkDP37TTMO_cjs.MAX_LIGHTS} are used (the first ${chunkDP37TTMO_cjs.MAX_LIGHTS}, in layer order); ${dropped.join(", ")} and later are dropped. Use fewer lights`);
+  }
+  const lightsCast = lights.some((l) => kindOf(l) !== "ambient" && l.castsShadows);
+  const casters = layers.filter((l) => l.type !== "light" && l.castsShadows && l.threeD);
+  if (casters.length > 0 && !lightsCast) out.push(`${casters.length} layer${casters.length > 1 ? "s have" : " has"} castsShadows but no light has castsShadows: add castsShadows: true to the light that should make the shadows`);
+  if (lightsCast && casters.length === 0) out.push("a light has castsShadows but no layer has castsShadows: add castsShadows: true to the threeD layers that should cast a shadow");
+  if (lightsCast && casters.length > chunkDP37TTMO_cjs.MAX_CASTERS) {
+    const dropped = casters.slice(chunkDP37TTMO_cjs.MAX_CASTERS).map((c) => nameOf(c, layers.indexOf(c)));
+    out.push(`${casters.length} layers cast shadows, but a layer receives shadows from at most ${chunkDP37TTMO_cjs.MAX_CASTERS} (the first ${chunkDP37TTMO_cjs.MAX_CASTERS}, in layer order); ${dropped.join(", ")} and later cast none`);
+  }
+  const softLights = lights.filter((l) => l.castsShadows && numbersOf(l, "shadowDiffusion").some((v) => v > 0));
+  if (softLights.length >= SOFT_LIGHTS) {
+    out.push(`${softLights.length} lights make soft shadows (shadowDiffusion above 0): each is a 16-sample search per pixel and per caster, costly (about 20 ms more a frame at 1080p with 20 lit layers in our measurement). Give shadowDiffusion to one or two lights; the others keep hard shadows`);
+  }
+  layers.forEach((l, i) => {
+    if (l.type === "light" || l.threeD) return;
+    const bad = ["castsShadows", "lit"].filter((k) => l[k] !== void 0);
+    if (bad.length) out.push(`layer ${nameOf(l, i)}: ${bad.map((k) => `"${k}"`).join(" and ")} only work${bad.length > 1 ? "" : "s"} on threeD layers (add threeD: true; a 2D layer is not lit and casts no shadow)`);
+  });
+  return out;
+}
+function fogProblems(camera) {
+  const out = [];
+  const near = numbersOf(camera, "fogNear")[0], far = numbersOf(camera, "fogFar")[0];
+  if (near !== void 0 && far !== void 0 && far <= near) out.push(`fogFar (${far}) is not beyond fogNear (${near}): the fog is a hard step at fogNear. Make fogFar larger (the distance where the fog is complete)`);
+  if (numbersOf(camera, "fogAmount").some((v) => v < 0 || v > 1)) out.push("fogAmount is 0..1 (how much of the fog colour the farthest things get); it is clamped");
+  return out;
+}
+
+// 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 pixi_js.Filter {
+  constructor(radius = 8) {
+    super({
+      glProgram: pixi_js.GlProgram.from({ vertex: GL_VERTEX, fragment: GL_FRAGMENT, name: "disc-blur" }),
+      gpuProgram: pixi_js.GpuProgram.from({ vertex: { source: WGSL, entryPoint: "mainVertex" }, fragment: { source: WGSL, entryPoint: "mainFragment" } }),
+      resources: { disc: new pixi_js.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;
+  }
+};
+var localUniformBit = {
+  name: "local-uniform-bit",
+  vertex: {
+    header: (
+      /* wgsl */
+      `
+      struct LocalUniforms { uTransformMatrix:mat3x3<f32>, uColor:vec4<f32>, uRound:f32, }
+      @group(1) @binding(0) var<uniform> localUniforms : LocalUniforms;`
+    ),
+    main: (
+      /* wgsl */
+      `
+      vColor *= localUniforms.uColor;
+      modelMatrix *= localUniforms.uTransformMatrix;`
+    ),
+    end: (
+      /* wgsl */
+      `
+      if(localUniforms.uRound == 1) { vPosition = vec4(roundPixels(vPosition.xy, globalUniforms.uResolution), vPosition.zw); }`
+    )
+  }
+};
+var textureBit = {
+  name: "texture-bit",
+  vertex: {
+    header: `struct TextureUniforms { uTextureMatrix:mat3x3<f32>, }
+      @group(2) @binding(2) var<uniform> textureUniforms : TextureUniforms;`,
+    main: `uv = (textureUniforms.uTextureMatrix * vec3(uv, 1.0)).xy;`
+  },
+  fragment: {
+    header: `@group(2) @binding(0) var uTexture: texture_2d<f32>;
+      @group(2) @binding(1) var uSampler: sampler;`,
+    main: `outColor = textureSample(uTexture, uSampler, vUV);`
+  }
+};
+var roundPixelsBit = {
+  name: "round-pixels-bit",
+  vertex: { header: `fn roundPixels(position: vec2<f32>, targetSize: vec2<f32>) -> vec2<f32> { return (floor(((position * 0.5 + 0.5) * targetSize) + 0.5) / targetSize) * 2.0 - 1.0; }` }
+};
+var ML = chunkDP37TTMO_cjs.MAX_LIGHTS;
+var MC = chunkDP37TTMO_cjs.MAX_CASTERS;
+var TAPS = chunkDP37TTMO_cjs.SHADOW_TAPS;
+var SHADOW_KEYS = Array.from({ length: MC }, (_, j) => `uShadow${j}`);
+var WGSL_SHADOW_DECLS = SHADOW_KEYS.map((k, j) => `      @group(2) @binding(${4 + j}) var ${k}: texture_2d<f32>;`).join("\n");
+var WGSL_SHADOW_PICK = SHADOW_KEYS.map((k, j) => (j === 0 ? "" : "else ") + `if (j == ${j}) { a = textureSampleLevel(${k}, uSampler, uv, 0.0).a; }`).join(" ");
+var GLSL_SHADOW_DECLS = SHADOW_KEYS.map((k) => `uniform sampler2D ${k};`).join(" ");
+var GLSL_SHADOW_PICK = SHADOW_KEYS.map((k, j) => (j === MC - 1 ? "" : `j == ${j} ? textureLod(${k}, uv, 0.0).a : `) + (j === MC - 1 ? `textureLod(${k}, uv, 0.0).a` : "")).join("");
+var STRUCT_WGSL = (
+  /* wgsl */
+  `
+      struct LightUniforms {
+        uOrigin: vec4<f32>, uAxisU: vec4<f32>, uAxisV: vec4<f32>, uCam: vec4<f32>, uCamFwd: vec4<f32>,
+        uAmbient: vec4<f32>, uFogColor: vec4<f32>, uFogRange: vec4<f32>,
+        uLPos: array<vec4<f32>, ${ML}>, uLDir: array<vec4<f32>, ${ML}>, uLCol: array<vec4<f32>, ${ML}>, uLFall: array<vec4<f32>, ${ML}>, uLShadow: array<vec4<f32>, ${ML}>,
+        uCO: array<vec4<f32>, ${MC}>, uCU: array<vec4<f32>, ${MC}>, uCV: array<vec4<f32>, ${MC}>,
+      };
+      @group(2) @binding(3) var<uniform> lightUniforms : LightUniforms;
+`
+);
+var lightBit = {
+  name: "light-bit",
+  vertex: {
+    header: (
+      /* wgsl */
+      `${STRUCT_WGSL}
+      @out vPW: vec4<f32>;`
+    ),
+    // world position over camera depth, and 1 / depth: interpolated per fragment and divided, they give the exact (perspective-correct) point
+    end: (
+      /* wgsl */
+      `
+      {
+        let Pv = lightUniforms.uOrigin.xyz + vUV.x * lightUniforms.uAxisU.xyz + vUV.y * lightUniforms.uAxisV.xyz;
+        let zc = max(dot(Pv - lightUniforms.uCam.xyz, lightUniforms.uCamFwd.xyz), 1e-3);
+        vPW = vec4<f32>(Pv / zc, 1.0 / zc);
+      }`
+    )
+  },
+  fragment: {
+    header: (
+      /* wgsl */
+      `
+${STRUCT_WGSL}
+      @in vPW: vec4<f32>;
+${WGSL_SHADOW_DECLS}
+
+      fn casterAlpha(j: i32, uv: vec2<f32>) -> f32 {
+        let inside = step(0.0, uv.x) * step(uv.x, 1.0) * step(0.0, uv.y) * step(uv.y, 1.0);
+        var a = 0.0;
+        ${WGSL_SHADOW_PICK}
+        return a * inside;
+      }
+
+      fn shadowAt(P: vec3<f32>, i: i32) -> f32 {
+        let lp = lightUniforms.uLPos[i]; let ld = lightUniforms.uLDir[i];
+        let parallel = lp.w > 2.5;
+        var occl = 0.0;
+        for (var j = 0; j < ${MC}; j++) {
+          if (f32(j) >= lightUniforms.uAxisU.w) { break; }
+          let Co = lightUniforms.uCO[j].xyz; let Cu = lightUniforms.uCU[j].xyz; let Cv = lightUniforms.uCV[j].xyz;
+          let Nc = cross(Cu, Cv);
+          var D = lp.xyz - P;
+          if (parallel) { D = -ld.xyz * 100000.0; }
+          let denom = dot(D, Nc);
+          if (abs(denom) < 1e-9) { continue; }
+          let t = dot(Co - P, Nc) / denom;
+          if (t <= 1e-4 || t >= 1.0) { continue; }
+          let H = P + t * D;
+          let uv = vec2<f32>(dot(H - Co, Cu) / dot(Cu, Cu), dot(H - Co, Cv) / dot(Cv, Cv));
+          let lenD = length(D);
+          let far = select((1.0 - t) * lenD, 1000.0, parallel);
+          let w = lightUniforms.uLShadow[i].y * (t * lenD) / max(far, 1.0);
+          let r = vec2<f32>(w / length(Cu), w / length(Cv));
+          var a = 0.0;
+          if (w * w > 0.0) {
+            for (var k = 0; k < ${TAPS}; k++) {
+              let rr = sqrt((f32(k) + 0.5) / ${TAPS}.0);
+              let an = f32(k) * 2.39996323;
+              a += casterAlpha(j, uv + vec2<f32>(cos(an), sin(an)) * rr * r);
+            }
+            a = a / ${TAPS}.0;
+          } else { a = casterAlpha(j, uv); }
+          occl = max(occl, a);
+        }
+        return 1.0 - occl * lightUniforms.uLShadow[i].x;
+      }
+    `
+    ),
+    end: (
+      /* wgsl */
+      `
+      {
+        let P = vPW.xyz / vPW.w;
+        if (lightUniforms.uCam.w > 0.5) {
+          var N = normalize(cross(lightUniforms.uAxisU.xyz, lightUniforms.uAxisV.xyz));
+          if (dot(N, lightUniforms.uCam.xyz - P) < 0.0) { N = -N; }
+          var light = lightUniforms.uAmbient.rgb;
+          for (var i = 0; i < ${ML}; i++) {
+            if (f32(i) >= lightUniforms.uOrigin.w) { break; }
+            let lp = lightUniforms.uLPos[i]; let ld = lightUniforms.uLDir[i]; let lc = lightUniforms.uLCol[i]; let lf = lightUniforms.uLFall[i];
+            var L = -ld.xyz;
+            var dist = 0.0;
+            if (lp.w < 2.5) { let d = lp.xyz - P; dist = length(d); L = d / max(dist, 1e-4); }
+            let ndl = max(dot(N, L), 0.0);
+            var att = 1.0;
+            if (lp.w < 2.5) {
+              if (lf.x > 0.5 && lf.x < 1.5) { att = 1.0 - smoothstep(lf.y, lf.y + max(lf.z, 1e-3), dist); }
+              else if (lf.x > 1.5) { att = min(1.0, (lf.y * lf.y) / max(dist * dist, 1e-6)); }
+            }
+            var cone = 1.0;
+            if (lp.w > 1.5 && lp.w < 2.5) { cone = smoothstep(ld.w, lc.w, dot(-L, ld.xyz)); }
+            var sh = 1.0;
+            if (lf.w > 0.5 && ndl * att * cone > 0.0) { sh = shadowAt(P, i); }
+            light += lc.rgb * (ndl * att * cone * sh);
+          }
+          finalColor = vec4<f32>(min(finalColor.rgb * light, vec3<f32>(finalColor.a)), finalColor.a);
+        }
+        if (lightUniforms.uFogRange.w > 0.5) {
+          let depth = dot(P - lightUniforms.uCam.xyz, lightUniforms.uCamFwd.xyz);
+          let f = clamp((depth - lightUniforms.uFogRange.x) / max(lightUniforms.uFogRange.y - lightUniforms.uFogRange.x, 1e-3), 0.0, 1.0) * lightUniforms.uFogColor.a;
+          finalColor = vec4<f32>(mix(finalColor.rgb, lightUniforms.uFogColor.rgb * finalColor.a, f), finalColor.a);
+        }
+      }
+    `
+    )
+  }
+};
+var lightBitGl = {
+  fragment: {
+    header: (
+      /* glsl */
+      `
+      uniform vec4 uOrigin; uniform vec4 uAxisU; uniform vec4 uAxisV; uniform vec4 uCam; uniform vec4 uCamFwd;
+      uniform vec4 uAmbient; uniform vec4 uFogColor; uniform vec4 uFogRange;
+      uniform vec4 uLPos[${ML}]; uniform vec4 uLDir[${ML}]; uniform vec4 uLCol[${ML}]; uniform vec4 uLFall[${ML}]; uniform vec4 uLShadow[${ML}];
+      uniform vec4 uCO[${MC}]; uniform vec4 uCU[${MC}]; uniform vec4 uCV[${MC}];
+      ${GLSL_SHADOW_DECLS}
+
+      float casterAlpha(int j, vec2 uv) {
+        float inside = step(0.0, uv.x) * step(uv.x, 1.0) * step(0.0, uv.y) * step(uv.y, 1.0);
+        float a = ${GLSL_SHADOW_PICK};
+        return a * inside;
+      }
+
+      float shadowAt(vec3 P, int i) {
+        vec4 lp = uLPos[i]; vec4 ld = uLDir[i];
+        bool parallel = lp.w > 2.5;
+        float occl = 0.0;
+        for (int j = 0; j < ${MC}; j++) {
+          if (float(j) >= uAxisU.w) break;
+          vec3 Co = uCO[j].xyz; vec3 Cu = uCU[j].xyz; vec3 Cv = uCV[j].xyz;
+          vec3 Nc = cross(Cu, Cv);
+          vec3 D = parallel ? -ld.xyz * 100000.0 : lp.xyz - P;
+          float denom = dot(D, Nc);
+          if (abs(denom) < 1e-9) continue;
+          float t = dot(Co - P, Nc) / denom;
+          if (t <= 1e-4 || t >= 1.0) continue;
+          vec3 H = P + t * D;
+          vec2 uv = vec2(dot(H - Co, Cu) / dot(Cu, Cu), dot(H - Co, Cv) / dot(Cv, Cv));
+          float lenD = length(D);
+          float far = parallel ? 1000.0 : (1.0 - t) * lenD;
+          float w = uLShadow[i].y * (t * lenD) / max(far, 1.0);
+          vec2 r = vec2(w / length(Cu), w / length(Cv));
+          float a = 0.0;
+          if (w * w > 0.0) {
+            for (int k = 0; k < ${TAPS}; k++) {
+              float rr = sqrt((float(k) + 0.5) / ${TAPS}.0);
+              float an = float(k) * 2.39996323;
+              a += casterAlpha(j, uv + vec2(cos(an), sin(an)) * rr * r);
+            }
+            a /= ${TAPS}.0;
+          } else { a = casterAlpha(j, uv); }
+          occl = max(occl, a);
+        }
+        return 1.0 - occl * uLShadow[i].x;
+      }
+    `
+    ),
+    end: (
+      /* glsl */
+      `
+      {
+        vec3 P = vPW.xyz / vPW.w;
+        if (uCam.w > 0.5) {
+          vec3 N = normalize(cross(uAxisU.xyz, uAxisV.xyz));
+          if (dot(N, uCam.xyz - P) < 0.0) N = -N;
+          vec3 light = uAmbient.rgb;
+          for (int i = 0; i < ${ML}; i++) {
+            if (float(i) >= uOrigin.w) break;
+            vec4 lp = uLPos[i]; vec4 ld = uLDir[i]; vec4 lc = uLCol[i]; vec4 lf = uLFall[i];
+            vec3 L = -ld.xyz;
+            float dist = 0.0;
+            if (lp.w < 2.5) { vec3 d = lp.xyz - P; dist = length(d); L = d / max(dist, 1e-4); }
+            float ndl = max(dot(N, L), 0.0);
+            float att = 1.0;
+            if (lp.w < 2.5) {
+              if (lf.x > 0.5 && lf.x < 1.5) att = 1.0 - smoothstep(lf.y, lf.y + max(lf.z, 1e-3), dist);
+              else if (lf.x > 1.5) att = min(1.0, (lf.y * lf.y) / max(dist * dist, 1e-6));
+            }
+            float cone = 1.0;
+            if (lp.w > 1.5 && lp.w < 2.5) cone = smoothstep(ld.w, lc.w, dot(-L, ld.xyz));
+            float sh = 1.0;
+            if (lf.w > 0.5 && ndl * att * cone > 0.0) sh = shadowAt(P, i);
+            light += lc.rgb * (ndl * att * cone * sh);
+          }
+          finalColor.rgb = min(finalColor.rgb * light, vec3(finalColor.a));
+        }
+        if (uFogRange.w > 0.5) {
+          float depth = dot(P - uCam.xyz, uCamFwd.xyz);
+          float f = clamp((depth - uFogRange.x) / max(uFogRange.y - uFogRange.x, 1e-3), 0.0, 1.0) * uFogColor.a;
+          finalColor.rgb = mix(finalColor.rgb, uFogColor.rgb * finalColor.a, f);
+        }
+      }
+    `
+    )
+  }
+};
+var GL_VERTEX2 = `#version 300 es
+in vec2 aPosition;
+in vec2 aUV;
+out vec4 vColor;
+out vec2 vUV;
+out vec4 vPW;
+uniform vec4 uOrigin; uniform vec4 uAxisU; uniform vec4 uAxisV; uniform vec4 uCam; uniform vec4 uCamFwd;
+uniform mat3 uProjectionMatrix; uniform mat3 uWorldTransformMatrix; uniform vec4 uWorldColorAlpha; uniform vec2 uResolution;
+uniform mat3 uTransformMatrix; uniform vec4 uColor; uniform float uRound;
+uniform mat3 uTextureMatrix;
+vec2 roundPixels(vec2 position, vec2 targetSize) { return (floor(((position * 0.5 + 0.5) * targetSize) + 0.5) / targetSize) * 2.0 - 1.0; }
+void main(void) {
+  mat3 modelMatrix = uTransformMatrix;
+  vColor = uColor;
+  vUV = (uTextureMatrix * vec3(aUV, 1.0)).xy;
+  mat3 mvp = uProjectionMatrix * uWorldTransformMatrix * modelMatrix;
+  gl_Position = vec4((mvp * vec3(aPosition, 1.0)).xy, 0.0, 1.0);
+  vColor *= uWorldColorAlpha;
+  if (uRound == 1.) gl_Position.xy = roundPixels(gl_Position.xy, uResolution);
+  vec3 Pv = uOrigin.xyz + vUV.x * uAxisU.xyz + vUV.y * uAxisV.xyz;
+  float zc = max(dot(Pv - uCam.xyz, uCamFwd.xyz), 1e-3);
+  vPW = vec4(Pv / zc, 1.0 / zc);
+}`;
+var GL_FRAGMENT2 = `#version 300 es
+precision highp float;
+in vec4 vColor;
+in vec2 vUV;
+in vec4 vPW;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+${lightBitGl.fragment.header}
+void main(void) {
+  vec4 outColor = texture(uTexture, vUV);
+  finalColor = outColor * vColor;
+  ${lightBitGl.fragment.end}
+}`;
+var programs = null;
+function getPrograms() {
+  programs ??= {
+    // pixi compiles high-shader GLSL as WebGL1-compatible (no textureLod, no dynamic uniform-array index): the GL program is written as ES 3.00
+    gl: pixi_js.GlProgram.from({ name: "lit-mesh", vertex: GL_VERTEX2, fragment: GL_FRAGMENT2 }),
+    gpu: pixi_js.compileHighShaderGpuProgram({ name: "lit-mesh", bits: [localUniformBit, textureBit, roundPixelsBit, lightBit] })
+  };
+  return programs;
+}
+var LitMaterial = class {
+  shader;
+  u;
+  constructor() {
+    const { gl, gpu } = getPrograms();
+    const v4 = () => ({ value: new Float32Array(4), type: "vec4<f32>" });
+    const arr = (n) => ({ value: new Float32Array(4 * n), type: "vec4<f32>", size: n });
+    this.u = new pixi_js.UniformGroup({
+      uOrigin: v4(),
+      uAxisU: v4(),
+      uAxisV: v4(),
+      uCam: v4(),
+      uCamFwd: v4(),
+      uAmbient: v4(),
+      uFogColor: v4(),
+      uFogRange: v4(),
+      uLPos: arr(ML),
+      uLDir: arr(ML),
+      uLCol: arr(ML),
+      uLFall: arr(ML),
+      uLShadow: arr(ML),
+      uCO: arr(MC),
+      uCU: arr(MC),
+      uCV: arr(MC)
+    });
+    this.shader = new pixi_js.Shader({
+      glProgram: gl,
+      gpuProgram: gpu,
+      resources: {
+        uTexture: pixi_js.Texture.EMPTY.source,
+        uSampler: pixi_js.Texture.EMPTY.source.style,
+        textureUniforms: { uTextureMatrix: { type: "mat3x3<f32>", value: new pixi_js.Matrix() } },
+        lightUniforms: this.u,
+        ...Object.fromEntries(SHADOW_KEYS.map((k) => [k, pixi_js.Texture.EMPTY.source]))
+      }
+    });
+  }
+  setTexture(src) {
+    if (this.shader.resources.uTexture !== src) {
+      this.shader.resources.uTexture = src;
+      this.shader.resources.uSampler = src.style;
+    }
+  }
+  update(frame, cam, lights, fog, casters) {
+    const U = this.u.uniforms;
+    const nc = Math.min(casters.length, MC);
+    U.uOrigin.set([frame.o.x, frame.o.y, frame.o.z, lights ? lights.count : 0]);
+    U.uAxisU.set([frame.u.x, frame.u.y, frame.u.z, nc]);
+    U.uAxisV.set([frame.v.x, frame.v.y, frame.v.z, 0]);
+    U.uCam.set([cam.x, cam.y, cam.z, lights ? 1 : 0]);
+    U.uCamFwd.set([cam.fx, cam.fy, cam.fz, 0]);
+    if (lights) {
+      U.uAmbient.set([lights.ambient[0], lights.ambient[1], lights.ambient[2], 0]);
+      U.uLPos.set(lights.pos);
+      U.uLDir.set(lights.dir);
+      U.uLCol.set(lights.col);
+      U.uLFall.set(lights.fall);
+      U.uLShadow.set(lights.shadow);
+    }
+    if (fog) {
+      U.uFogColor.set([fog.r, fog.g, fog.b, fog.amount]);
+      U.uFogRange.set([fog.near, fog.far, 0, 1]);
+    } else U.uFogRange.set([0, 0, 0, 0]);
+    const keys = SHADOW_KEYS;
+    for (let j = 0; j < MC; j++) {
+      const c = casters[j];
+      if (c && j < nc) {
+        U.uCO.set([c.frame.o.x, c.frame.o.y, c.frame.o.z, 0], 4 * j);
+        U.uCU.set([c.frame.u.x, c.frame.u.y, c.frame.u.z, 0], 4 * j);
+        U.uCV.set([c.frame.v.x, c.frame.v.y, c.frame.v.z, 0], 4 * j);
+        if (this.shader.resources[keys[j]] !== c.source) this.shader.resources[keys[j]] = c.source;
+      } else if (this.shader.resources[keys[j]] !== pixi_js.Texture.EMPTY.source) this.shader.resources[keys[j]] = pixi_js.Texture.EMPTY.source;
+    }
+    this.u.update();
+  }
+  destroy() {
+    this.shader.destroy();
+  }
+};
+
+// 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) * chunkDP37TTMO_cjs.DEG,
+    rotationY: (c.rotationY ?? 0) * chunkDP37TTMO_cjs.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 pixi_js.PerspectiveMesh({ texture: pixi_js.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;
+  /** The plane in world space from the last update (a texture uv of 0..1 maps to `o + u·U + v·V`): what shading and shadows need. */
+  world = null;
+  /** The lit shader: made only when the composition has a light or fog (a composition with neither makes nothing). */
+  material = null;
+  /** This layer's own texture (what a shadow reads), or null before the first draw. */
+  get source() {
+    return this.rt?.source ?? null;
+  }
+  warnedLit = false;
+  /** The spec of the layer this draws (for `lit`, `castsShadows`). */
+  get spec() {
+    return this.seq.spec;
+  }
+  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 = chunkDP37TTMO_cjs.projectLayer(readLayerTransform(target), frame, basis);
+    this.depth = projected.depth;
+    {
+      const lt = readLayerTransform(target);
+      const o = chunkDP37TTMO_cjs.layerToWorld(lt, frame.x, frame.y);
+      const pu = chunkDP37TTMO_cjs.layerToWorld(lt, frame.x + frame.width, frame.y);
+      const pv = chunkDP37TTMO_cjs.layerToWorld(lt, frame.x, frame.y + frame.height);
+      this.world = { o, u: { x: pu.x - o.x, y: pu.y - o.y, z: pu.z - o.z }, v: { x: pv.x - o.x, y: pv.y - o.y, z: pv.z - o.z } };
+    }
+    if (!projected.visible) {
+      if (!this.warnedBehind) {
+        this.warnedBehind = true;
+        if (this.seq.spec.hideBehindCamera) return this.hide();
+        if (projected.depth > chunkDP37TTMO_cjs.NEAR) {
+          console.warn(
+            `pixi-effects: ${chunkECA2WNRX_cjs.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: ${chunkECA2WNRX_cjs.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 pixi_js.Matrix().translate(-frame.x, -frame.y),
+      clear: true,
+      clearColor: [0, 0, 0, 0]
+    });
+    this.display.geometry.setCorners(...projected.corners);
+    this.material?.setTexture(this.rt.source);
+    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 > chunkDP37TTMO_cjs.MIN_BLUR ? Math.min(radius, chunkDP37TTMO_cjs.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 (chunk3DLYAPK7_cjs.isAdvancedBlend(this.blendWas)) {
+        this.blendFilter = chunk3DLYAPK7_cjs.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;
+  }
+  /**
+   * Turn the lit shader on (made once) or off. Returns it, or null when it is off or cannot be made on this renderer (said once: the layer
+   * then draws unlit, as it did before there were lights).
+   */
+  setLit(on) {
+    if (on && !this.material) {
+      try {
+        this.material = new LitMaterial();
+      } catch (err) {
+        if (!this.warnedLit) {
+          this.warnedLit = true;
+          console.warn(`pixi-effects: ${chunkECA2WNRX_cjs.describeLayer(this.seq.spec)}: the lighting shader could not be made on this renderer (${err?.message ?? err}); the layer is drawn unlit`);
+        }
+        return null;
+      }
+      if (this.rt) this.material.setTexture(this.rt.source);
+      this.display.shader = this.material.shader;
+    } else if (!on && this.material) {
+      this.display.shader = null;
+      this.material.destroy();
+      this.material = null;
+    }
+    return this.material;
+  }
+  destroy() {
+    this.setLit(false);
+    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 = pixi_js.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", "fogNear", "fogFar", "fogColor", "fogAmount"];
+var NEEDS_THREE_D = ["z", "rotationX", "rotationY"];
+var CAMERA_ONLY = ["focus", "aperture", "fogNear", "fogFar", "fogColor", "fogAmount"];
+var SKEW_KEYS = ["skew", "skewX", "skewY"];
+function lintSequence(spec, warn = defaultWarn) {
+  const who = chunkECA2WNRX_cjs.describeLayer(spec);
+  const keys = chunkECA2WNRX_cjs.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 === "light") {
+    for (const m of lightLayerProblems(spec)) warn(`pixi-effects: ${who}: ${m}`);
+    return;
+  }
+  if (spec.type === "camera") {
+    for (const m of fogProblems(spec)) warn(`pixi-effects: ${who}: ${m}`);
+    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 = chunkECA2WNRX_cjs.describeLayer(camera);
+  for (const p of chunkDP37TTMO_cjs.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/core/matte.ts
+var MATTE_CHANNELS = ["alpha", "luma"];
+var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function maskSourceOf(mask) {
+  if (isObject(mask) && typeof mask.type === "string") return { kind: "inline", spec: mask };
+  const problems = [];
+  const refs = [];
+  const one = (r, inList) => {
+    if (typeof r === "string") {
+      refs.push({ layer: r, channel: "alpha", invert: false });
+      return;
+    }
+    if (isObject(r) && typeof r.type === "string") {
+      if (inList) problems.push("a layer written inside a list of masks is ignored: give that layer a name and write the name");
+      return;
+    }
+    if (isObject(r) && typeof r.layer === "string") {
+      let channel = "alpha";
+      if (r.channel !== void 0) {
+        if (r.channel === "alpha" || r.channel === "luma") channel = r.channel;
+        else {
+          const guess = typeof r.channel === "string" ? chunkTWZNOUM7_cjs.suggestName(r.channel, MATTE_CHANNELS) : null;
+          const alias = typeof r.channel === "string" && ["luminance", "brightness", "grayscale", "greyscale", "gray", "grey", "value"].includes(r.channel.toLowerCase()) ? "luma" : null;
+          const meant = guess ?? alias;
+          problems.push(`mask "${r.layer}": channel ${JSON.stringify(r.channel)} is not a matte channel${meant ? `; did you mean "${meant}"?` : ""} (use alpha or luma); alpha is used`);
+        }
+      }
+      let invert = false;
+      if (r.invert !== void 0) {
+        if (typeof r.invert === "boolean") invert = r.invert;
+        else problems.push(`mask "${r.layer}": invert must be true or false (got ${JSON.stringify(r.invert)}); false is used`);
+      }
+      refs.push({ layer: r.layer, channel, invert });
+    }
+  };
+  if (Array.isArray(mask)) for (const r of mask) one(r, true);
+  else one(mask, false);
+  return refs.length || problems.length ? { kind: "refs", refs, problems } : { kind: "none" };
+}
+function refNames(mask) {
+  const s = maskSourceOf(mask);
+  return s.kind === "refs" ? [...new Set(s.refs.map((r) => r.layer))] : [];
+}
+function usesMatteRoute(spec) {
+  const s = maskSourceOf(spec.mask);
+  if (s.kind !== "inline") return false;
+  const t = s.spec.type;
+  return spec.maskInverted === true || t === "text" || t === "image" || t === "video" || t === "shader";
+}
+var MANY_MATTES = 8;
+var startOf = (s) => Math.max(0, s.at ?? 0);
+var endOf = (s, span) => s.duration === void 0 ? span : (s.at ?? 0) + s.duration;
+var num = (n) => String(Number(n.toFixed(3)));
+function canBeMatte(spec) {
+  return spec.type !== "camera" && spec.type !== "audio" && spec.type !== "null" && !spec.threeD;
+}
+function matteProblems(layer, siblings, span) {
+  const src = maskSourceOf(layer.mask);
+  if (src.kind !== "refs") return [];
+  const out = [...src.problems];
+  const names = siblings.filter((s) => s.name && s.type !== "camera").map((s) => s.name);
+  if (layer.maskInverted && src.refs.length) {
+    out.push('maskInverted is for a mask written in place: with a reference write { layer: "name", invert: true } (and use a list to subtract one matte from another)');
+  }
+  if (layer.parent && src.refs.length) {
+    out.push(`it has a parent, so it is drawn in the null layer's space and the matte is in the composition's: mask the null layer ("${layer.parent}") instead`);
+  }
+  for (const ref of src.refs) {
+    if (ref.layer === layer.name) {
+      out.push(`mask "${ref.layer}": the layer masks itself; use another layer`);
+      continue;
+    }
+    const same = siblings.filter((s) => s.name === ref.layer && s.type !== "camera");
+    if (same.length === 0) {
+      const guess = chunkTWZNOUM7_cjs.suggestName(ref.layer, names.filter((n) => n !== layer.name));
+      out.push(`mask "${ref.layer}": no layer with that name${guess ? `; did you mean "${guess}"?` : ""} (a matte is another layer of the same composition; the layer is drawn without it)`);
+      continue;
+    }
+    if (same.length > 1) out.push(`mask "${ref.layer}": ${same.length} layers are named "${ref.layer}"; the first is used`);
+    const matte = same[0];
+    if (!canBeMatte(matte)) {
+      const what = matte.threeD ? "a threeD layer" : matte.type === "audio" ? "an audio layer (it draws nothing)" : "a null layer (it draws nothing)";
+      out.push(`mask "${ref.layer}": "${ref.layer}" is ${what} and cannot be a matte (the layer is drawn without it)`);
+      continue;
+    }
+    if (maskSourceOf(matte.mask).kind !== "none") out.push(`mask "${ref.layer}": "${ref.layer}" has a mask of its own, which is ignored when it is used as a matte`);
+    const ms = startOf(matte), me = endOf(matte, span), ls = startOf(layer), le = endOf(layer, span);
+    if (ms > ls + 1e-6 || me < le - 1e-6) {
+      out.push(`mask "${ref.layer}": "${ref.layer}" is on screen from ${num(ms)}s to ${num(me)}s but the layer from ${num(ls)}s to ${num(le)}s: where the matte is missing the layer is invisible (give the matte the layer's at and duration, or a longer one)`);
+    }
+  }
+  return out;
+}
+var VERT = `in vec2 aPosition;
+out vec2 vTextureCoord;
+out vec2 vMatteUv;
+uniform vec4 uInputSize;
+uniform vec4 uOutputFrame;
+uniform vec4 uOutputTexture;
+uniform mat3 uMatteMatrix;
+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);
+  vMatteUv = (uMatteMatrix * vec3(vTextureCoord, 1.0)).xy;
+}`;
+var FRAG = `in vec2 vTextureCoord;
+in vec2 vMatteUv;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+uniform sampler2D uMatteTexture;
+uniform float uLuma;
+uniform float uInvert;
+void main(void) {
+  vec4 src = texture(uTexture, vTextureCoord);
+  vec4 m = texture(uMatteTexture, vMatteUv);
+  // outside the matte texture there is no matte: the clamp-to-edge sampler would repeat the border
+  float inside = step(0.0, vMatteUv.x) * step(0.0, vMatteUv.y) * step(vMatteUv.x, 1.0) * step(vMatteUv.y, 1.0);
+  m *= inside;
+  // luma of the premultiplied colour = luma(colour) * alpha: a transparent matte counts as black (Rec. 709 weights)
+  float v = uLuma > 0.5 ? dot(m.rgb, vec3(0.2126, 0.7152, 0.0722)) : m.a;
+  if (uInvert > 0.5) v = 1.0 - v;
+  finalColor = src * v;
+}`;
+var WGSL2 = `
+struct GlobalFilterUniforms {
+  uInputSize:vec4<f32>,
+  uInputPixel:vec4<f32>,
+  uInputClamp:vec4<f32>,
+  uOutputFrame:vec4<f32>,
+  uGlobalFrame:vec4<f32>,
+  uOutputTexture:vec4<f32>,
+};
+struct MatteUniforms {
+  uMatteMatrix:mat3x3<f32>,
+  uLuma:f32,
+  uInvert: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> matteUniforms : MatteUniforms;
+@group(1) @binding(1) var uMatteTexture: texture_2d<f32>;
+@group(1) @binding(2) var uMatteSampler : sampler;
+
+struct VSOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) uv : vec2<f32>,
+    @location(1) matteUv : vec2<f32>,
+  };
+
+@vertex
+fn mainVertex(
+  @location(0) aPosition : vec2<f32>,
+) -> VSOutput {
+  var position = aPosition * gfu.uOutputFrame.zw + gfu.uOutputFrame.xy;
+  position.x = position.x * (2.0 / gfu.uOutputTexture.x) - 1.0;
+  position.y = position.y * (2.0 * gfu.uOutputTexture.z / gfu.uOutputTexture.y) - gfu.uOutputTexture.z;
+  let uv = aPosition * (gfu.uOutputFrame.zw * gfu.uInputSize.zw);
+  let matteUv = (matteUniforms.uMatteMatrix * vec3<f32>(uv, 1.0)).xy;
+  return VSOutput(vec4<f32>(position, 0.0, 1.0), uv, matteUv);
+}
+
+@fragment
+fn mainFragment(
+  @location(0) uv: vec2<f32>,
+  @location(1) matteUv: vec2<f32>,
+) -> @location(0) vec4<f32> {
+  let src = textureSample(uTexture, uSampler, uv);
+  var m = textureSample(uMatteTexture, uMatteSampler, matteUv);
+  let inside = step(0.0, matteUv.x) * step(0.0, matteUv.y) * step(matteUv.x, 1.0) * step(matteUv.y, 1.0);
+  m = m * inside;
+  var v = select(m.a, dot(m.rgb, vec3<f32>(0.2126, 0.7152, 0.0722)), matteUniforms.uLuma > 0.5);
+  if (matteUniforms.uInvert > 0.5) { v = 1.0 - v; }
+  return src * v;
+}`;
+var MatteFilter = class extends pixi_js.Filter {
+  _sprite;
+  constructor({ sprite, channel = "alpha", invert = false }) {
+    const source = sprite.texture.source;
+    super({
+      glProgram: pixi_js.GlProgram.from({ vertex: VERT, fragment: FRAG, name: "pe-matte-filter" }),
+      gpuProgram: pixi_js.GpuProgram.from({ vertex: { source: WGSL2, entryPoint: "mainVertex" }, fragment: { source: WGSL2, entryPoint: "mainFragment" } }),
+      resources: {
+        matteUniforms: new pixi_js.UniformGroup({
+          uMatteMatrix: { value: new pixi_js.Matrix(), type: "mat3x3<f32>" },
+          uLuma: { value: channel === "luma" ? 1 : 0, type: "f32" },
+          uInvert: { value: invert ? 1 : 0, type: "f32" }
+        }),
+        uMatteTexture: source,
+        uMatteSampler: source.style
+      }
+    });
+    this._sprite = sprite;
+  }
+  apply(filterManager, input, output, clearMode) {
+    const u = this.resources.matteUniforms.uniforms;
+    filterManager.calculateSpriteMatrix(u.uMatteMatrix, this._sprite);
+    this.resources.uMatteTexture = this._sprite.texture.source;
+    filterManager.applyFilter(this, input, output, clearMode);
+  }
+};
+
+// src/core/MatteSet.ts
+var EMPTY = new pixi_js.Container();
+var MatteSet = class {
+  constructor(inner, width, height) {
+    this.inner = inner;
+    this.width = width;
+    this.height = height;
+  }
+  inner;
+  width;
+  height;
+  mattes = /* @__PURE__ */ new Map();
+  sources = /* @__PURE__ */ new Set();
+  get size() {
+    return this.mattes.size;
+  }
+  has(key) {
+    return this.mattes.has(key);
+  }
+  /** Is this layer a matte's source (so it is not drawn on screen)? */
+  isSource(seq) {
+    return this.sources.has(seq);
+  }
+  /** `chain`: the null layers the source sits in, nearest first (the source is in no container, so their transforms are composed by hand). */
+  add(key, seq, chain = []) {
+    if (this.mattes.has(key)) return;
+    const rt = pixi_js.RenderTexture.create({ width: this.width, height: this.height, resolution: 1, antialias: true });
+    const sprite = new pixi_js.Sprite(rt);
+    sprite.renderable = false;
+    this.inner.addChild(sprite);
+    this.mattes.set(key, { seq, chain, rt, sprite });
+    this.sources.add(seq);
+  }
+  filterFor(key, opts) {
+    const m = this.mattes.get(key);
+    return m ? new MatteFilter({ sprite: m.sprite, channel: opts.channel, invert: opts.invert }) : null;
+  }
+  /** Draw every matte into its texture from the state the timeline has just set; a hidden matte is an empty texture (it cuts everything away). */
+  render(host) {
+    for (const { seq, chain, rt } of this.mattes.values()) {
+      const target = seq.target;
+      if (target && target.renderable && target.visible) {
+        target.updateLocalTransform();
+        const m = target.localTransform.clone();
+        for (const p of chain) {
+          p.target?.updateLocalTransform();
+          if (p.target) m.prepend(p.target.localTransform);
+        }
+        host.render({ container: target, target: rt, transform: m, clear: true, clearColor: [0, 0, 0, 0] });
+      } else {
+        host.render({ container: EMPTY, target: rt, transform: new pixi_js.Matrix(), clear: true, clearColor: [0, 0, 0, 0] });
+      }
+    }
+  }
+  destroy() {
+    for (const m of this.mattes.values()) {
+      m.sprite.destroy();
+      m.rt.destroy(true);
+    }
+    this.mattes.clear();
+    this.sources.clear();
+  }
+};
+
+// src/sequences/Composition.ts
+var CompositionSequence = class extends chunkDP37TTMO_cjs.Sequence {
+  _innerContainer = null;
+  _compositionShape = null;
+  _children = [];
+  _cameras = [];
+  _lights = [];
+  /** The lights alive and the camera position of the last lit frame (what `inspect` reads: a layer's light level is computed from them on demand). */
+  _lighting = null;
+  _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 = [];
+  /** The mattes (layers drawn into textures that cut other layers), when any layer of this composition names or has one. */
+  _mattes = null;
+  _inlineMattes = 0;
+  /** 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 pixi_js.Container();
+    wrapper.cullable = true;
+    wrapper.cullableChildren = true;
+    wrapper.cullArea = new pixi_js.Rectangle(0, 0, width, height);
+    const inner = new pixi_js.Container();
+    inner.cullable = true;
+    inner.cullableChildren = true;
+    wrapper.addChild(inner);
+    this.target = wrapper;
+    this.intrinsicWidth = width;
+    this.intrinsicHeight = height;
+    this._innerContainer = inner;
+    const base = chunkDP37TTMO_cjs.timeRemapOf(this.spec);
+    const span = base ? chunkDP37TTMO_cjs.contentLength(base, this.duration) : this.duration;
+    this._remap = base ? chunkDP37TTMO_cjs.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 ?? []);
+      for (const message of matteProblems(s, this.spec.sequences ?? [], span)) console.warn(`pixi-effects: ${chunkECA2WNRX_cjs.describeLayer(s)}: ${message}`);
+      chunkECA2WNRX_cjs.lintTiming(s, span, (message, kind) => kind === "late-keyframe" ? lateKeyframes.push(message) : console.warn(message));
+      chunkECA2WNRX_cjs.lintText(s);
+      chunkECA2WNRX_cjs.lintKeys(s);
+    }
+    for (const message of chunkECA2WNRX_cjs.summarizeWarnings(lateKeyframes)) console.warn(message);
+    const crowd = chunk3DLYAPK7_cjs.maxConcurrentAdvanced(this.spec.sequences ?? [], span);
+    if (crowd >= chunk3DLYAPK7_cjs.MANY_ADVANCED) {
+      console.warn(`pixi-effects: ${chunkECA2WNRX_cjs.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 chunkDP37TTMO_cjs.buildSequenceTree(
+      this.spec.sequences ?? [],
+      this._compositionShape,
+      this.root
+    );
+    this._resolveParents();
+    const matteNames = /* @__PURE__ */ new Set();
+    for (const c of this._children) for (const n of refNames(c.spec.mask)) matteNames.add(n);
+    if (matteNames.size > 0) {
+      this._mattes = new MatteSet(inner, width, height);
+      for (const name of matteNames) {
+        const source = this._children.find((c) => c.spec.name === name && !(c instanceof chunkDP37TTMO_cjs.CameraSequence));
+        if (!source || !source.target || !canBeMatte(source.spec)) continue;
+        const chain = [];
+        for (let p = this._parentOf.get(source); p; p = this._parentOf.get(p)) chain.push(p);
+        this._mattes.add(name, source, chain);
+      }
+    }
+    if (this._children.some((c) => c instanceof chunkDP37TTMO_cjs.LightSequence)) {
+      for (const message of lightSetProblems(this.spec.sequences ?? [])) console.warn(`pixi-effects: ${chunkECA2WNRX_cjs.describeLayer(this.spec)}: ${message}`);
+    }
+    const layerNames = new Set(this._children.map((c) => c.spec.name).filter((n) => !!n));
+    for (const cam of this._children) {
+      if (!(cam instanceof chunkDP37TTMO_cjs.CameraSequence)) continue;
+      cam.resolveFocusNames((name) => {
+        const hit = this._children.find((c) => c.spec.name === name && c.spec.threeD);
+        return hit ? chunkDP37TTMO_cjs.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 chunkDP37TTMO_cjs.CameraSequence) {
+        this._cameras.push(child);
+        continue;
+      }
+      if (child instanceof chunkDP37TTMO_cjs.LightSequence) {
+        this._lights.push(child);
+        continue;
+      }
+      if (!child.target) continue;
+      if (this._mattes?.isSource(child)) continue;
+      const holder = this._parentOf.get(child);
+      const into = holder?.target ?? inner;
+      const maskSrc = maskSourceOf(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 = chunk3DLYAPK7_cjs.applyBlendMode(child.spec, layer.display, report);
+        if (added3d) this._blendOwned.push(added3d);
+        if (maskSrc.kind !== "none") {
+          console.warn(`pixi-effects: ${chunkECA2WNRX_cjs.describeLayer(child.spec)}: mask is not supported on threeD layers yet; ignored`);
+        }
+        continue;
+      }
+      into.addChild(child.target);
+      if (holder) this._nested.push(child);
+      else this._visual.push({ seq: child, layer: null });
+      const matteFilters = [];
+      if (maskSrc.kind === "refs" && this._mattes) {
+        for (const ref of maskSrc.refs) {
+          const f = this._mattes.filterFor(ref.layer, { channel: ref.channel, invert: ref.invert });
+          if (f) matteFilters.push(f);
+        }
+      }
+      if (maskSrc.kind === "inline") {
+        const maskSpec = maskSrc.spec;
+        const lifetime = maskSpec.at === void 0 ? { at: child.at, duration: maskSpec.duration ?? child.duration } : {};
+        const built = await chunkDP37TTMO_cjs.buildSequenceTree([{ ...maskSpec, ...lifetime }], this._compositionShape, this.root);
+        const maskSeq = built[0];
+        if (maskSeq?.target) {
+          child.maskSequence = maskSeq;
+          if (usesMatteRoute(child.spec)) {
+            if (!this._mattes) this._mattes = new MatteSet(inner, width, height);
+            const key = `\0inline-${this._inlineMattes++}`;
+            const chain = [];
+            for (let p = this._parentOf.get(child); p; p = this._parentOf.get(p)) chain.push(p);
+            this._mattes.add(key, maskSeq, chain);
+            const f = this._mattes.filterFor(key, { channel: "alpha", invert: child.spec.maskInverted === true });
+            if (f) matteFilters.push(f);
+          } else {
+            into.addChild(maskSeq.target);
+            const t = child.target;
+            if (typeof t.setMask === "function") t.setMask({ mask: maskSeq.target, inverse: false });
+            else t.mask = maskSeq.target;
+          }
+        }
+      }
+      if (matteFilters.length > 0) {
+        const t = child.target;
+        t.filters = [...Array.isArray(t.filters) ? t.filters : [], ...matteFilters];
+        this._blendOwned.push(...matteFilters);
+      }
+      const added = chunk3DLYAPK7_cjs.applyBlendMode(child.spec, child.target, report);
+      if (added) this._blendOwned.push(added);
+    }
+    if (this._mattes && this._mattes.size > MANY_MATTES) {
+      console.warn(`pixi-effects: ${chunkECA2WNRX_cjs.describeLayer(this.spec)}: ${this._mattes.size} mattes: each is a ${width}\xD7${height} texture (about ${Math.round(width * height * 4 / 1048576)} MiB, more with anti-aliasing). Share one matte between layers, or use fewer`);
+    }
+    for (const [message, seen] of blendSaid) {
+      console.warn(`pixi-effects: ${chunkECA2WNRX_cjs.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.seq.target).zIndex = i;
+      });
+    } else if (this._cameras.length > 0) {
+      console.warn("pixi-effects: camera has no effect: this composition has no threeD layers");
+    }
+    if (this._layers3d.length === 0 && this._lights.length > 0) {
+      console.warn(`pixi-effects: ${chunkECA2WNRX_cjs.describeLayer(this.spec)}: a light has no effect: this composition has no threeD layers (a light lights only the threeD layers of its own composition, not those of the compositions nested in it: put the light inside the composition that holds them)`);
+    }
+    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.gsap.timeline({ paused: true, defaults: { ease: "none" } }) : timeline;
+    for (const child of this._children) {
+      const own = gsap.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;
+    chunkDP37TTMO_cjs.bindClock(timeline, clock, "time", remap, this.duration, offset + this.at, scope);
+    inner.time(inner.duration());
+    inner.time(0);
+    last = NaN;
+    this._warnUnreachable(chunkDP37TTMO_cjs.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: ${chunkECA2WNRX_cjs.describeLayer(child.spec)} starts at ${at}s of ${chunkECA2WNRX_cjs.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 chunkDP37TTMO_cjs.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,
+        // how lit it is (threeD layers that receive the lights of the last frame only); computed here, not per frame
+        light: layer && this._lighting && layer.world && layer.spec.lit !== false ? chunkDP37TTMO_cjs.lightLevel(layer.world, this._lighting.cam, this._lighting.states) : void 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 chunkDP37TTMO_cjs.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 = chunkECA2WNRX_cjs.describeLayer(child.spec);
+      if (child instanceof chunkDP37TTMO_cjs.CameraSequence) {
+        console.warn(`pixi-effects: ${who}: a camera cannot have a parent; ignored`);
+        continue;
+      }
+      if (child instanceof chunkDP37TTMO_cjs.LightSequence) {
+        console.warn(`pixi-effects: ${who}: a light cannot have a parent (parent "${want}" ignored: move the light with its own x / y / z keyframes)`);
+        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 = chunkTWZNOUM7_cjs.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 chunkDP37TTMO_cjs.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);
+    this._mattes?.render(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() : chunkDP37TTMO_cjs.homeCamera(width, height);
+    const basis = chunkDP37TTMO_cjs.cameraBasis(cam, width, height);
+    for (const layer of this._layers3d) layer.update(host, basis);
+    this._applyLighting(childT, compEnd, basis, active?.cam ?? null);
+    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];
+    });
+  }
+  /**
+   * Lights and fog: when the composition has a light layer or the camera writes fog, every threeD layer draws with the lit shader, fed with
+   * the lights alive NOW (a pure function of the lights, the camera and the layers; nothing is remembered between frames). With neither,
+   * nothing is made and nothing is drawn differently. With no light alive at this moment (all outside their `at` / `duration`) a layer is
+   * drawn unlit, as it is in a composition with no light.
+   */
+  _applyLighting(t, compEnd, basis, cam) {
+    const fog = cam?.fogState() ?? null;
+    if (this._lights.length === 0 && !this._cameras.some((c) => c.fog)) return;
+    const live = this._lights.filter((l) => {
+      const w = l.window();
+      return t >= w.start && (t < w.end || w.end >= compEnd && t <= w.end);
+    });
+    const states = live.map((l) => l.state());
+    const packed = states.length > 0 ? chunkDP37TTMO_cjs.packLights(states) : null;
+    this._lighting = states.length > 0 ? { states, cam: { x: basis.cx, y: basis.cy, z: basis.cz } } : null;
+    const shadowing = states.some((s) => s.castsShadows);
+    const casters = shadowing ? this._layers3d.filter((l) => l.spec.castsShadows && l.display.visible && l.world && l.source) : [];
+    const camInfo = { x: basis.cx, y: basis.cy, z: basis.cz, fx: basis.fx, fy: basis.fy, fz: basis.fz };
+    for (const l of this._layers3d) {
+      const mat = l.setLit(true);
+      if (!mat || !l.world) continue;
+      const lit = l.spec.lit !== false;
+      const mine = lit ? casters.filter((c) => c !== l).slice(0, chunkDP37TTMO_cjs.MAX_CASTERS).map((c) => ({ frame: c.world, source: c.source })) : [];
+      mat.update(l.world, camInfo, lit ? packed : null, fog, mine);
+    }
+  }
+  /** 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 = chunkDP37TTMO_cjs.projectPoint(basis, { x: cam.lookAtX, y: cam.lookAtY, z: cam.focus ?? 0 }).depth;
+    if (!(focusDepth > chunkDP37TTMO_cjs.NEAR)) {
+      if (!this._dofSaid.behind) {
+        this._dofSaid.behind = true;
+        console.warn(`pixi-effects: ${chunkECA2WNRX_cjs.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 ? chunkDP37TTMO_cjs.blurRadius(aperture, basis.focal, l.depth, focusDepth) : 0);
+      if (l.blur > 0) blurred++;
+    }
+    if (blurred >= chunkDP37TTMO_cjs.MANY_BLURRED && !this._dofSaid.many) {
+      this._dofSaid.many = true;
+      console.warn(`pixi-effects: ${chunkECA2WNRX_cjs.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 = chunkDP37TTMO_cjs.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.setLit(false);
+    for (const l of this._layers3d) l.destroy();
+    this._layers3d = [];
+    this._mattes?.destroy();
+    this._mattes = null;
+    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();
+}
+
+exports.CompositionSequence = CompositionSequence;
+exports.maskSourceOf = maskSourceOf;
+//# sourceMappingURL=chunk-SY27HZC5.cjs.map
+//# sourceMappingURL=chunk-SY27HZC5.cjs.map