pixi-effects 0.22.0 → 0.25.0

package/dist/{chunk-DC4JPY6A.js → chunk-PRZ4U6JN.js}

@@ -1,7 +1,7 @@
-import { collectPropKeys, describeLayer } from './chunk-E7RONUZ7.js';
-import { suggestName, warnUnknownOptions } from './chunk-NHICCDTC.js';
+import { collectPropKeys, describeLayer } from './chunk-TLYTYBWX.js';
+import { suggestName, warnUnknownOptions } from './chunk-BXOCEZ4U.js';
 import * as PIXI from 'pixi.js';
-import { Rectangle, Container, GraphicsPath, Graphics, Assets, Texture, Sprite, FillGradient, Text, Filter, GlProgram, defaultFilterVert, GpuProgram, UniformGroup, Color } from 'pixi.js';
+import { Rectangle, Container, Color, GraphicsPath, Sprite, Texture, Graphics, Assets, FillGradient, Text, Filter, GlProgram, defaultFilterVert, GpuProgram, UniformGroup } from 'pixi.js';
 import { gsap } from 'gsap';
 
 // src/expr/random.ts
@@ -528,8 +528,8 @@ function partitionProps(props) {
   for (const k of Object.keys(props)) {
     const m = k.match(/^filters\.([^.]+)\.(.+)$/);
     if (m) {
-      const [, name, sub] = m;
-      (filterProps[name] ??= {})[sub] = props[k];
+      const [, name, sub2] = m;
+      (filterProps[name] ??= {})[sub2] = props[k];
     } else {
       ownProps[k] = props[k];
     }
@@ -541,10 +541,10 @@ function splitRouted(props, routers) {
   const rest = {};
   const routed = [];
   for (const k of Object.keys(props)) {
-    const dot = k.indexOf(".");
-    const router = dot > 0 ? routers[k.slice(0, dot)] : void 0;
+    const dot2 = k.indexOf(".");
+    const router = dot2 > 0 ? routers[k.slice(0, dot2)] : void 0;
     if (router) {
-      const hit = router(k.slice(dot + 1));
+      const hit = router(k.slice(dot2 + 1));
       if (hit) routed.push({ target: hit.target, prop: hit.prop, key: k, value: props[k] });
     } else {
       rest[k] = props[k];
@@ -1145,10 +1145,238 @@ var GrainFilter = class extends Filter {
     this.u.uFrame = this._fps > 0 ? Math.floor(t * this._fps + 1e-3) : 0;
   }
 };
+var WARP_KINDS = ["wave", "haze"];
+var OPTION_KEYS = ["kind", "strength", "scale", "speed", "angle", "seed"];
+var DEG = Math.PI / 180;
+var HASH_GL2 = `
+uint hash(uint x) { x ^= x >> 16; x *= 0x7feb352du; x ^= x >> 15; x *= 0x846ca68bu; x ^= x >> 16; return x; }
+float lattice(ivec2 p, uint k) {
+  uint h = hash(uint(p.x) + hash(uint(p.y) + hash(k)));
+  return float(h >> 8) / 16777215.0;
+}
+float valueNoise(vec2 q, uint k) {
+  vec2 i = floor(q);
+  vec2 f = fract(q);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  ivec2 p = ivec2(i);
+  float a = lattice(p, k), b = lattice(p + ivec2(1, 0), k), c = lattice(p + ivec2(0, 1), k), d = lattice(p + ivec2(1, 1), k);
+  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+}`;
+var GL_VERTEX2 = `#version 300 es
+precision highp float;
+in vec2 aPosition;
+out vec2 vTextureCoord;
+uniform highp vec4 uInputSize;
+uniform highp vec4 uOutputFrame;
+uniform highp 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_FRAGMENT3 = `#version 300 es
+precision highp float;
+precision highp int;
+in vec2 vTextureCoord;
+uniform sampler2D uTexture;
+uniform highp vec4 uInputSize;
+uniform highp vec4 uInputClamp;
+uniform float uStrength;
+uniform float uScale;
+uniform float uSpeed;
+uniform float uAngle;
+uniform float uSeed;
+uniform float uMode;
+uniform float uTime;
+out vec4 finalColor;
+${HASH_GL2}
+void main(void) {
+  vec2 pos = vTextureCoord * uInputSize.xy;
+  vec2 off;
+  if (uMode < 0.5) {
+    float phase = dot(pos, vec2(cos(uAngle), sin(uAngle))) / uScale - uSpeed * uTime;
+    float s = uStrength * sin(6.28318530718 * phase);
+    off = vec2(-sin(uAngle), cos(uAngle)) * s;
+  } else {
+    uint k = hash(uint(uSeed));
+    vec2 p = vec2(pos.x / uScale, pos.y / uScale - uSpeed * uTime);
+    off = uStrength * 2.0 * vec2(valueNoise(p, k) - 0.5, valueNoise(p + vec2(37.2, 17.8), k) - 0.5);
+  }
+  vec2 suv = clamp(vTextureCoord + off * uInputSize.zw, uInputClamp.xy, uInputClamp.zw);
+  finalColor = texture(uTexture, suv);
+}`;
+var WGSL_SOURCE3 = `
+struct GlobalFilterUniforms {
+  uInputSize: vec4<f32>,
+  uInputPixel: vec4<f32>,
+  uInputClamp: vec4<f32>,
+  uOutputFrame: vec4<f32>,
+  uGlobalFrame: vec4<f32>,
+  uOutputTexture: vec4<f32>,
+};
+struct WarpUniforms {
+  uStrength: f32,
+  uScale: f32,
+  uSpeed: f32,
+  uAngle: f32,
+  uSeed: f32,
+  uMode: f32,
+  uTime: 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> warpUniforms : WarpUniforms;
+
+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),
+  );
+}
+
+fn hash(xIn: u32) -> u32 {
+  var x = xIn;
+  x = x ^ (x >> 16u); x = x * 0x7feb352du; x = x ^ (x >> 15u); x = x * 0x846ca68bu; x = x ^ (x >> 16u);
+  return x;
+}
+fn lattice(p: vec2<i32>, k: u32) -> f32 {
+  let h = hash(u32(p.x) + hash(u32(p.y) + hash(k)));
+  return f32(h >> 8u) / 16777215.0;
+}
+fn valueNoise(q: vec2<f32>, k: u32) -> f32 {
+  let i = floor(q);
+  let f = fract(q);
+  let u = f * f * (3.0 - 2.0 * f);
+  let p = vec2<i32>(i);
+  let a = lattice(p, k);
+  let b = lattice(p + vec2<i32>(1, 0), k);
+  let c = lattice(p + vec2<i32>(0, 1), k);
+  let d = lattice(p + vec2<i32>(1, 1), k);
+  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+}
+
+@fragment
+fn mainFragment(@location(0) uv : vec2<f32>) -> @location(0) vec4<f32> {
+  let pos = uv * gfu.uInputSize.xy;
+  var off = vec2<f32>(0.0);
+  if (warpUniforms.uMode < 0.5) {
+    let phase = dot(pos, vec2<f32>(cos(warpUniforms.uAngle), sin(warpUniforms.uAngle))) / warpUniforms.uScale - warpUniforms.uSpeed * warpUniforms.uTime;
+    let s = warpUniforms.uStrength * sin(6.28318530718 * phase);
+    off = vec2<f32>(-sin(warpUniforms.uAngle), cos(warpUniforms.uAngle)) * s;
+  } else {
+    let k = hash(u32(warpUniforms.uSeed));
+    let p = vec2<f32>(pos.x / warpUniforms.uScale, pos.y / warpUniforms.uScale - warpUniforms.uSpeed * warpUniforms.uTime);
+    off = warpUniforms.uStrength * 2.0 * vec2<f32>(valueNoise(p, k) - 0.5, valueNoise(p + vec2<f32>(37.2, 17.8), k) - 0.5);
+  }
+  let suv = clamp(uv + off * gfu.uInputSize.zw, gfu.uInputClamp.xy, gfu.uInputClamp.zw);
+  return textureSampleLevel(uTexture, uSampler, suv, 0.0);
+}`;
+var WarpFilter = class extends Filter {
+  constructor(options = {}) {
+    warnUnknownOptions("warp filter", options, OPTION_KEYS);
+    let { kind = "wave", strength = 6, scale = 80, speed = 0.5, angle = 0, seed = 0 } = options;
+    if (!WARP_KINDS.includes(kind)) {
+      const guess = suggestName(String(kind), WARP_KINDS);
+      console.warn(`pixi-effects: warp: kind ${JSON.stringify(kind)} is not supported${guess ? `; did you mean "${guess}"?` : ""} (use ${WARP_KINDS.join(" or ")}); wave is used`);
+      kind = "wave";
+    }
+    if (!(strength >= 0 && strength <= 200)) {
+      console.warn(`pixi-effects: warp: strength ${strength} is not a number from 0 to 200: it is the largest shift in pixels (8 is a clear ripple); ${strength > 200 ? "200" : "0"} is used`);
+      strength = strength > 200 ? 200 : 0;
+    }
+    if (!(seed >= 0)) {
+      console.warn(`pixi-effects: warp: seed ${seed} must be 0 or more (an integer that picks the haze pattern); 0 is used`);
+      seed = 0;
+    }
+    if (!(scale > 0)) {
+      console.warn(`pixi-effects: warp: scale ${scale} must be above 0: it is the wavelength in pixels (80 is the default); 1 is used`);
+      scale = 1;
+    }
+    super({
+      glProgram: GlProgram.from({ vertex: GL_VERTEX2, fragment: GL_FRAGMENT3, name: "warp-filter" }),
+      gpuProgram: GpuProgram.from({ vertex: { source: WGSL_SOURCE3, entryPoint: "mainVertex" }, fragment: { source: WGSL_SOURCE3, entryPoint: "mainFragment" } }),
+      resources: {
+        warpUniforms: new UniformGroup({
+          uStrength: { value: strength, type: "f32" },
+          uScale: { value: scale, type: "f32" },
+          uSpeed: { value: speed, type: "f32" },
+          uAngle: { value: angle * DEG, type: "f32" },
+          uSeed: { value: Math.floor(seed), type: "f32" },
+          uMode: { value: kind === "haze" ? 1 : 0, type: "f32" },
+          uTime: { value: 0, type: "f32" }
+        })
+      }
+    });
+    this.padding = Math.ceil(strength);
+  }
+  get u() {
+    return this.resources.warpUniforms.uniforms;
+  }
+  get kind() {
+    return this.u.uMode === 1 ? "haze" : "wave";
+  }
+  set kind(v) {
+    this.u.uMode = v === "haze" ? 1 : 0;
+  }
+  get strength() {
+    return this.u.uStrength;
+  }
+  set strength(v) {
+    this.u.uStrength = v;
+    this.padding = Math.ceil(Math.max(0, v));
+  }
+  get scale() {
+    return this.u.uScale;
+  }
+  set scale(v) {
+    this.u.uScale = Math.max(v, 1e-3);
+  }
+  get speed() {
+    return this.u.uSpeed;
+  }
+  set speed(v) {
+    this.u.uSpeed = v;
+  }
+  get angle() {
+    return this.u.uAngle / DEG;
+  }
+  set angle(v) {
+    this.u.uAngle = v * DEG;
+  }
+  get seed() {
+    return this.u.uSeed;
+  }
+  set seed(v) {
+    this.u.uSeed = v >= 0 ? Math.floor(v) : 0;
+  }
+  /** The movie calls this with the time (s) of the frame it is about to draw. */
+  setTime(t) {
+    this.u.uTime = t;
+  }
+};
 
 // src/filters/named.ts
 var CORE = { blur: "BlurFilter", noise: "NoiseFilter", alpha: "AlphaFilter" };
-var CORE_TYPES = [...Object.keys(CORE), "colorMatrix", "grain"];
+var CORE_TYPES = [...Object.keys(CORE), "colorMatrix", "grain", "warp"];
 var LIBRARY_TYPES = [
   "adjustment",
   "advancedBloom",
@@ -1266,6 +1494,7 @@ function colorGradientParams(params) {
 function createNamedFilter(type, params) {
   if (lower(type) === "colormatrix") return colorMatrix(params);
   if (lower(type) === "grain") return new GrainFilter(params);
+  if (lower(type) === "warp") return new WarpFilter(params);
   const core = Object.entries(CORE).find(([k]) => lower(k) === lower(type));
   if (core) return new PIXI[core[1]](params);
   if (!isLibraryType(type)) throw unknownType(type);
@@ -1521,7 +1750,7 @@ function clockTable(remap, prop, duration, at, scope, to) {
 }
 
 // src/space/math.ts
-var DEG = Math.PI / 180;
+var DEG2 = Math.PI / 180;
 var DEFAULT_FOV = 40;
 var MIN_FOV = 1;
 var MAX_FOV = 179;
@@ -1531,7 +1760,7 @@ function clampFov(fov) {
   return Math.min(MAX_FOV, Math.max(MIN_FOV, fov));
 }
 function homeDistance(compHeight, fovDeg) {
-  return compHeight / 2 / Math.tan(clampFov(fovDeg) * DEG / 2);
+  return compHeight / 2 / Math.tan(clampFov(fovDeg) * DEG2 / 2);
 }
 function homeCamera(compW, compH, fov = DEFAULT_FOV) {
   return {
@@ -1585,7 +1814,7 @@ function cameraBasis(cam, compW, compH) {
     fx,
     fy,
     fz,
-    focal: compH / 2 / Math.tan(clampFov(cam.fov) * DEG / 2),
+    focal: compH / 2 / Math.tan(clampFov(cam.fov) * DEG2 / 2),
     halfW: compW / 2,
     halfH: compH / 2
   };
@@ -1705,6 +1934,9 @@ var CameraSequence = class extends Sequence {
   warnedAperture = false;
   /** True when the camera writes `focus` or `aperture` anywhere: depth of field is on. */
   dof = false;
+  /** True when the camera writes any fog key anywhere: depth fog is on (nothing is made for a camera without fog). */
+  fog = false;
+  fogC = null;
   zOfName = null;
   layerNames = /* @__PURE__ */ new Set();
   async build() {
@@ -1726,10 +1958,15 @@ var CameraSequence = class extends Sequence {
     carrier.aperture = DEFAULT_APERTURE;
     carrier.offsetX = carrier.offsetY = carrier.offsetZ = 0;
     carrier.lookOffsetX = carrier.lookOffsetY = carrier.lookOffsetZ = 0;
+    carrier.fogNear = home.z;
+    carrier.fogFar = home.z * 3;
+    carrier.fogColor = "#000000";
+    carrier.fogAmount = 1;
     this.target = carrier;
     const keys = collectPropKeys(this.spec);
     this.autoZ = !keys.has("z");
     this.dof = keys.has("focus") || keys.has("aperture");
+    this.fog = keys.has("fogNear") || keys.has("fogFar") || keys.has("fogColor") || keys.has("fogAmount");
   }
   /** The aperture to use now: off unless depth of field is on and the value is a number of 0 or more (said once if it is not). */
   apertureNow(a) {
@@ -1777,6 +2014,20 @@ var CameraSequence = class extends Sequence {
       aperture: this.apertureNow(c.aperture)
     };
   }
+  /** The fog now (colour as 0..1 channels, distances, 0..1 amount), or null when the camera writes no fog key. */
+  fogState() {
+    if (!this.fog) return null;
+    const c = this.target;
+    const fc = this.fogC ??= new Color();
+    try {
+      fc.setValue(c.fogColor);
+    } catch {
+      fc.setValue(0);
+    }
+    const [r, g, b] = fc.toArray();
+    const amount = Number.isFinite(c.fogAmount) ? Math.min(1, Math.max(0, c.fogAmount)) : 1;
+    return { r, g, b, near: c.fogNear, far: c.fogFar, amount };
+  }
   /** Lifespan on the global timeline (valid after bindTimeline). */
   window() {
     const start = this.absoluteStart ?? this.at;
@@ -1784,6 +2035,160 @@ var CameraSequence = class extends Sequence {
   }
 };
 
+// src/space/lighting.ts
+var LIGHT_KINDS = ["ambient", "point", "spot", "parallel"];
+var FALLOFFS = ["none", "smooth", "inverseSquare"];
+var LIGHT_PROPS = ["x", "y", "z", "lookAtX", "lookAtY", "lookAtZ", "intensity", "color", "coneAngle", "coneFeather", "radius", "falloffDistance", "shadowDarkness", "shadowDiffusion"];
+var MAX_LIGHTS = 8;
+var MAX_CASTERS = 4;
+var SHADOW_TAPS = 16;
+var FALLOFF_ID = { none: 0, smooth: 1, inverseSquare: 2 };
+var KIND_ID = { point: 1, spot: 2, parallel: 3 };
+function smoothstep(e0, e1, x) {
+  const t = Math.min(1, Math.max(0, (x - e0) / (e1 - e0)));
+  return t * t * (3 - 2 * t);
+}
+var DEG3 = Math.PI / 180;
+function norm(v) {
+  const l = Math.hypot(v.x, v.y, v.z) || 1;
+  return { x: v.x / l, y: v.y / l, z: v.z / l };
+}
+var dot = (a, b) => a.x * b.x + a.y * b.y + a.z * b.z;
+var sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y, z: a.z - b.z });
+function coneCos(l) {
+  const half = Math.min(179, Math.max(0, l.coneAngle)) * DEG3 / 2;
+  const inner = half * (1 - Math.min(1, Math.max(0, l.coneFeather)));
+  const cosOuter = Math.cos(half);
+  const cosInner = Math.max(Math.cos(inner), cosOuter + 1e-4);
+  return { cosOuter, cosInner };
+}
+function packLights(lights) {
+  const pos = new Float32Array(4 * MAX_LIGHTS), dir = new Float32Array(4 * MAX_LIGHTS), col = new Float32Array(4 * MAX_LIGHTS), fall = new Float32Array(4 * MAX_LIGHTS), shadow = new Float32Array(4 * MAX_LIGHTS);
+  const ambient = [0, 0, 0];
+  let n = 0;
+  for (const l of lights) {
+    if (l.kind === "ambient") {
+      ambient[0] += l.r * l.intensity;
+      ambient[1] += l.g * l.intensity;
+      ambient[2] += l.b * l.intensity;
+      continue;
+    }
+    if (n >= MAX_LIGHTS) continue;
+    const d = norm({ x: l.lookAtX - l.x, y: l.lookAtY - l.y, z: l.lookAtZ - l.z });
+    const { cosOuter, cosInner } = coneCos(l);
+    pos.set([l.x, l.y, l.z, KIND_ID[l.kind]], 4 * n);
+    dir.set([d.x, d.y, d.z, cosOuter], 4 * n);
+    col.set([l.r * l.intensity, l.g * l.intensity, l.b * l.intensity, cosInner], 4 * n);
+    fall.set([FALLOFF_ID[l.falloff], l.radius, l.falloffDistance, l.castsShadows ? 1 : 0], 4 * n);
+    shadow.set([l.castsShadows ? l.shadowDarkness : 0, l.shadowDiffusion, 0, 0], 4 * n);
+    n++;
+  }
+  return { count: n, ambient, pos, dir, col, fall, shadow };
+}
+function shadeReference(p, n, cam, lights) {
+  let N = norm(n);
+  if (dot(N, sub(cam, p)) < 0) N = { x: -N.x, y: -N.y, z: -N.z };
+  const out = [0, 0, 0];
+  for (const l of lights) {
+    if (l.kind === "ambient") {
+      out[0] += l.r * l.intensity;
+      out[1] += l.g * l.intensity;
+      out[2] += l.b * l.intensity;
+      continue;
+    }
+    const dirLA = norm({ x: l.lookAtX - l.x, y: l.lookAtY - l.y, z: l.lookAtZ - l.z });
+    let L;
+    let dist = 0;
+    if (l.kind === "parallel") L = { x: -dirLA.x, y: -dirLA.y, z: -dirLA.z };
+    else {
+      const d = sub({ x: l.x, y: l.y, z: l.z }, p);
+      dist = Math.hypot(d.x, d.y, d.z);
+      L = { x: d.x / dist, y: d.y / dist, z: d.z / dist };
+    }
+    const ndl = Math.max(0, dot(N, L));
+    let att = 1;
+    if (l.kind !== "parallel") {
+      if (l.falloff === "smooth") att = 1 - smoothstep(l.radius, l.radius + Math.max(l.falloffDistance, 1e-3), dist);
+      else if (l.falloff === "inverseSquare") att = Math.min(1, l.radius * l.radius / Math.max(dist * dist, 1e-6));
+    }
+    let cone = 1;
+    if (l.kind === "spot") {
+      const { cosOuter, cosInner } = coneCos(l);
+      cone = smoothstep(cosOuter, cosInner, -dot(L, dirLA));
+    }
+    const k = l.intensity * ndl * att * cone;
+    out[0] += l.r * k;
+    out[1] += l.g * k;
+    out[2] += l.b * k;
+  }
+  return out;
+}
+function lightLevel(frame, cam, lights) {
+  const mid = { x: frame.o.x + 0.5 * frame.u.x + 0.5 * frame.v.x, y: frame.o.y + 0.5 * frame.u.y + 0.5 * frame.v.y, z: frame.o.z + 0.5 * frame.u.z + 0.5 * frame.v.z };
+  const n = { x: frame.u.y * frame.v.z - frame.u.z * frame.v.y, y: frame.u.z * frame.v.x - frame.u.x * frame.v.z, z: frame.u.x * frame.v.y - frame.u.y * frame.v.x };
+  const m = shadeReference(mid, n, cam, lights);
+  return 0.2126 * m[0] + 0.7152 * m[1] + 0.0722 * m[2];
+}
+var LightSequence = class extends Sequence {
+  color = new Color();
+  async build() {
+    const w = this.parent?.width ?? this.root.width;
+    const h = this.parent?.height ?? this.root.height;
+    if (this.duration === void 0) this.duration = this.parent?.duration ?? this.root.duration;
+    const c = new Container();
+    c.x = w * 0.3;
+    c.y = h * 0.2;
+    c.z = homeDistance(h, 40) * 0.6;
+    c.lookAtX = w / 2;
+    c.lookAtY = h / 2;
+    c.lookAtZ = 0;
+    c.intensity = 1;
+    c.color = "#ffffff";
+    c.coneAngle = 90;
+    c.coneFeather = 0.5;
+    c.radius = 500;
+    c.falloffDistance = 500;
+    c.shadowDarkness = 1;
+    c.shadowDiffusion = 0;
+    this.target = c;
+  }
+  state() {
+    const c = this.target;
+    try {
+      this.color.setValue(c.color);
+    } catch {
+      this.color.setValue(16777215);
+    }
+    const [r, g, b] = this.color.toArray();
+    return {
+      // a kind or falloff nobody knows is the default the warning promises (the shader must never see an unknown id)
+      kind: LIGHT_KINDS.includes(this.spec.kind) ? this.spec.kind : "point",
+      x: c.x,
+      y: c.y,
+      z: c.z,
+      lookAtX: c.lookAtX,
+      lookAtY: c.lookAtY,
+      lookAtZ: c.lookAtZ,
+      r,
+      g,
+      b,
+      intensity: Number.isFinite(c.intensity) ? Math.max(0, c.intensity) : 1,
+      coneAngle: c.coneAngle,
+      coneFeather: c.coneFeather,
+      falloff: FALLOFFS.includes(this.spec.falloff) ? this.spec.falloff : "none",
+      radius: c.radius,
+      falloffDistance: c.falloffDistance,
+      castsShadows: !!this.spec.castsShadows,
+      shadowDarkness: Math.min(1, Math.max(0, c.shadowDarkness)),
+      shadowDiffusion: Math.max(0, c.shadowDiffusion)
+    };
+  }
+  window() {
+    const start = this.absoluteStart ?? this.at;
+    return { start, end: start + (this.duration ?? 0) };
+  }
+};
+
 // src/core/revertibleSet.ts
 function revertibleSet(timeline, at, read, write, value) {
   let p = 0;
@@ -2153,8 +2558,8 @@ function validateGradientKeyframes(spec, who, warn = (m) => console.warn(m), kin
           }
         } else if (/^fillGradient\./i.test(key) || /^gradient/i.test(key)) {
           const tail = key.replace(/^fillGradient\./i, "").replace(/^gradient/i, "");
-          const sub = tail ? tail[0].toLowerCase() + tail.slice(1) : "angle";
-          say(`"${key}" is not an animatable property: write fillGradient: { ${PATCH_KEYS.includes(sub) ? sub : "angle"} } (the whole gradient is one object) in the keyframe's to / from / set`);
+          const sub2 = tail ? tail[0].toLowerCase() + tail.slice(1) : "angle";
+          say(`"${key}" is not an animatable property: write fillGradient: { ${PATCH_KEYS.includes(sub2) ? sub2 : "angle"} } (the whole gradient is one object) in the keyframe's to / from / set`);
         }
       }
     }
