pixi-effects 0.3.0 → 0.5.0

package/dist/{chunk-PN5A6QA7.js → chunk-UBPZLGLU.js}

@@ -739,6 +739,11 @@ var Sequence = class {
    * (not a normal child) by PIXI when `target.mask = maskSequence.target`.
    */
   maskSequence = null;
+  /**
+   * Set by the parent composition on a sprite-based (image / video) mask. PIXI hides such a mask with
+   * `renderable = false`; the lifespan toggles must not switch it back on, or the mask is drawn as a picture.
+   */
+  keepHidden = false;
   /**
    * Absolute start time on the global timeline (offset + at), recorded by
    * bindTimeline. Movie._awaitVideoFrames uses it to determine the correct
@@ -783,6 +788,7 @@ var Sequence = class {
     applyKeyframes(timeline, this.target, this.spec.keyframes, this.duration, scope, [], startTime, routers);
     const endTime = startTime + this.duration;
     this.absoluteStart = startTime;
+    if (this.keepHidden) return;
     this.target.renderable = startTime <= 0;
     timeline.set(this.target, { renderable: true }, startTime);
     timeline.set(this.target, { renderable: false }, endTime);
@@ -796,6 +802,14 @@ var Sequence = class {
    */
   updateSpace(_t, _host) {
   }
+  /**
+   * Runs once per rendered frame, after the timeline seek and before the cull. Layers whose drawn
+   * geometry follows tweened state (shapes) redraw here, so the culler measures where the layer is NOW
+   * and not where it was drawn at the previous render.
+   */
+  syncFrame() {
+    this.maskSequence?.syncFrame();
+  }
   destroy() {
     this.maskSequence?.destroy();
     this.maskSequence = null;
@@ -827,18 +841,27 @@ function lintTiming(spec, parentDuration, warn = defaultWarn) {
   if (at >= parentDuration) {
     warn(`pixi-effects: ${who} starts at ${at}s, after its composition ends (${parentDuration}s), so it is never visible`);
   }
+  if (spec.type === "audio" && spec.sfx !== void 0 && spec.duration === void 0) return;
   const duration = spec.duration ?? parentDuration;
   (spec.keyframes ?? []).forEach((kf, i) => {
     const kat = kf.at ?? 0;
     if (kat >= duration) {
       warn(
-        `pixi-effects: ${who}: keyframes[${i}] starts at ${kat}s, after the layer ends (duration ${duration}s), so it never plays. Keyframe \`at\` is measured from the start of this layer, not from the start of the composition.`
+        `pixi-effects: ${who}: keyframes[${i}] starts at ${kat}s, after the layer ends (duration ${duration}s), so it never plays. Keyframe \`at\` is measured from the start of this layer, not from the start of the composition.`,
+        "late-keyframe"
       );
     }
   });
 }
+function summarizeWarnings(messages, shown = 3) {
+  if (messages.length <= shown) return messages;
+  return [...messages.slice(0, shown), `pixi-effects: ${messages.length - shown} more layers with the same problem (the same loop or helper is probably building them): fix the ones above and these go away.`];
+}
 function lintText(spec, warn = defaultWarn) {
   if (spec.type !== "text") return;
+  if ((spec.text ?? "").includes("{value}") && !collectPropKeys(spec).has("value")) {
+    warn(`pixi-effects: ${describeLayer(spec)}: the text has a {value} placeholder but nothing sets or animates \`value\`, so it prints 0. Set initial: { value: \u2026 } or animate it; {value} is reserved for counters (there is no way to print a literal "{value}").`);
+  }
   if (collectPropKeys(spec).has("value") && !(spec.text ?? "").includes("{value}")) {
     warn(`pixi-effects: ${describeLayer(spec)}: \`value\` is set or animated but the text has no {value} placeholder, so nothing shows it. Use text: '{value}' (or e.g. '{value} users').`);
   }
@@ -1011,7 +1034,30 @@ var CameraSequence = class extends Sequence {
   }
 };
 
+// src/core/revertibleSet.ts
+function revertibleSet(timeline, at, read, write, value) {
+  let p = 0;
+  let before;
+  const proxy = {
+    get p() {
+      return p;
+    },
+    set p(next) {
+      if (next >= 1 && p < 1) {
+        before = read();
+        write(value);
+      } else if (next < 1 && p >= 1) {
+        write(before);
+      }
+      p = next;
+    }
+  };
+  timeline.set(proxy, { p: 1 }, at);
+}
+
 // src/expr/colorInterp.ts
+var CHROMA_FLOOR = 0.03;
+var CHROMA_FULL = 0.08;
 function buildColorInterp(from, to, space) {
   const fromRGBA = parseToRGBA(from);
   const toRGBA = parseToRGBA(to);
@@ -1028,8 +1074,9 @@ function buildColorInterp(from, to, space) {
   }
   const fromLCH = oklabToOklch(fromOk);
   const toLCH = oklabToOklch(toOk);
-  if (fromLCH.C < 1e-4) fromLCH.h = toLCH.h;
-  if (toLCH.C < 1e-4) toLCH.h = fromLCH.h;
+  const fromHue = fromLCH.h, toHue = toLCH.h;
+  fromLCH.h = borrowHue(fromHue, fromLCH.C, toHue);
+  toLCH.h = borrowHue(toHue, toLCH.C, fromHue);
   const hueDelta = shortestHueDelta(fromLCH.h, toLCH.h);
   return (t) => {
     const L = lerp(fromLCH.L, toLCH.L, t);
@@ -1040,6 +1087,11 @@ function buildColorInterp(from, to, space) {
     return rgbaString(oklabToRgb(ab), alpha);
   };
 }
+function borrowHue(own, chroma, other) {
+  const u = Math.min(1, Math.max(0, (chroma - CHROMA_FLOOR) / (CHROMA_FULL - CHROMA_FLOOR)));
+  const keep = u * u * (3 - 2 * u);
+  return own + shortestHueDelta(own, other) * (1 - keep);
+}
 function parseToRGBA(input) {
   if (typeof input === "number") {
     return { r: (input >> 16 & 255) / 255, g: (input >> 8 & 255) / 255, b: (input & 255) / 255, a: 1 };
@@ -1201,9 +1253,10 @@ var ImageSequence = class extends Sequence {
       const toTint = kf.to?.tint;
       const setTint = kf.set?.tint;
       if (setTint !== void 0) {
-        timeline.call(() => {
-          this.target.tint = setTint;
-        }, [], at);
+        const sprite = this.target;
+        revertibleSet(timeline, at, () => sprite.tint, (c) => {
+          sprite.tint = c;
+        }, setTint);
       }
       if (toTint !== void 0) {
         tweenColor(
@@ -1223,6 +1276,7 @@ var ImageSequence = class extends Sequence {
     }
     this.absoluteStart = startTime;
     const endTime = startTime + this.duration;
+    if (this.keepHidden) return;
     this.target.renderable = startTime <= 0;
     timeline.set(this.target, { renderable: true }, startTime);
     timeline.set(this.target, { renderable: false }, endTime);
@@ -1250,12 +1304,31 @@ function stripKeysInKeyframe(kf, keys) {
     from: stripKeys(kf.from, keys)
   };
 }
-var STYLE_OPAQUE_KEYS = ["fontFamily", "fill", "align", "fontStyle", "fontWeight"];
+var STYLE_OPAQUE_KEYS = [
+  "fontFamily",
+  "fill",
+  "align",
+  "fontStyle",
+  "fontWeight",
+  "fontVariant",
+  "textBaseline",
+  "whiteSpace",
+  "lineJoin",
+  "join",
+  "cap",
+  "color",
+  "stroke"
+];
 function formatValue(v, f) {
   const fixed = v.toFixed(Math.max(0, Math.floor(f?.decimals ?? 0)));
-  if (!f?.grouping) return fixed;
-  const [int, frac] = fixed.split(".");
-  return int.replace(/\B(?=(\d{3})+(?!\d))/g, ",") + (frac !== void 0 ? "." + frac : "");
+  const pad = Math.max(0, Math.floor(f?.pad ?? 0));
+  if (!f?.grouping && !pad) return fixed;
+  const [signed, frac] = fixed.split(".");
+  const sign = signed.startsWith("-") ? "-" : "";
+  let int = sign ? signed.slice(1) : signed;
+  if (pad) int = int.padStart(pad, "0");
+  if (f?.grouping) int = int.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return sign + int + (frac !== void 0 ? "." + frac : "");
 }
 var TextSequence = class extends Sequence {
   /** Current number for the `{value}` placeholder (tweened by `value` keyframes). */
@@ -1365,10 +1438,10 @@ function bindValueKeyframes(timeline, state, refresh, keyframes, parentDuration,
     const loop = loopVars(kf);
     if (setV !== void 0) {
       const v = resolveNumber(setV, scope);
-      timeline.call(() => {
-        state.value = v;
+      revertibleSet(timeline, at, () => state.value, (n) => {
+        state.value = n;
         refresh();
-      }, [], at);
+      }, v);
     }
     if (toV !== void 0 && fromV !== void 0) {
       timeline.fromTo(
@@ -1397,10 +1470,10 @@ function bindFillKeyframes(timeline, text, keyframes, parentDuration, offset, co
     const fromFill = pickFill(kf.from);
     const toFill = pickFill(kf.to);
     if (setFill !== void 0) {
-      timeline.call(() => {
-        state.fill = setFill;
+      revertibleSet(timeline, at, () => state.fill, (c) => {
+        state.fill = c;
         writeFill();
-      }, [], at);
+      }, setFill);
     }
     if (toFill !== void 0) {
       tweenColor(
@@ -1427,54 +1500,96 @@ function pickFill(props) {
 }
 var AudioSequence = class extends Sequence {
   _audioBuffer = null;
+  _synth = null;
+  _source = "";
   async build() {
-    const data = await Assets.get(this.spec.asset);
+    this.target = null;
+    if (this.spec.sfx !== void 0) return this._buildSfx(this.spec);
+    const spec = this.spec;
+    this._source = `asset "${spec.asset}"`;
+    const data = await Assets.get(spec.asset);
     this._audioBuffer = data.audioBuffer;
     if (this.duration === void 0) {
-      this.duration = this.spec.duration ?? data.duration ?? this.root.duration;
+      const rest = Math.max(0, (this.parent?.duration ?? this.root.duration) - this.at);
+      this.duration = spec.duration ?? (spec.loop ? rest : data.duration) ?? this.root.duration;
     }
-    if (!this.spec.loop && data.duration !== void 0 && this.duration > data.duration + 0.05) {
+    if (!spec.loop && data.duration !== void 0 && this.duration > data.duration + 0.05) {
       console.warn(
-        `pixi-effects: ${describeLayer(this.spec)}: audio asset "${this.spec.asset}" is ${data.duration.toFixed(1)}s but the layer lasts ${this.duration.toFixed(1)}s, so it goes silent after ${data.duration.toFixed(1)}s. Add loop: true, or shorten the layer's duration.`
+        `pixi-effects: ${describeLayer(spec)}: audio asset "${spec.asset}" is ${data.duration.toFixed(1)}s but the layer lasts ${this.duration.toFixed(1)}s, so it goes silent after ${data.duration.toFixed(1)}s. Add loop: true, or shorten the layer's duration.`
       );
     }
-    this.target = null;
+  }
+  async _buildSfx(spec) {
+    const who = describeLayer(spec);
+    const raw = spec;
+    if (raw.asset !== void 0) console.warn(`pixi-effects: ${who}: has both asset and sfx \u2014 the sfx plays; remove one`);
+    if (raw.loop) console.warn(`pixi-effects: ${who}: loop has no effect on an sfx \u2014 to repeat it, add one audio layer per hit (a JS loop)`);
+    const { resolveSfx, renderSfx, sfxKey } = await import('./sfx-S37DDC66.js');
+    const sfx = resolveSfx(spec.sfx, spec.duration, who);
+    if (!sfx) return;
+    this.duration = sfx.length;
+    this._source = `sfx "${sfx.preset ?? "custom"}"`;
+    this._synth = { key: sfxKey(sfx), render: (sr) => renderSfx(sfx, sr) };
+    (spec.keyframes ?? []).forEach((kf, i) => {
+      if ((kf.at ?? 0) >= sfx.length) {
+        console.warn(`pixi-effects: ${who}: keyframes[${i}] starts at ${kf.at}s, after the sound ends (${sfx.length}s), so it never plays`);
+      } else if ((kf.at ?? 0) < 0 && sfx.length + (kf.at ?? 0) < 0) {
+        console.warn(`pixi-effects: ${who}: keyframes[${i}] starts ${-kf.at}s before the END of a ${sfx.length}s sound, which is before the sound begins (a negative \`at\` counts back from the end of the layer). Use a shorter \`at\`, or stretch the sound with \`duration\`.`);
+      }
+    });
   }
   bindTimeline(_timeline) {
   }
   collectAudio(out, baseTime) {
-    if (!this._audioBuffer) return;
-    const initialVolume = this.spec.volume ?? 1;
-    const volumeKeyframes = [];
+    if (!this._audioBuffer && !this._synth) return;
+    const initialVolume = this.spec.volume ?? this.spec.initial?.volume ?? 1;
+    const t0 = baseTime + this.at;
     const dur = this.duration;
-    for (const raw of this.spec.keyframes ?? []) {
-      const kf = normalizeKeyframe(raw, dur);
-      const set = kf.set;
-      const to = kf.to;
-      const from = kf.from;
-      if (kf.kind === "set" && set && "volume" in set) {
-        volumeKeyframes.push({ time: baseTime + this.at + kf.at, value: set.volume });
-      } else if (kf.kind === "to" && to && "volume" in to) {
-        volumeKeyframes.push({ time: baseTime + this.at + kf.at + kf.duration, value: to.volume });
-      } else if (kf.kind === "fromTo" && to && "volume" in to) {
-        volumeKeyframes.push({ time: baseTime + this.at + kf.at, value: from?.volume ?? initialVolume });
-        volumeKeyframes.push({ time: baseTime + this.at + kf.at + kf.duration, value: to.volume });
-      } else if (kf.kind === "from" && from && "volume" in from) {
-        volumeKeyframes.push({ time: baseTime + this.at + kf.at, value: from.volume });
-        volumeKeyframes.push({ time: baseTime + this.at + kf.at + kf.duration, value: initialVolume });
-      }
-    }
     out.push({
-      buffer: this._audioBuffer,
-      loop: !!this.spec.loop,
-      start: baseTime + this.at,
-      end: baseTime + this.at + dur,
+      ...this._audioBuffer ? { buffer: this._audioBuffer } : { synth: this._synth },
+      layer: describeLayer(this.spec),
+      source: this._source,
+      loop: !this._synth && !!this.spec.loop,
+      start: t0,
+      end: t0 + dur,
       initialVolume,
-      volumeKeyframes
+      volumeKeyframes: this._volumePoints(t0, dur, initialVolume)
     });
   }
+  _volumePoints(t0, dur, initialVolume) {
+    const volumeKeyframes = [];
+    const keyframes = (this.spec.keyframes ?? []).map((raw) => normalizeKeyframe(raw, dur)).filter((kf) => [kf.set, kf.to, kf.from].some((p) => p && "volume" in p)).sort((x, y) => x.at - y.at);
+    let current = initialVolume;
+    const point = (time, value) => {
+      volumeKeyframes.push({ time, value });
+    };
+    for (const kf of keyframes) {
+      const start = t0 + kf.at;
+      const end = start + kf.duration;
+      const set = kf.set?.volume;
+      const to = kf.to?.volume;
+      const from = kf.from?.volume;
+      point(start, current);
+      if (kf.kind === "set" && set !== void 0) {
+        point(start, set);
+        current = set;
+      } else if (kf.kind === "to" && to !== void 0) {
+        point(end, to);
+        current = to;
+      } else if (kf.kind === "fromTo" && to !== void 0) {
+        point(start, from ?? current);
+        point(end, to);
+        current = to;
+      } else if (kf.kind === "from" && from !== void 0) {
+        point(start, from);
+        point(end, current);
+      }
+    }
+    return volumeKeyframes;
+  }
   destroy() {
     this._audioBuffer = null;
+    this._synth = null;
   }
 };
 
@@ -1623,6 +1738,8 @@ var VideoSequence = class extends Sequence {
     const initialVolume = this.spec.volume ?? 1;
     out.push({
       buffer: this._audioBuffer,
+      layer: describeLayer(this.spec),
+      source: `video "${this.spec.asset}"`,
       loop: !!this.spec.loop,
       start: baseTime + this.at,
       end: baseTime + this.at + this.duration,
@@ -1711,11 +1828,12 @@ var GEOMETRY_KEYS_BY_SHAPE = {
   rect: ["width", "height", "cornerRadius", "anchorX", "anchorY"],
   circle: ["radius", "anchorX", "anchorY"],
   ellipse: ["radiusX", "radiusY", "anchorX", "anchorY"],
+  arc: ["radius", "innerRadius", "startAngle", "endAngle"],
   line: [],
   polygon: [],
   path: []
 };
-var ANCHORED_SHAPES = /* @__PURE__ */ new Set(["rect", "circle", "ellipse"]);
+var ANCHORED_SHAPES = /* @__PURE__ */ new Set(["rect", "circle", "ellipse", "arc"]);
 var ShapeSequence = class extends Sequence {
   _state = {
     fillColor: void 0,
@@ -1742,6 +1860,11 @@ var ShapeSequence = class extends Sequence {
     for (const k of geomKeys) this._liveKeys.add(k);
     seedGeometry(this._state, this.spec, scope);
     seedStyle(this._state, this.spec.initial ?? {}, scope);
+    seedStrokeStyle(this._state, this.spec, this.spec.initial ?? {}, describeLayer(this.spec));
+    if (this.spec.shape === "arc") {
+      this._state.startAngle ??= 0;
+      this._state.endAngle ??= 360;
+    }
     const gradientSpec = this.spec.fillGradient ?? this.spec.initial?.fillGradient;
     if (gradientSpec) this._state.fillStyle = makeGradientFill(gradientSpec);
     this._drawGeometry = makeDrawGeometry(this.spec, scope, this._state);
@@ -1759,12 +1882,32 @@ var ShapeSequence = class extends Sequence {
       if (init.y === void 0) graphics.y = cy;
     }
     graphics.onRender = () => {
-      graphics.clear();
-      this._drawGeometry(graphics);
-      applyState(graphics, this._state);
+      if (this._fresh) {
+        this._fresh = false;
+        return;
+      }
+      this._redraw();
     };
     this.buildFilters();
   }
+  _fresh = false;
+  _redraw() {
+    const graphics = this.target;
+    graphics.clear();
+    this._drawGeometry(graphics);
+    applyState(graphics, this._state);
+  }
+  /**
+   * Draw from the tweened `_state` before the culler runs. The culler measures the geometry as last
+   * drawn; a layer drawn only inside `onRender` is culled on stale bounds (a rect growing from
+   * `width: 0` at the left edge was skipped after a jump seek, and one frame late in playback).
+   */
+  syncFrame() {
+    super.syncFrame();
+    if (!this.target?.renderable) return;
+    this._redraw();
+    this._fresh = true;
+  }
   bindTimeline(timeline, offset = 0) {
     if (!this.target) return;
     const scope = this.scope();
@@ -1790,6 +1933,21 @@ function seedGeometry(state, spec, scope) {
     if (v !== void 0) state[k] = num(v, scope);
   }
 }
+var STROKE_CAPS = ["butt", "round", "square"];
+var STROKE_JOINS = ["miter", "round", "bevel"];
+function seedStrokeStyle(state, spec, initial, who) {
+  const top = spec;
+  const ini = initial;
+  const pick = (key, valid) => {
+    const v = top[key] ?? ini[key];
+    if (v === void 0) return void 0;
+    if (valid.includes(String(v))) return String(v);
+    console.warn(`pixi-effects: ${who}: ${key} "${v}" is not one of ${valid.join(", ")}; ignored`);
+    return void 0;
+  };
+  state.strokeCap = pick("strokeCap", STROKE_CAPS);
+  state.strokeJoin = pick("strokeJoin", STROKE_JOINS);
+}
 function seedStyle(state, initial, scope) {
   for (const k of STYLE_KEYS) {
     const v = initial[k];
@@ -1798,8 +1956,8 @@ function seedStyle(state, initial, scope) {
   }
 }
 function stripGradient(props) {
-  if (!props || !("fillGradient" in props)) return props;
-  const { fillGradient: _drop, ...rest } = props;
+  if (!props || !("fillGradient" in props || "strokeCap" in props || "strokeJoin" in props)) return props;
+  const { fillGradient: _drop, strokeCap: _cap, strokeJoin: _join, ...rest } = props;
   return rest;
 }
 function stripLive(props, liveKeys) {
@@ -1846,7 +2004,13 @@ function applyState(g, s) {
     g.fill({ color: s.fillColor, alpha: s.fillAlpha });
   }
   if (s.strokeColor !== void 0 && s.strokeWidth > 0) {
-    g.stroke({ color: s.strokeColor, alpha: s.strokeAlpha, width: s.strokeWidth });
+    g.stroke({
+      color: s.strokeColor,
+      alpha: s.strokeAlpha,
+      width: s.strokeWidth,
+      ...s.strokeCap ? { cap: s.strokeCap } : {},
+      ...s.strokeJoin ? { join: s.strokeJoin } : {}
+    });
   }
 }
 function drawRectFromState(g, s) {
@@ -1873,6 +2037,34 @@ 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;
+function drawArcFromState(g, s) {
+  const r = s.radius ?? 0;
+  const ri = Math.max(0, Math.min(s.innerRadius ?? 0, r));
+  const startDeg = s.startAngle ?? 0;
+  let endDeg = s.endAngle ?? 360;
+  if (!(r > 0) || endDeg === startDeg) return;
+  const filled = !!s.fillStyle || s.fillColor !== void 0;
+  if (Math.abs(endDeg - startDeg) >= 360) {
+    if (!filled) {
+      g.circle(0, 0, r);
+      return;
+    }
+    endDeg = startDeg + Math.sign(endDeg - startDeg) * 359.999;
+  }
+  const a0 = startDeg * DEG2, a1 = endDeg * DEG2;
+  const ccw = a1 < a0;
+  if (filled) g.moveTo(r * Math.cos(a0), r * Math.sin(a0));
+  g.arc(0, 0, r, a0, a1, ccw);
+  if (!filled) return;
+  if (ri > 0) {
+    g.lineTo(ri * Math.cos(a1), ri * Math.sin(a1));
+    g.arc(0, 0, ri, a1, a0, !ccw);
+  } else {
+    g.lineTo(0, 0);
+  }
+  g.closePath();
+}
 function makeLineDraw(spec, scope) {
   const fx = num(spec.from[0], scope);
   const fy = num(spec.from[1], scope);
@@ -1901,7 +2093,8 @@ function makePathDraw(spec) {
 var STATE_DRAWERS = {
   rect: drawRectFromState,
   circle: drawCircleFromState,
-  ellipse: drawEllipseFromState
+  ellipse: drawEllipseFromState,
+  arc: drawArcFromState
 };
 function makeDrawGeometry(spec, scope, state) {
   const stateDrawer = STATE_DRAWERS[spec.shape];
@@ -1928,9 +2121,10 @@ function bindLiveKeyframes(timeline, state, liveKeys, keyframes, parentDuration,
       if (live) {
         for (const [k, v] of Object.entries(live)) {
           const resolved = resolveLiveValue(k, v, scope);
-          timeline.call(() => {
-            state[k] = resolved;
-          }, [], at);
+          const live2 = state;
+          revertibleSet(timeline, at, () => live2[k], (v2) => {
+            live2[k] = v2;
+          }, resolved);
         }
       }
     }
@@ -1989,7 +2183,7 @@ function numOrZero(v, scope) {
 var _CompositionSequence = null;
 async function getCompositionSequence() {
   if (!_CompositionSequence) {
-    _CompositionSequence = (await import('./Composition-FEYAUMFI.js')).CompositionSequence;
+    _CompositionSequence = (await import('./Composition-TUCRSMJU.js')).CompositionSequence;
   }
   return _CompositionSequence;
 }
@@ -2026,6 +2220,6 @@ async function buildSequenceTree(specs, parent, root) {
   return out;
 }
 
-export { CameraSequence, DEFAULT_FOV, DEG, Sequence, buildScope, buildSequenceTree, cameraBasis, collectPropKeys, describeLayer, evaluateExpr, homeCamera, homeDistance, lintText, lintTiming, projectLayer, registerSequenceType, resolveAt };
-//# sourceMappingURL=chunk-PN5A6QA7.js.map
-//# sourceMappingURL=chunk-PN5A6QA7.js.map
+export { CameraSequence, DEFAULT_FOV, DEG, NEAR, Sequence, buildScope, buildSequenceTree, cameraBasis, collectPropKeys, describeLayer, evaluateExpr, homeCamera, homeDistance, lintText, lintTiming, projectLayer, registerSequenceType, resolveAt, summarizeWarnings };
+//# sourceMappingURL=chunk-UBPZLGLU.js.map
+//# sourceMappingURL=chunk-UBPZLGLU.js.map