@@ -2541,7 +2946,7 @@ var AudioSequence = class extends Sequence {
     const raw = spec;
     if (raw.asset !== void 0) console.warn(`pixi-effects: ${who}: has both asset and sfx \u2014 the sfx plays; remove one`);
     if (raw.loop) console.warn(`pixi-effects: ${who}: loop has no effect on an sfx \u2014 to repeat it, add one audio layer per hit (a JS loop)`);
-    const { resolveSfx, renderSfx, sfxKey } = await import('./sfx-3IDAJ3UZ.js');
+    const { resolveSfx, renderSfx, sfxKey } = await import('./sfx-VUKARHDX.js');
     const sfx = resolveSfx(spec.sfx, spec.duration, who);
     if (!sfx) return;
     this.duration = sfx.length;
@@ -2560,7 +2965,7 @@ var AudioSequence = class extends Sequence {
     const raw = spec;
     if (raw.asset !== void 0) console.warn(`pixi-effects: ${who}: has both asset and music \u2014 the music plays; remove one`);
     if (raw.sfx !== void 0) console.warn(`pixi-effects: ${who}: has both sfx and music \u2014 the music plays; remove one`);
-    const { resolveMusic, renderMusic, musicLength, musicKey } = await import('./music-FUN7N225.js');
+    const { resolveMusic, renderMusic, musicLength, musicKey } = await import('./music-AF4VTFAF.js');
     const music = resolveMusic(spec.music, who);
     if (!music) return;
     const natural = musicLength(music);
@@ -3353,7 +3758,7 @@ function drawEllipseFromState(g, s) {
   const ay = s.anchorY ?? 0.5;
   g.ellipse((0.5 - ax) * 2 * rx, (0.5 - ay) * 2 * ry, rx, ry);
 }
-var DEG2 = Math.PI / 180;
+var DEG4 = Math.PI / 180;
 function drawArcFromState(g, s) {
   const r = s.radius ?? 0;
   const ri = Math.max(0, Math.min(s.innerRadius ?? 0, r));
@@ -3368,7 +3773,7 @@ function drawArcFromState(g, s) {
     }
     endDeg = startDeg + Math.sign(endDeg - startDeg) * 359.999;
   }
-  const a0 = startDeg * DEG2, a1 = endDeg * DEG2;
+  const a0 = startDeg * DEG4, a1 = endDeg * DEG4;
   const ccw = a1 < a0;
   if (filled) g.moveTo(r * Math.cos(a0), r * Math.sin(a0));
   g.arc(0, 0, r, a0, a1, ccw);
@@ -3550,11 +3955,396 @@ function numOrZero(v, scope) {
   return 0;
 }
 
+// src/core/glShared.ts
+var shared = null;
+var generation = 0;
+var refs = 0;
+var unavailable = false;
+function create() {
+  if (typeof document === "undefined") return null;
+  const canvas = document.createElement("canvas");
+  const gl = canvas.getContext("webgl2", { alpha: true, premultipliedAlpha: true, preserveDrawingBuffer: true, antialias: false });
+  if (!gl) return null;
+  const made = { gl, canvas, generation: ++generation };
+  canvas.addEventListener("webglcontextlost", (e) => {
+    e.preventDefault();
+    if (shared === made) shared = null;
+  });
+  return made;
+}
+function currentGl() {
+  if (shared) return shared;
+  if (unavailable) return null;
+  shared = create();
+  if (!shared) unavailable = true;
+  return shared;
+}
+function acquireGl() {
+  refs++;
+  return currentGl();
+}
+function releaseGl() {
+  refs = Math.max(0, refs - 1);
+  if (refs === 0 && shared) {
+    const lose = shared.gl.getExtension?.("WEBGL_lose_context");
+    try {
+      lose?.loseContext();
+    } catch {
+    }
+    shared = null;
+  }
+}
+
+// src/core/shaderChecks.ts
+var SHADER_BUILTINS = ["iResolution", "iTime", "iFrame"];
+var SHADER_MISSING = ["iMouse", "iChannel0", "iChannel1", "iChannel2", "iChannel3", "iDate", "iTimeDelta", "iSampleRate"];
+var IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var HEX = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+var RESERVED = new Set(`attribute const uniform varying break continue do for while if else in out inout float int void bool true false discard return
+  mat2 mat3 mat4 mat2x2 mat2x3 mat2x4 mat3x2 mat3x3 mat3x4 mat4x2 mat4x3 mat4x4 vec2 vec3 vec4 ivec2 ivec3 ivec4 bvec2 bvec3 bvec4 uvec2 uvec3 uvec4 uint
+  sampler2D sampler3D samplerCube sampler2DShadow samplerCubeShadow sampler2DArray sampler2DArrayShadow isampler2D isampler3D isamplerCube isampler2DArray
+  usampler2D usampler3D usamplerCube usampler2DArray struct layout centroid flat smooth precision invariant highp mediump lowp
+  sample patch subroutine common partition active asm class union enum typedef template this resource goto inline noinline public static extern external
+  interface long short double half fixed unsigned superp input output hvec2 hvec3 hvec4 fvec2 fvec3 fvec4 dvec2 dvec3 dvec4 filter sizeof cast namespace using`.split(/\s+/));
+var isIdent = (name) => IDENT.test(name) && !name.startsWith("gl_") && !name.includes("__") && !RESERVED.has(name) && !SHADER_BUILTINS.includes(name);
+function uniformType(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? "float" : null;
+  if (typeof v === "string") return HEX.test(v) ? "vec3" : null;
+  if (Array.isArray(v) && v.length >= 2 && v.length <= 4 && v.every((n) => typeof n === "number" && Number.isFinite(n))) return `vec${v.length}`;
+  return null;
+}
+function uniformFloats(v) {
+  if (typeof v === "number") return [v];
+  if (typeof v === "string") {
+    const h = v.length === 4 ? v.slice(1).replace(/./g, (c) => c + c) : v.slice(1);
+    return [0, 2, 4].map((i) => parseInt(h.slice(i, i + 2), 16) / 255);
+  }
+  return v.slice();
+}
+function uniformDecls(uniforms) {
+  let out = "";
+  for (const [name, v] of Object.entries(uniforms ?? {})) {
+    const type = uniformType(v);
+    if (type && isIdent(name)) out += `uniform ${type} ${name};
+`;
+  }
+  return out;
+}
+var HEAD = `#version 300 es
+#line 100001
+precision highp float;
+precision highp int;
+uniform vec3 iResolution;
+uniform float iTime;
+uniform int iFrame;
+out vec4 pe_out;
+`;
+var FOOT = (transparent) => `
+#line 200001
+void main() { vec4 c = vec4(0.0, 0.0, 0.0, 1.0); mainImage(c, gl_FragCoord.xy); ${transparent ? "pe_out = vec4(c.rgb * c.a, c.a);" : "pe_out = vec4(c.rgb, 1.0);"} }
+`;
+function wrapFragment(user, uniforms, transparent) {
+  const prefix = HEAD + uniformDecls(uniforms) + "#line 1\n";
+  return { source: prefix + user + FOOT(transparent), userLine: prefix.split("\n").length };
+}
+function glslErrors(log) {
+  const out = [];
+  for (const raw of (log ?? "").split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    const angle = /^ERROR:\s*\d+:(\d+):\s*(.*)$/.exec(line);
+    const mesa = /^\d+:(\d+)\(\d+\):\s*(?:error|warning):\s*(.*)$/.exec(line);
+    const hit = angle ?? mesa;
+    if (!hit) {
+      out.push(line);
+      continue;
+    }
+    const n = Number(hit[1]);
+    if (n >= 200001) out.push(`in the main() made for you, which calls mainImage: ${hit[2]} (write void mainImage(out vec4 fragColor, in vec2 fragCoord))`);
+    else if (n >= 100001) out.push(`in the declarations made from your uniforms: ${hit[2]} (a uniform name GLSL does not allow, such as a reserved word?)`);
+    else out.push(`line ${n}: ${hit[2]}`);
+  }
+  return out;
+}
+var stripComments = (code) => code.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/.*$/gm, " ");
+function shaderProblems(spec) {
+  const out = [];
+  const raw = spec;
+  if (typeof raw.fragment !== "string" || raw.fragment.trim() === "") {
+    out.push("fragment is the GLSL of the shader: write { type: 'shader', fragment: 'void mainImage(out vec4 fragColor, in vec2 fragCoord) { fragColor = vec4(fragCoord / iResolution.xy, 0.0, 1.0); }' }");
+  } else {
+    const code = stripComments(raw.fragment);
+    if (!/\bvoid\s+mainImage\s*\(/.test(code)) {
+      out.push("there is no mainImage: write void mainImage(out vec4 fragColor, in vec2 fragCoord) { \u2026 } (Shadertoy style; the layer calls it for every pixel)" + (/\bvoid\s+main\s*\(/.test(code) ? " and not main()" : ""));
+    } else {
+      if (/\bvoid\s+main\s*\(/.test(code)) out.push("main() is written for you (it calls your mainImage): remove your main()");
+      if (!/\bvoid\s+mainImage\s*\(\s*(?:out|inout)\s+(?:(?:highp|mediump|lowp)\s+)?vec4\s+\w+\s*,\s*(?:in\s+)?(?:(?:highp|mediump|lowp)\s+)?vec2\s+\w+\s*\)/.test(code)) {
+        out.push("the signature of mainImage must be void mainImage(out vec4 fragColor, in vec2 fragCoord): the colour parameter is out (without out the layer draws black and nothing says why) and the position is a vec2");
+      }
+    }
+    if (/^\s*#version\b/m.test(code)) out.push("#version is added for you (GLSL ES 3.00): remove it");
+    if (/\bgl_FragColor\b/.test(code)) out.push("gl_FragColor does not exist here: write the colour into the fragColor parameter of mainImage");
+    if (/\btexture2D\s*\(|\btextureCube\s*\(/.test(code)) out.push("texture2D is GLSL ES 1.00: this is GLSL ES 3.00, write texture(\u2026) (and note that this version has no textures to read)");
+    if (/\b(?:varying|attribute)\b/.test(code)) out.push("varying and attribute are not used in a fragment-only shader: remove them");
+    for (const b of SHADER_BUILTINS) {
+      if (new RegExp(`\\buniform\\s+\\w+\\s+${b}\\b`).test(code)) out.push(`${b} is declared for you: remove your uniform ${b}`);
+    }
+    const missing = SHADER_MISSING.filter((n) => new RegExp(`\\b${n}\\b`).test(code));
+    if (missing.length) out.push(`${missing.join(", ")} ${missing.length > 1 ? "are" : "is"} not provided in this version (the shader has iResolution, iTime, iFrame and your uniforms); the shader will not compile`);
+    if (/\bwhile\s*\(/.test(code)) out.push("a while loop may never end and a GPU cannot be stopped: use a for loop with a constant bound");
+    const consts = new Set([...code.matchAll(/\bconst\s+(?:int|float|uint)\s+(\w+)/g)].map((m) => m[1]).concat([...code.matchAll(/#define\s+(\w+)/g)].map((m) => m[1])));
+    const constant = (expr) => {
+      const rest = expr.replace(/\d+\.?\d*(?:[eE][-+]?\d+)?[uUfF]?|\.\d+(?:[eE][-+]?\d+)?[fF]?|[A-Za-z_]\w*/g, (t) => /^[A-Za-z_]/.test(t) && !consts.has(t) ? "?" : "");
+      return /^[\s+\-*/%()]*$/.test(rest);
+    };
+    for (const m of code.matchAll(/\bfor\s*\(\s*(?:int|float|uint)\s+\w+\s*=\s*[^;]+;\s*\w+\s*(?:<=|>=|<|>|!=)\s*([^;]+?)\s*;/g)) {
+      const bound = m[1];
+      const ands = bound.split("&&"), ors = bound.split("||");
+      const ok = ors.length > 1 ? ors.every((part) => constant(part.split("&&")[0].replace(/<.*$/, ""))) : ands.length > 1 ? ands.some(constant) || constant(ands[0]) : constant(bound);
+      if (!ok) {
+        out.push(`a for loop with the bound "${bound}" may run for ever: use a constant bound (a number or a const) and break out early`);
+        break;
+      }
+    }
+  }
+  if (raw.uniforms !== void 0) {
+    if (raw.uniforms === null || typeof raw.uniforms !== "object" || Array.isArray(raw.uniforms)) {
+      out.push("uniforms is an object of names to values: { speed: 1, tint: '#ff8040', pos: [0.5, 0.5] }");
+    } else {
+      for (const [name, v] of Object.entries(raw.uniforms)) {
+        if (!isIdent(name)) out.push(`uniform "${name}" is not a name GLSL can use (letters, digits and _, not starting with a digit; not a GLSL keyword or reserved word such as sample, smooth, filter, input; not iResolution / iTime / iFrame)`);
+        else if (uniformType(v) === null) out.push(`uniform "${name}": ${JSON.stringify(v)} is not a number, 2 to 4 numbers or a '#rrggbb' colour`);
+      }
+    }
+  }
+  if (raw.resolution !== void 0 && !(typeof raw.resolution === "number" && raw.resolution > 0 && raw.resolution <= 2)) {
+    out.push(`resolution ${JSON.stringify(raw.resolution)} is not a number above 0 and at most 2 (0.5 draws a quarter of the pixels and scales up); 1 is used`);
+  }
+  if (raw.transparent !== void 0 && typeof raw.transparent !== "boolean") out.push("transparent is true or false (true uses the shader's alpha; the default draws opaque)");
+  return out;
+}
+
+// src/sequences/Shader.ts
+var VERT = `#version 300 es
+void main() { vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2)); gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0); }`;
+var ShaderSequence = class extends Sequence {
+  prog = null;
+  progGeneration = -1;
+  w = 1;
+  h = 1;
+  c2d = null;
+  fps = 30;
+  failed = false;
+  warnedNoGl = false;
+  acquired = false;
+  warnedPaths = /* @__PURE__ */ new Set();
+  /** The current value of every uniform: what keyframes move (`uniforms.speed`, `uniforms.tint.0`). */
+  carrier = {};
+  /** How many components each vector uniform has (a scalar is not listed). */
+  dims = {};
+  get shaderSpec() {
+    return this.spec;
+  }
+  pathRouters() {
+    return { uniforms: (path) => this.resolveUniform(path) };
+  }
+  async build() {
+    const spec = this.shaderSpec;
+    const who = describeLayer(spec);
+    for (const m of shaderProblems(spec)) console.warn(`pixi-effects: ${who}: ${m}`);
+    if (this.duration === void 0) this.duration = this.parent?.duration ?? this.root.duration;
+    const scope = buildScope(this, this.parent, this.root);
+    const width = resolveDim(spec.width, scope) ?? this.parent?.width ?? this.root.width;
+    const height = resolveDim(spec.height, scope) ?? this.parent?.height ?? this.root.height;
+    const res = typeof spec.resolution === "number" && spec.resolution > 0 && spec.resolution <= 2 ? spec.resolution : 1;
+    this.w = Math.max(1, Math.round(width * res));
+    this.h = Math.max(1, Math.round(height * res));
+    this.fps = this.root.frameRate ?? 30;
+    for (const [name, v] of Object.entries(spec.uniforms ?? {})) {
+      if (uniformType(v) === null) continue;
+      if (typeof v === "number") this.carrier[name] = v;
+      else {
+        const f = uniformFloats(v);
+        this.carrier[name] = Object.fromEntries(f.map((x, i) => [String(i), x]));
+        this.dims[name] = f.length;
+      }
+    }
+    this.c2d = document.createElement("canvas");
+    this.c2d.width = this.w;
+    this.c2d.height = this.h;
+    const sprite = new Sprite({ texture: Texture.from(this.c2d), label: spec.name });
+    sprite.width = width;
+    sprite.height = height;
+    this.target = sprite;
+    this.intrinsicWidth = width;
+    this.intrinsicHeight = height;
+    this.buildFilters();
+    if (typeof spec.fragment === "string" && spec.fragment.trim() !== "") this.acquire();
+    else this.failed = true;
+    this.drawAt(0);
+  }
+  async awaitFrameAt(local) {
+    this.drawAt(Math.max(0, Math.min(local, this.duration ?? local)));
+  }
+  /** Resolve `uniforms.speed` / `uniforms.tint.0` for the keyframe pipeline; a name or index nobody has is said once and dropped. */
+  resolveUniform(path) {
+    const segs = path.split(".");
+    const name = segs[0];
+    const slot = this.carrier[name];
+    const warn = (why) => {
+      if (this.warnedPaths.has(path)) return;
+      this.warnedPaths.add(path);
+      console.warn(`pixi-effects: ${describeLayer(this.spec)}: keyframe path uniforms.${path} ${why}; skipped`);
+    };
+    if (slot === void 0) {
+      const guess = suggestName(name, Object.keys(this.carrier));
+      warn(`names no uniform "${name}"${guess ? `; did you mean "${guess}"?` : ""} (declare it in uniforms with a starting value)`);
+      return null;
+    }
+    if (typeof slot === "number") {
+      if (segs.length !== 1) {
+        warn(`has more than a name, but "${name}" is a single number`);
+        return null;
+      }
+      return { target: this.carrier, prop: name };
+    }
+    const n = this.dims[name];
+    const index = segs.length === 2 ? Number(segs[1]) : NaN;
+    if (!Number.isInteger(index) || index < 0 || index >= n) {
+      warn(`must name a component of "${name}" (0 to ${n - 1}): 'uniforms.${name}.0'`);
+      return null;
+    }
+    return { target: slot, prop: String(index) };
+  }
+  acquire() {
+    const sh = acquireGl();
+    this.acquired = true;
+    if (!sh) {
+      this.noGl();
+      return;
+    }
+    this.compile();
+  }
+  noGl() {
+    this.failed = true;
+    if (!this.warnedNoGl) {
+      this.warnedNoGl = true;
+      console.warn(`pixi-effects: ${describeLayer(this.spec)}: this browser has no WebGL2, so the shader cannot run; the layer is drawn as a checkerboard`);
+    }
+  }
+  compile() {
+    const sh = currentGl();
+    if (!sh) {
+      this.noGl();
+      return;
+    }
+    const { gl } = sh;
+    const spec = this.shaderSpec;
+    const make = (type, src) => {
+      const s = gl.createShader(type);
+      gl.shaderSource(s, src);
+      gl.compileShader(s);
+      return s;
+    };
+    const vs = make(gl.VERTEX_SHADER, VERT);
+    const fs = make(gl.FRAGMENT_SHADER, wrapFragment(spec.fragment, spec.uniforms ?? {}, !!spec.transparent).source);
+    const p = gl.createProgram();
+    gl.attachShader(p, vs);
+    gl.attachShader(p, fs);
+    gl.linkProgram(p);
+    const ok = gl.getProgramParameter(p, gl.LINK_STATUS);
+    const log = ok ? "" : gl.getShaderInfoLog(fs) || gl.getProgramInfoLog(p) || "";
+    gl.deleteShader(vs);
+    gl.deleteShader(fs);
+    if (!ok) {
+      gl.deleteProgram(p);
+      this.failed = true;
+      this.prog = null;
+      console.warn(`pixi-effects: ${describeLayer(this.spec)}: the fragment shader did not compile (the line numbers are the lines of your code):
+${glslErrors(log).join("\n")}
+The layer is drawn as a checkerboard until it is fixed.`);
+      return;
+    }
+    this.prog = p;
+    this.progGeneration = sh.generation;
+  }
+  drawAt(local) {
+    const c = this.c2d;
+    if (!c) return;
+    const ctx2 = c.getContext("2d");
+    if (!ctx2) return;
+    let sh = this.failed ? null : currentGl();
+    if (sh && this.progGeneration !== sh.generation) {
+      this.compile();
+      sh = this.failed ? null : currentGl();
+    }
+    if (!sh || !this.prog) {
+      const s = 32;
+      for (let y = 0; y < c.height; y += s) for (let x = 0; x < c.width; x += s) {
+        ctx2.fillStyle = x / s + y / s & 1 ? "#ff00ff" : "#220022";
+        ctx2.fillRect(x, y, s, s);
+      }
+    } else {
+      const { gl, canvas } = sh;
+      if (canvas.width !== this.w || canvas.height !== this.h) {
+        canvas.width = this.w;
+        canvas.height = this.h;
+      }
+      gl.viewport(0, 0, this.w, this.h);
+      gl.useProgram(this.prog);
+      gl.uniform3f(gl.getUniformLocation(this.prog, "iResolution"), this.w, this.h, 1);
+      gl.uniform1f(gl.getUniformLocation(this.prog, "iTime"), local);
+      gl.uniform1i(gl.getUniformLocation(this.prog, "iFrame"), Math.round(local * this.fps));
+      for (const [name, v] of Object.entries(this.carrier)) {
+        const loc = gl.getUniformLocation(this.prog, name);
+        if (typeof v === "number") {
+          gl.uniform1f(loc, v);
+          continue;
+        }
+        const n = this.dims[name];
+        const comps = Array.from({ length: n }, (_, i) => v[String(i)] ?? 0);
+        if (n === 2) gl.uniform2fv(loc, comps);
+        else if (n === 3) gl.uniform3fv(loc, comps);
+        else gl.uniform4fv(loc, comps);
+      }
+      gl.clearColor(0, 0, 0, 0);
+      gl.clear(gl.COLOR_BUFFER_BIT);
+      gl.drawArrays(gl.TRIANGLES, 0, 3);
+      ctx2.clearRect(0, 0, c.width, c.height);
+      ctx2.drawImage(canvas, 0, 0);
+    }
+    this.target?.texture.source.update();
+  }
+  destroy() {
+    const texture = this.target?.texture;
+    if (this.prog) {
+      const sh = currentGl();
+      if (sh && this.progGeneration === sh.generation) sh.gl.deleteProgram(this.prog);
+      this.prog = null;
+    }
+    if (this.acquired) {
+      this.acquired = false;
+      releaseGl();
+    }
+    if (this.c2d) {
+      this.c2d.width = this.c2d.height = 1;
+      this.c2d = null;
+    }
+    super.destroy();
+    texture?.destroy(true);
+  }
+};
+function resolveDim(v, scope) {
+  if (v === void 0) return void 0;
+  if (typeof v === "number") return v;
+  return evaluateExpr(v, scope);
+}
+
 // src/core/Composition.ts
 var _CompositionSequence = null;
 async function getCompositionSequence() {
   if (!_CompositionSequence) {
-    _CompositionSequence = (await import('./Composition-Q5TVG3HM.js')).CompositionSequence;
+    _CompositionSequence = (await import('./Composition-C4FSWJZF.js')).CompositionSequence;
   }
   return _CompositionSequence;
 }
@@ -3565,6 +4355,8 @@ var staticTypes = {
   video: VideoSequence,
   shape: ShapeSequence,
   camera: CameraSequence,
+  light: LightSequence,
+  shader: ShaderSequence,
   null: NullSequence
 };
 var registry2 = {};
@@ -3592,6 +4384,6 @@ async function buildSequenceTree(specs, parent, root) {
   return out;
 }
 
-export { CameraSequence, DEFAULT_FOV, DEG, MANY_BLURRED, MAX_BLUR, MIN_BLUR, NEAR, NullSequence, Sequence, bindClock, blurRadius, buildScope, buildSequenceTree, cameraBasis, checkEase, clockTable, contentLength, ensureFilterLibrary, evaluateExpr, flattenSvgPath, focusProblems, homeCamera, homeDistance, layerInitialZ, noise, projectLayer, projectPoint, rand, random, registerSequenceType, remapOf, resolveAt, timeRemapOf };
-//# sourceMappingURL=chunk-DC4JPY6A.js.map
-//# sourceMappingURL=chunk-DC4JPY6A.js.map
+export { CameraSequence, DEFAULT_FOV, DEG2 as DEG, FALLOFFS, LIGHT_KINDS, LIGHT_PROPS, LightSequence, MANY_BLURRED, MAX_BLUR, MAX_CASTERS, MAX_LIGHTS, MIN_BLUR, NEAR, NullSequence, SHADOW_TAPS, Sequence, bindClock, blurRadius, buildScope, buildSequenceTree, cameraBasis, checkEase, clockTable, contentLength, ensureFilterLibrary, evaluateExpr, flattenSvgPath, focusProblems, homeCamera, homeDistance, layerInitialZ, layerToWorld, lightLevel, noise, packLights, projectLayer, projectPoint, rand, random, registerSequenceType, remapOf, resolveAt, timeRemapOf };
+//# sourceMappingURL=chunk-PRZ4U6JN.js.map
+//# sourceMappingURL=chunk-PRZ4U6JN.js.map