@it-compiles/anima 0.1.0 → 0.1.1

package/dist/video-renderer-Buv1c43x.js

@@ -0,0 +1,3424 @@
+function isExpr(v) {
+  return typeof v === "function";
+}
+function isGroup(obj) {
+  return "isGroup" in obj && obj.isGroup === true;
+}
+const Screen = {
+  width: 1280,
+  height: 720,
+  center: () => [640, 360],
+  centerX: () => 640,
+  centerY: () => 360,
+  topLeft: () => [0, 0],
+  topRight: () => [1280, 0],
+  bottomLeft: () => [0, 720],
+  bottomRight: () => [1280, 720]
+};
+const vec = {
+  add: ([x1, y1], [x2, y2]) => [x1 + x2, y1 + y2],
+  sub: ([x1, y1], [x2, y2]) => [x1 - x2, y1 - y2],
+  lerp: ([x1, y1], [x2, y2], u) => [x1 + (x2 - x1) * u, y1 + (y2 - y1) * u]
+};
+const Vec = (x, y) => [x, y];
+const lerp = (a, b, u) => a + (b - a) * u;
+const angle = (deg) => {
+  return deg * (Math.PI / 180);
+};
+function applySR([x, y], scale, rotate, scaleX = 1, scaleY = 1) {
+  const sx = x * scale * scaleX;
+  const sy = y * scale * scaleY;
+  const c = Math.cos(rotate);
+  const s = Math.sin(rotate);
+  return [
+    sx * c - sy * s,
+    sx * s + sy * c
+  ];
+}
+class BBoxHandleImpl {
+  paddingValues = { top: 0, right: 0, bottom: 0, left: 0 };
+  // Store a function that computes the rect lazily
+  computeRect;
+  constructor(computeRect) {
+    this.computeRect = computeRect;
+  }
+  pad(p) {
+    const parentCompute = this.computeRect;
+    const parentPadding = this.paddingValues;
+    let newPadding;
+    if (typeof p === "number") {
+      newPadding = {
+        top: parentPadding.top + p,
+        right: parentPadding.right + p,
+        bottom: parentPadding.bottom + p,
+        left: parentPadding.left + p
+      };
+    } else {
+      newPadding = {
+        top: parentPadding.top + (p.top ?? 0),
+        right: parentPadding.right + (p.right ?? 0),
+        bottom: parentPadding.bottom + (p.bottom ?? 0),
+        left: parentPadding.left + (p.left ?? 0)
+      };
+    }
+    const result = new BBoxHandleImpl(parentCompute);
+    result.paddingValues = newPadding;
+    return result;
+  }
+  getRect() {
+    const baseRect = this.computeRect();
+    return {
+      x: baseRect.x - this.paddingValues.left,
+      y: baseRect.y - this.paddingValues.top,
+      w: baseRect.w + this.paddingValues.left + this.paddingValues.right,
+      h: baseRect.h + this.paddingValues.top + this.paddingValues.bottom
+    };
+  }
+  size() {
+    return (_ctx) => {
+      const r = this.getRect();
+      return [r.w, r.h];
+    };
+  }
+  width() {
+    return (_ctx) => {
+      return this.getRect().w;
+    };
+  }
+  height() {
+    return (_ctx) => {
+      return this.getRect().h;
+    };
+  }
+  whSize() {
+    return {
+      width: this.width(),
+      height: this.height()
+    };
+  }
+  center() {
+    return (_ctx) => {
+      const r = this.getRect();
+      return [r.x + r.w / 2, r.y + r.h / 2];
+    };
+  }
+  anchor(a) {
+    return (_ctx) => {
+      const r = this.getRect();
+      let x = r.x, y = r.y;
+      if (a === "top" || a === "center" || a === "bottom" || a === "baseline") {
+        x = r.x + r.w / 2;
+      } else if (a === "topRight" || a === "right" || a === "bottomRight") {
+        x = r.x + r.w;
+      }
+      if (a === "left" || a === "center" || a === "right") {
+        y = r.y + r.h / 2;
+      } else if (a === "bottomLeft" || a === "bottom" || a === "bottomRight" || a === "baselineLeft" || a === "baseline") {
+        y = r.y + r.h;
+      }
+      return [x, y];
+    };
+  }
+  toRect() {
+    return (_ctx) => {
+      return this.getRect();
+    };
+  }
+}
+class AnimCtxImpl {
+  base = /* @__PURE__ */ new Map();
+  channels = /* @__PURE__ */ new Map();
+  pins = /* @__PURE__ */ new Map();
+  scene = null;
+  debugGroups = [];
+  /** Resolve a Vec2 expression to a concrete Vec2 */
+  resolveVec2(expr) {
+    if (isExpr(expr)) {
+      const ctx = this.createResolvedCtx();
+      return expr(ctx);
+    }
+    return expr;
+  }
+  /** Resolve a number expression to a concrete number */
+  resolveNum(expr) {
+    if (isExpr(expr)) {
+      const ctx = this.createResolvedCtx();
+      return expr(ctx);
+    }
+    return expr;
+  }
+  /** Create a ResolvedCtx based on current state */
+  createResolvedCtx() {
+    if (!this.scene) throw new Error("Scene not set");
+    return this.solve(this.scene);
+  }
+  reset(scene) {
+    this.base.clear();
+    this.channels.clear();
+    this.pins.clear();
+    this.debugGroups = [];
+    this.scene = scene;
+    for (const obj of scene.objects()) {
+      this.base.set(obj, scene.getInitialTransform(obj));
+    }
+  }
+  getDebugGroups() {
+    return this.debugGroups;
+  }
+  getDebugPins() {
+    return this.pins;
+  }
+  /** Get the current world position of a specific anchor on an object */
+  getCurrentAnchorPosition(obj, anchor) {
+    if (!this.scene) throw new Error("Scene not set");
+    const existingPin = this.pins.get(obj);
+    if (existingPin && existingPin.anchor === anchor) {
+      return existingPin.world;
+    }
+    const base = this.base.get(obj);
+    const ch = this.channels.get(obj);
+    const scale = ch?.scale ?? base.scale;
+    const scaleX = (ch?.scaleX ?? 1) * scale;
+    const scaleY = (ch?.scaleY ?? 1) * scale;
+    const rotate = ch?.rotate ?? base.rotate;
+    let originPos;
+    if (existingPin) {
+      const pinnedLocal = this.scene.resolveAnchor(obj, existingPin.anchor);
+      const cos2 = Math.cos(rotate);
+      const sin2 = Math.sin(rotate);
+      const transformedX2 = pinnedLocal[0] * scaleX * cos2 - pinnedLocal[1] * scaleY * sin2;
+      const transformedY2 = pinnedLocal[0] * scaleX * sin2 + pinnedLocal[1] * scaleY * cos2;
+      originPos = [existingPin.world[0] - transformedX2, existingPin.world[1] - transformedY2];
+    } else {
+      originPos = base.translate;
+    }
+    const local = this.scene.resolveAnchor(obj, anchor);
+    const cos = Math.cos(rotate);
+    const sin = Math.sin(rotate);
+    const transformedX = local[0] * scaleX * cos - local[1] * scaleY * sin;
+    const transformedY = local[0] * scaleX * sin + local[1] * scaleY * cos;
+    return [originPos[0] + transformedX, originPos[1] + transformedY];
+  }
+  getGroupBounds(group) {
+    return this.computeGroupWorldBounds(group);
+  }
+  /** Get the origin position of an object in world space, accounting for any existing pin */
+  getOriginPosition(obj) {
+    if (!this.scene) throw new Error("Scene not set");
+    const pin = this.pins.get(obj);
+    if (!pin) {
+      return this.base.get(obj).translate;
+    }
+    const base = this.base.get(obj);
+    const ch = this.channels.get(obj);
+    const scale = ch?.scale ?? base.scale;
+    const scaleX = (ch?.scaleX ?? 1) * scale;
+    const scaleY = (ch?.scaleY ?? 1) * scale;
+    const rotate = ch?.rotate ?? base.rotate;
+    const localAnchor = this.scene.resolveAnchor(obj, pin.anchor);
+    const cos = Math.cos(rotate);
+    const sin = Math.sin(rotate);
+    const transformedX = localAnchor[0] * scaleX * cos - localAnchor[1] * scaleY * sin;
+    const transformedY = localAnchor[0] * scaleX * sin + localAnchor[1] * scaleY * cos;
+    return [pin.world[0] - transformedX, pin.world[1] - transformedY];
+  }
+  resolveGroupAnchor(group, anchor) {
+    const bounds = this.getGroupBounds(group);
+    const anchorMap = {
+      origin: [bounds.x, bounds.y],
+      // For groups, origin is same as topLeft
+      topLeft: [bounds.x, bounds.y],
+      top: [bounds.x + bounds.w / 2, bounds.y],
+      topRight: [bounds.x + bounds.w, bounds.y],
+      left: [bounds.x, bounds.y + bounds.h / 2],
+      center: [bounds.x + bounds.w / 2, bounds.y + bounds.h / 2],
+      right: [bounds.x + bounds.w, bounds.y + bounds.h / 2],
+      bottomLeft: [bounds.x, bounds.y + bounds.h],
+      bottom: [bounds.x + bounds.w / 2, bounds.y + bounds.h],
+      bottomRight: [bounds.x + bounds.w, bounds.y + bounds.h],
+      baselineLeft: [bounds.x, bounds.y + bounds.h],
+      // baseline defaults to bottom
+      baseline: [bounds.x + bounds.w / 2, bounds.y + bounds.h]
+    };
+    return anchorMap[anchor];
+  }
+  getGroupCenter(group) {
+    const bounds = this.getGroupBounds(group);
+    return [bounds.x + bounds.w / 2, bounds.y + bounds.h / 2];
+  }
+  scale(obj) {
+    if (isGroup(obj)) {
+      return {
+        to: (vExpr, u) => {
+          const v = this.resolveNum(vExpr);
+          const groupCenter = this.getGroupCenter(obj);
+          const scaleFactor = lerp(1, v, u);
+          for (const member of obj.members) {
+            const base = this.base.get(member);
+            const ch = this.channels.get(member) ?? {};
+            const currentScale = ch.scale ?? base.scale;
+            ch.scale = currentScale * scaleFactor;
+            const originPos = this.getOriginPosition(member);
+            const offsetFromCenter = vec.sub(originPos, groupCenter);
+            const scaledOffset = [offsetFromCenter[0] * scaleFactor, offsetFromCenter[1] * scaleFactor];
+            const newOriginPos = vec.add(groupCenter, scaledOffset);
+            this.pins.set(member, {
+              anchor: "origin",
+              world: newOriginPos
+            });
+            this.channels.set(member, ch);
+          }
+        },
+        by: (deltaExpr, u) => {
+          const delta = this.resolveNum(deltaExpr);
+          const groupCenter = this.getGroupCenter(obj);
+          const scaleFactor = lerp(1, 1 + delta, u);
+          for (const member of obj.members) {
+            const base = this.base.get(member);
+            const ch = this.channels.get(member) ?? {};
+            const currentScale = ch.scale ?? base.scale;
+            ch.scale = currentScale * scaleFactor;
+            const originPos = this.getOriginPosition(member);
+            const offsetFromCenter = vec.sub(originPos, groupCenter);
+            const scaledOffset = [offsetFromCenter[0] * scaleFactor, offsetFromCenter[1] * scaleFactor];
+            const newOriginPos = vec.add(groupCenter, scaledOffset);
+            this.pins.set(member, {
+              anchor: "origin",
+              world: newOriginPos
+            });
+            this.channels.set(member, ch);
+          }
+        }
+      };
+    }
+    return {
+      to: (vExpr, u) => {
+        const v = this.resolveNum(vExpr);
+        const ch = this.channels.get(obj) ?? {};
+        const current = ch.scale ?? this.base.get(obj).scale;
+        ch.scale = lerp(current, v, u);
+        this.channels.set(obj, ch);
+      },
+      by: (deltaExpr, u) => {
+        const delta = this.resolveNum(deltaExpr);
+        const ch = this.channels.get(obj) ?? {};
+        const current = ch.scale ?? this.base.get(obj).scale;
+        ch.scale = current * lerp(1, 1 + delta, u);
+        this.channels.set(obj, ch);
+      }
+    };
+  }
+  scaleX(obj) {
+    return {
+      to: (vExpr, u) => {
+        const v = this.resolveNum(vExpr);
+        const ch = this.channels.get(obj) ?? {};
+        const current = ch.scaleX ?? 1;
+        ch.scaleX = lerp(current, v, u);
+        this.channels.set(obj, ch);
+      },
+      by: (deltaExpr, u) => {
+        const delta = this.resolveNum(deltaExpr);
+        const ch = this.channels.get(obj) ?? {};
+        const current = ch.scaleX ?? 1;
+        ch.scaleX = current * lerp(1, 1 + delta, u);
+        this.channels.set(obj, ch);
+      }
+    };
+  }
+  scaleY(obj) {
+    return {
+      to: (vExpr, u) => {
+        const v = this.resolveNum(vExpr);
+        const ch = this.channels.get(obj) ?? {};
+        const current = ch.scaleY ?? 1;
+        ch.scaleY = lerp(current, v, u);
+        this.channels.set(obj, ch);
+      },
+      by: (deltaExpr, u) => {
+        const delta = this.resolveNum(deltaExpr);
+        const ch = this.channels.get(obj) ?? {};
+        const current = ch.scaleY ?? 1;
+        ch.scaleY = current * lerp(1, 1 + delta, u);
+        this.channels.set(obj, ch);
+      }
+    };
+  }
+  width(obj) {
+    if (!this.scene) throw new Error("Scene not set");
+    const bounds = this.scene.getBounds(obj);
+    const originalWidth = bounds.w;
+    return {
+      to: (targetPxExpr, u) => {
+        const targetPx = this.resolveNum(targetPxExpr);
+        const targetScaleX = targetPx / originalWidth;
+        const ch = this.channels.get(obj) ?? {};
+        const current = ch.scaleX ?? 1;
+        ch.scaleX = lerp(current, targetScaleX, u);
+        this.channels.set(obj, ch);
+      },
+      by: (deltaPxExpr, u) => {
+        const deltaPx = this.resolveNum(deltaPxExpr);
+        const ch = this.channels.get(obj) ?? {};
+        const currentScaleX = ch.scaleX ?? 1;
+        const currentWidth = originalWidth * currentScaleX;
+        const targetWidth = currentWidth + deltaPx;
+        const targetScaleX = targetWidth / originalWidth;
+        ch.scaleX = lerp(currentScaleX, targetScaleX, u);
+        this.channels.set(obj, ch);
+      }
+    };
+  }
+  height(obj) {
+    if (!this.scene) throw new Error("Scene not set");
+    const bounds = this.scene.getBounds(obj);
+    const originalHeight = bounds.h;
+    return {
+      to: (targetPxExpr, u) => {
+        const targetPx = this.resolveNum(targetPxExpr);
+        const targetScaleY = targetPx / originalHeight;
+        const ch = this.channels.get(obj) ?? {};
+        const current = ch.scaleY ?? 1;
+        ch.scaleY = lerp(current, targetScaleY, u);
+        this.channels.set(obj, ch);
+      },
+      by: (deltaPxExpr, u) => {
+        const deltaPx = this.resolveNum(deltaPxExpr);
+        const ch = this.channels.get(obj) ?? {};
+        const currentScaleY = ch.scaleY ?? 1;
+        const currentHeight = originalHeight * currentScaleY;
+        const targetHeight = currentHeight + deltaPx;
+        const targetScaleY = targetHeight / originalHeight;
+        ch.scaleY = lerp(currentScaleY, targetScaleY, u);
+        this.channels.set(obj, ch);
+      }
+    };
+  }
+  resize(obj) {
+    if (!this.scene) throw new Error("Scene not set");
+    const bounds = this.scene.getBounds(obj);
+    const originalWidth = bounds.w;
+    const originalHeight = bounds.h;
+    const resolveTarget = (target) => {
+      if (typeof target === "number") return target;
+      if (typeof target === "function") return this.resolveNum(target);
+      if ("fit" in target) return { fit: this.resolveNum(target.fit) };
+      if ("width" in target && "height" in target) {
+        return { width: this.resolveNum(target.width), height: this.resolveNum(target.height) };
+      }
+      if ("width" in target) return { width: this.resolveNum(target.width) };
+      if ("height" in target) return { height: this.resolveNum(target.height) };
+      return target;
+    };
+    const parseTarget = (target) => {
+      if (typeof target === "number") {
+        return { scale: target / originalWidth };
+      }
+      if ("fit" in target) {
+        const scaleW = target.fit / originalWidth;
+        const scaleH = target.fit / originalHeight;
+        return { scale: Math.min(scaleW, scaleH) };
+      }
+      if ("width" in target && "height" in target) {
+        return {
+          scaleX: target.width / originalWidth,
+          scaleY: target.height / originalHeight
+        };
+      }
+      if ("width" in target) {
+        return { scale: target.width / originalWidth };
+      }
+      if ("height" in target) {
+        return { scale: target.height / originalHeight };
+      }
+      return {};
+    };
+    return {
+      to: (targetExpr, u) => {
+        const target = resolveTarget(targetExpr);
+        const { scaleX, scaleY, scale } = parseTarget(target);
+        const ch = this.channels.get(obj) ?? {};
+        if (scale !== void 0) {
+          const currentScale = ch.scale ?? this.base.get(obj).scale;
+          ch.scale = lerp(currentScale, scale, u);
+        } else {
+          if (scaleX !== void 0) {
+            const current = ch.scaleX ?? 1;
+            ch.scaleX = lerp(current, scaleX, u);
+          }
+          if (scaleY !== void 0) {
+            const current = ch.scaleY ?? 1;
+            ch.scaleY = lerp(current, scaleY, u);
+          }
+        }
+        this.channels.set(obj, ch);
+      },
+      by: (deltaExpr, u) => {
+        const delta = resolveTarget(deltaExpr);
+        const ch = this.channels.get(obj) ?? {};
+        if (typeof delta === "number") {
+          const currentScale = ch.scale ?? this.base.get(obj).scale;
+          const currentWidth = originalWidth * currentScale;
+          const targetWidth = currentWidth + delta;
+          const targetScale = targetWidth / originalWidth;
+          ch.scale = lerp(currentScale, targetScale, u);
+        } else if ("fit" in delta) {
+          const currentScale = ch.scale ?? this.base.get(obj).scale;
+          const currentFit = Math.max(originalWidth, originalHeight) * currentScale;
+          const targetFit = currentFit + delta.fit;
+          const scaleW = targetFit / originalWidth;
+          const scaleH = targetFit / originalHeight;
+          const targetScale = Math.min(scaleW, scaleH);
+          ch.scale = lerp(currentScale, targetScale, u);
+        } else if ("width" in delta && "height" in delta) {
+          const currentScaleX = ch.scaleX ?? 1;
+          const currentScaleY = ch.scaleY ?? 1;
+          const currentWidth = originalWidth * currentScaleX;
+          const currentHeight = originalHeight * currentScaleY;
+          const targetScaleX = (currentWidth + delta.width) / originalWidth;
+          const targetScaleY = (currentHeight + delta.height) / originalHeight;
+          ch.scaleX = lerp(currentScaleX, targetScaleX, u);
+          ch.scaleY = lerp(currentScaleY, targetScaleY, u);
+        } else if ("width" in delta) {
+          const currentScale = ch.scale ?? this.base.get(obj).scale;
+          const currentWidth = originalWidth * currentScale;
+          const targetScale = (currentWidth + delta.width) / originalWidth;
+          ch.scale = lerp(currentScale, targetScale, u);
+        } else if ("height" in delta) {
+          const currentScale = ch.scale ?? this.base.get(obj).scale;
+          const currentHeight = originalHeight * currentScale;
+          const targetScale = (currentHeight + delta.height) / originalHeight;
+          ch.scale = lerp(currentScale, targetScale, u);
+        }
+        this.channels.set(obj, ch);
+      }
+    };
+  }
+  fit(obj) {
+    return {
+      to: (bbox, u) => {
+        this.resize(obj).to(bbox.whSize(), u);
+        this.pin(obj, "center").to(bbox.center(), u);
+      },
+      toBBox: (target, u, opts) => {
+        let bbox = this.bbox(target);
+        if (opts?.pad !== void 0) {
+          bbox = bbox.pad(opts.pad);
+        }
+        this.resize(obj).to(bbox.whSize(), u);
+        this.pin(obj, "center").to(bbox.center(), u);
+      }
+    };
+  }
+  computeWorldBounds(obj) {
+    if (!this.scene) throw new Error("Scene not set");
+    const bounds = this.scene.getBounds(obj);
+    const ch = this.channels.get(obj);
+    const base = this.base.get(obj);
+    const pin = this.pins.get(obj);
+    let translate;
+    if (pin) {
+      const local = this.scene.resolveAnchor(obj, pin.anchor);
+      const scale2 = ch?.scale ?? base.scale;
+      const scaleX2 = (ch?.scaleX ?? 1) * scale2;
+      const scaleY2 = (ch?.scaleY ?? 1) * scale2;
+      const rotate = ch?.rotate ?? base.rotate;
+      const cos = Math.cos(rotate);
+      const sin = Math.sin(rotate);
+      const transformedX = local[0] * scaleX2 * cos - local[1] * scaleY2 * sin;
+      const transformedY = local[0] * scaleX2 * sin + local[1] * scaleY2 * cos;
+      translate = [pin.world[0] - transformedX, pin.world[1] - transformedY];
+    } else {
+      translate = base.translate;
+    }
+    const scale = ch?.scale ?? base.scale;
+    const scaleX = (ch?.scaleX ?? 1) * scale;
+    const scaleY = (ch?.scaleY ?? 1) * scale;
+    return {
+      x: translate[0] + bounds.x * scaleX,
+      y: translate[1] + bounds.y * scaleY,
+      w: bounds.w * scaleX,
+      h: bounds.h * scaleY
+    };
+  }
+  computeGroupWorldBounds(group) {
+    let minX = Infinity, minY = Infinity;
+    let maxX = -Infinity, maxY = -Infinity;
+    for (const member of group.members) {
+      const b = this.computeWorldBounds(member);
+      minX = Math.min(minX, b.x);
+      minY = Math.min(minY, b.y);
+      maxX = Math.max(maxX, b.x + b.w);
+      maxY = Math.max(maxY, b.y + b.h);
+    }
+    if (!isFinite(minX)) {
+      return { x: 0, y: 0, w: 0, h: 0 };
+    }
+    return { x: minX, y: minY, w: maxX - minX, h: maxY - minY };
+  }
+  bbox(obj) {
+    if (!this.scene) throw new Error("Scene not set");
+    const computeRect = () => {
+      return isGroup(obj) ? this.computeGroupWorldBounds(obj) : this.computeWorldBounds(obj);
+    };
+    return new BBoxHandleImpl(computeRect);
+  }
+  rotate(obj) {
+    if (isGroup(obj)) {
+      return {
+        to: (radExpr, u) => {
+          const rad = this.resolveNum(radExpr);
+          const groupCenter = this.getGroupCenter(obj);
+          for (const member of obj.members) {
+            const base = this.base.get(member);
+            const ch = this.channels.get(member) ?? {};
+            const currentRot = ch.rotate ?? base.rotate;
+            ch.rotate = lerp(currentRot, rad, u);
+            const originPos = this.getOriginPosition(member);
+            const offsetFromCenter = vec.sub(originPos, groupCenter);
+            const angle2 = lerp(0, rad, u);
+            const cos = Math.cos(angle2);
+            const sin = Math.sin(angle2);
+            const rotatedOffset = [
+              offsetFromCenter[0] * cos - offsetFromCenter[1] * sin,
+              offsetFromCenter[0] * sin + offsetFromCenter[1] * cos
+            ];
+            const newOriginPos = vec.add(groupCenter, rotatedOffset);
+            this.pins.set(member, {
+              anchor: "origin",
+              world: newOriginPos
+            });
+            this.channels.set(member, ch);
+          }
+        },
+        by: (deltaExpr, u) => {
+          const delta = this.resolveNum(deltaExpr);
+          const groupCenter = this.getGroupCenter(obj);
+          for (const member of obj.members) {
+            const base = this.base.get(member);
+            const ch = this.channels.get(member) ?? {};
+            const currentRot = ch.rotate ?? base.rotate;
+            ch.rotate = currentRot + delta * u;
+            const originPos = this.getOriginPosition(member);
+            const offsetFromCenter = vec.sub(originPos, groupCenter);
+            const angle2 = delta * u;
+            const cos = Math.cos(angle2);
+            const sin = Math.sin(angle2);
+            const rotatedOffset = [
+              offsetFromCenter[0] * cos - offsetFromCenter[1] * sin,
+              offsetFromCenter[0] * sin + offsetFromCenter[1] * cos
+            ];
+            const newOriginPos = vec.add(groupCenter, rotatedOffset);
+            this.pins.set(member, {
+              anchor: "origin",
+              world: newOriginPos
+            });
+            this.channels.set(member, ch);
+          }
+        }
+      };
+    }
+    return {
+      to: (radExpr, u) => {
+        const rad = this.resolveNum(radExpr);
+        const ch = this.channels.get(obj) ?? {};
+        const current = ch.rotate ?? this.base.get(obj).rotate;
+        ch.rotate = lerp(current, rad, u);
+        this.channels.set(obj, ch);
+      },
+      by: (deltaExpr, u) => {
+        const delta = this.resolveNum(deltaExpr);
+        const ch = this.channels.get(obj) ?? {};
+        const current = ch.rotate ?? this.base.get(obj).rotate;
+        ch.rotate = current + delta * u;
+        this.channels.set(obj, ch);
+      }
+    };
+  }
+  pin(obj, anchor) {
+    if (isGroup(obj)) {
+      return {
+        to: (posExpr, u) => {
+          const pos = this.resolveVec2(posExpr);
+          const currentAnchor = this.resolveGroupAnchor(obj, anchor);
+          const targetAnchor = vec.lerp(currentAnchor, pos, u);
+          const delta = vec.sub(targetAnchor, currentAnchor);
+          for (const member of obj.members) {
+            const existingPin = this.pins.get(member);
+            const memberAnchor = existingPin?.anchor ?? "origin";
+            const currentAnchorPos = this.getCurrentAnchorPosition(member, memberAnchor);
+            const newPos = vec.add(currentAnchorPos, delta);
+            this.pins.set(member, {
+              anchor: memberAnchor,
+              world: newPos
+            });
+          }
+        },
+        by: (deltaExpr, u) => {
+          const delta = this.resolveVec2(deltaExpr);
+          const interpolatedDelta = vec.lerp([0, 0], delta, u);
+          for (const member of obj.members) {
+            const existingPin = this.pins.get(member);
+            const memberAnchor = existingPin?.anchor ?? "origin";
+            const currentAnchorPos = this.getCurrentAnchorPosition(member, memberAnchor);
+            const newPos = vec.add(currentAnchorPos, interpolatedDelta);
+            this.pins.set(member, {
+              anchor: memberAnchor,
+              world: newPos
+            });
+          }
+        }
+      };
+    }
+    return {
+      to: (posExpr, u) => {
+        const pos = this.resolveVec2(posExpr);
+        const current = this.getCurrentAnchorPosition(obj, anchor);
+        const world = vec.lerp(current, pos, u);
+        this.pins.set(obj, {
+          anchor,
+          world
+        });
+      },
+      by: (deltaExpr, u) => {
+        const delta = this.resolveVec2(deltaExpr);
+        const current = this.getCurrentAnchorPosition(obj, anchor);
+        const world = vec.add(current, vec.lerp([0, 0], delta, u));
+        this.pins.set(obj, {
+          anchor,
+          world
+        });
+      }
+    };
+  }
+  opacity(obj) {
+    if (isGroup(obj)) {
+      return {
+        to: (vExpr, u) => {
+          const v = this.resolveNum(vExpr);
+          for (const member of obj.members) {
+            const ch = this.channels.get(member) ?? {};
+            const current = ch.opacity ?? 1;
+            ch.opacity = lerp(current, v, u);
+            this.channels.set(member, ch);
+          }
+        },
+        by: (deltaExpr, u) => {
+          const delta = this.resolveNum(deltaExpr);
+          for (const member of obj.members) {
+            const ch = this.channels.get(member) ?? {};
+            const current = ch.opacity ?? 1;
+            ch.opacity = current * lerp(1, 1 + delta, u);
+            this.channels.set(member, ch);
+          }
+        }
+      };
+    }
+    return {
+      to: (vExpr, u) => {
+        const v = this.resolveNum(vExpr);
+        const ch = this.channels.get(obj) ?? {};
+        const current = ch.opacity ?? 1;
+        ch.opacity = lerp(current, v, u);
+        this.channels.set(obj, ch);
+      },
+      by: (deltaExpr, u) => {
+        const delta = this.resolveNum(deltaExpr);
+        const ch = this.channels.get(obj) ?? {};
+        const current = ch.opacity ?? 1;
+        ch.opacity = current * lerp(1, 1 + delta, u);
+        this.channels.set(obj, ch);
+      }
+    };
+  }
+  group(...objects) {
+    const groupObj = {
+      id: /* @__PURE__ */ Symbol("group"),
+      members: objects,
+      isGroup: true
+    };
+    const self = this;
+    const builder = {
+      ...groupObj,
+      pin: (anchor) => {
+        const methods = self.pin(groupObj, anchor);
+        return {
+          to: (pos, u) => {
+            methods.to(pos, u);
+            self.trackGroupDebug(groupObj, u, { anchor, target: pos });
+          },
+          by: (delta, u) => {
+            methods.by(delta, u);
+            self.trackGroupDebug(groupObj, u);
+          }
+        };
+      },
+      scale: () => {
+        const methods = self.scale(groupObj);
+        return {
+          to: (v, u) => {
+            methods.to(v, u);
+            self.trackGroupDebug(groupObj, u);
+          },
+          by: (delta, u) => {
+            methods.by(delta, u);
+            self.trackGroupDebug(groupObj, u);
+          }
+        };
+      },
+      rotate: () => {
+        const methods = self.rotate(groupObj);
+        return {
+          to: (v, u) => {
+            methods.to(v, u);
+            self.trackGroupDebug(groupObj, u);
+          },
+          by: (delta, u) => {
+            methods.by(delta, u);
+            self.trackGroupDebug(groupObj, u);
+          }
+        };
+      },
+      opacity: () => {
+        const methods = self.opacity(groupObj);
+        return {
+          to: (v, u) => {
+            methods.to(v, u);
+            self.trackGroupDebug(groupObj, u);
+          },
+          by: (delta, u) => {
+            methods.by(delta, u);
+            self.trackGroupDebug(groupObj, u);
+          }
+        };
+      }
+    };
+    return builder;
+  }
+  trackGroupDebug(groupObj, u, pin) {
+    if (u < 1) {
+      let entry = this.debugGroups.find(
+        (g) => g.kind === "group" && g.members === groupObj.members
+      );
+      if (!entry) {
+        entry = {
+          members: groupObj.members,
+          kind: "group"
+        };
+        this.debugGroups.push(entry);
+      }
+      if (pin) {
+        entry.pin = pin;
+      }
+      return entry;
+    }
+    return null;
+  }
+  /** Flatten objects for final result (extracts all SceneObjects from groups) */
+  flattenToSceneObjects(objects) {
+    const result = [];
+    for (const obj of objects) {
+      if (isGroup(obj)) {
+        result.push(...obj.members);
+      } else {
+        result.push(obj);
+      }
+    }
+    return result;
+  }
+  /** Get bounds for an ObjRef (single object or group) */
+  getObjRefBounds(obj) {
+    if (isGroup(obj)) {
+      return this.computeGroupWorldBounds(obj);
+    }
+    return this.computeWorldBounds(obj);
+  }
+  /** Get the top-left position of an ObjRef (bounds position, not pin position) */
+  getObjRefPosition(obj) {
+    const bounds = this.getObjRefBounds(obj);
+    return [bounds.x, bounds.y];
+  }
+  /** Move an ObjRef by a delta (moves all members of a group together, preserving pin anchors) */
+  moveObjRef(obj, fromPos, toPos, u) {
+    const delta = vec.sub(toPos, fromPos);
+    const interpolatedDelta = vec.lerp([0, 0], delta, u);
+    if (isGroup(obj)) {
+      for (const member of obj.members) {
+        const existingPin = this.pins.get(member);
+        const anchor = existingPin?.anchor ?? "origin";
+        const currentAnchorPos = this.getCurrentAnchorPosition(member, anchor);
+        const newPos = vec.add(currentAnchorPos, interpolatedDelta);
+        this.pins.set(member, {
+          anchor,
+          world: newPos
+        });
+      }
+    } else {
+      const existingPin = this.pins.get(obj);
+      const anchor = existingPin?.anchor ?? "origin";
+      const currentAnchorPos = this.getCurrentAnchorPosition(obj, anchor);
+      const newPos = vec.add(currentAnchorPos, interpolatedDelta);
+      this.pins.set(obj, {
+        anchor,
+        world: newPos
+      });
+    }
+  }
+  alignOnCrossAxis(start, size, maxSize, align) {
+    if (align === "center") {
+      return start + (maxSize - size) / 2;
+    }
+    if (align === "topLeft" || align === "left" || align === "top") {
+      return start;
+    }
+    if (align === "bottomRight" || align === "right" || align === "bottom") {
+      return start + maxSize - size;
+    }
+    if (align === "baselineLeft" || align === "baseline") {
+      return start + maxSize - size;
+    }
+    return start;
+  }
+  calculateLayoutPositions(objects, axis, align, gap) {
+    if (!this.scene) throw new Error("Scene not set");
+    const boundsList = objects.map((obj) => this.getObjRefBounds(obj));
+    const startX = Math.min(...boundsList.map((b) => b.x));
+    const startY = Math.min(...boundsList.map((b) => b.y));
+    const maxH = Math.max(...boundsList.map((b) => b.h));
+    const maxW = Math.max(...boundsList.map((b) => b.w));
+    const targets = [];
+    let cursor = axis === "x" ? startX : startY;
+    for (let i = 0; i < objects.length; i++) {
+      const b = boundsList[i];
+      let x, y;
+      if (axis === "x") {
+        x = cursor;
+        y = this.alignOnCrossAxis(startY, b.h, maxH, align);
+        cursor += b.w + gap;
+      } else {
+        x = this.alignOnCrossAxis(startX, b.w, maxW, align);
+        y = cursor;
+        cursor += b.h + gap;
+      }
+      targets.push([x, y]);
+    }
+    return targets;
+  }
+  layout(...args) {
+    let opts = {};
+    let objects;
+    const last2 = args[args.length - 1];
+    if (last2 && typeof last2 === "object" && !("id" in last2)) {
+      opts = last2;
+      objects = args.slice(0, -1);
+    } else {
+      objects = args;
+    }
+    const axis = opts.axis ?? "x";
+    const align = opts.align ?? "center";
+    const gap = opts.gap ?? 0;
+    return {
+      to: (u) => {
+        const targets = this.calculateLayoutPositions(objects, axis, align, gap);
+        for (let i = 0; i < objects.length; i++) {
+          const obj = objects[i];
+          const currentPos = this.getObjRefPosition(obj);
+          const targetPos = targets[i];
+          this.moveObjRef(obj, currentPos, targetPos, u);
+        }
+        const allMembers = this.flattenToSceneObjects(objects);
+        const groupObj = {
+          id: /* @__PURE__ */ Symbol("layout-group"),
+          members: allMembers,
+          isGroup: true
+        };
+        let debugEntry = null;
+        if (u < 1) {
+          debugEntry = {
+            members: allMembers,
+            kind: "layout"
+          };
+          this.debugGroups.push(debugEntry);
+        }
+        const self = this;
+        const builder = {
+          ...groupObj,
+          pin: (anchor) => {
+            const methods = self.pin(groupObj, anchor);
+            return {
+              to: (pos, pinU) => {
+                methods.to(pos, pinU);
+                if (debugEntry) {
+                  debugEntry.pin = { anchor, target: pos };
+                }
+              },
+              by: (delta, pinU) => {
+                methods.by(delta, pinU);
+              }
+            };
+          },
+          scale: () => self.scale(groupObj),
+          rotate: () => self.rotate(groupObj),
+          opacity: () => self.opacity(groupObj)
+        };
+        return builder;
+      }
+    };
+  }
+  inline(...args) {
+    const { objects, gap } = this.parseLayoutArgs(args);
+    return this.layout(...objects, { axis: "x", align: "baselineLeft", gap });
+  }
+  stack(...args) {
+    const { objects, gap } = this.parseLayoutArgs(args);
+    return this.layout(...objects, { axis: "y", align: "center", gap });
+  }
+  paragraph(...args) {
+    const { objects, gap } = this.parseLayoutArgs(args);
+    return this.layout(...objects, { axis: "y", align: "left", gap });
+  }
+  /** Parse layout args - last arg may be a gap number */
+  parseLayoutArgs(args) {
+    const last2 = args[args.length - 1];
+    if (typeof last2 === "number") {
+      return { objects: args.slice(0, -1), gap: last2 };
+    }
+    return { objects: args, gap: 0 };
+  }
+  /** Get anchor offset within bounds */
+  getAnchorOffsetFromRect(bounds, anchor) {
+    let ox = 0, oy = 0;
+    if (anchor === "top" || anchor === "center" || anchor === "bottom" || anchor === "baseline") {
+      ox = bounds.w / 2;
+    } else if (anchor === "topRight" || anchor === "right" || anchor === "bottomRight") {
+      ox = bounds.w;
+    }
+    if (anchor === "left" || anchor === "center" || anchor === "right") {
+      oy = bounds.h / 2;
+    } else if (anchor === "bottomLeft" || anchor === "bottom" || anchor === "bottomRight" || anchor === "baselineLeft" || anchor === "baseline") {
+      oy = bounds.h;
+    }
+    return [ox, oy];
+  }
+  /** Get anchor position in world space for an ObjRef */
+  getObjRefAnchorPosition(obj, anchor) {
+    const bounds = this.getObjRefBounds(obj);
+    const offset = this.getAnchorOffsetFromRect(bounds, anchor);
+    return [bounds.x + offset[0], bounds.y + offset[1]];
+  }
+  align(...args) {
+    let opts = {};
+    let objects;
+    const last2 = args[args.length - 1];
+    if (last2 && typeof last2 === "object" && !("id" in last2)) {
+      opts = last2;
+      objects = args.slice(0, -1);
+    } else {
+      objects = args;
+    }
+    const anchor = opts.anchor ?? "center";
+    return {
+      to: (u) => {
+        if (!this.scene || objects.length === 0) {
+          const allMembers2 = this.flattenToSceneObjects(objects);
+          return this.group(...allMembers2);
+        }
+        const targetAnchorPos = this.getObjRefAnchorPosition(objects[0], anchor);
+        for (let i = 1; i < objects.length; i++) {
+          const obj = objects[i];
+          const bounds = this.getObjRefBounds(obj);
+          const anchorOffset = this.getAnchorOffsetFromRect(bounds, anchor);
+          const targetPos = [
+            targetAnchorPos[0] - anchorOffset[0],
+            targetAnchorPos[1] - anchorOffset[1]
+          ];
+          const currentPos = this.getObjRefPosition(obj);
+          this.moveObjRef(obj, currentPos, targetPos, u);
+        }
+        const allMembers = this.flattenToSceneObjects(objects);
+        const groupObj = {
+          id: /* @__PURE__ */ Symbol("align-group"),
+          members: allMembers,
+          isGroup: true
+        };
+        let debugEntry = null;
+        if (u < 1) {
+          debugEntry = {
+            members: allMembers,
+            kind: "layout"
+          };
+          this.debugGroups.push(debugEntry);
+        }
+        const self = this;
+        return {
+          ...groupObj,
+          pin: (pinAnchor) => {
+            const methods = self.pin(groupObj, pinAnchor);
+            return {
+              to: (pos, pinU) => {
+                methods.to(pos, pinU);
+                if (debugEntry) {
+                  debugEntry.pin = { anchor: pinAnchor, target: pos };
+                }
+              },
+              by: (delta, pinU) => {
+                methods.by(delta, pinU);
+              }
+            };
+          },
+          scale: () => self.scale(groupObj),
+          rotate: () => self.rotate(groupObj),
+          opacity: () => self.opacity(groupObj)
+        };
+      }
+    };
+  }
+  center(...objects) {
+    return this.align(...objects, { anchor: "center" });
+  }
+  solve(scene) {
+    const resolved = /* @__PURE__ */ new Map();
+    const opacity = /* @__PURE__ */ new Map();
+    for (const obj of scene.objects()) {
+      const base = scene.getInitialTransform(obj);
+      const ch = this.channels.get(obj);
+      const scale = ch?.scale ?? base.scale;
+      const scaleX = ch?.scaleX;
+      const scaleY = ch?.scaleY;
+      const rotate = ch?.rotate ?? base.rotate;
+      let translate = base.translate ?? [0, 0];
+      const pin = this.pins.get(obj);
+      if (pin) {
+        const local = scene.resolveAnchor(obj, pin.anchor);
+        const transformed = applySR(local, scale, rotate, scaleX ?? 1, scaleY ?? 1);
+        translate = vec.sub(pin.world, transformed);
+      }
+      resolved.set(obj, {
+        translate,
+        rotate: rotate ?? 0,
+        scale: scale ?? 1,
+        scaleX,
+        scaleY
+      });
+      opacity.set(obj, ch?.opacity ?? 1);
+    }
+    return {
+      getTransform: (o) => resolved.get(o),
+      getOpacity: (o) => opacity.get(o) ?? 1
+    };
+  }
+}
+function getAnchorOffset(anchor, bounds) {
+  const { x, y, w, h } = bounds;
+  const left = x;
+  const right = x + w;
+  const top = y;
+  const bottom = y + h;
+  const centerX = x + w / 2;
+  const centerY = y + h / 2;
+  switch (anchor) {
+    case "origin":
+      return [0, 0];
+    case "topLeft":
+      return [left, top];
+    case "top":
+      return [centerX, top];
+    case "topRight":
+      return [right, top];
+    case "left":
+      return [left, centerY];
+    case "center":
+      return [centerX, centerY];
+    case "right":
+      return [right, centerY];
+    case "bottomLeft":
+      return [left, bottom];
+    case "bottom":
+      return [centerX, bottom];
+    case "bottomRight":
+      return [right, bottom];
+    case "baselineLeft":
+      return [left, bottom];
+    case "baseline":
+      return [centerX, bottom];
+    default:
+      return [0, 0];
+  }
+}
+function renderDebugOverlay(g, scene, solved, debugGroups, pins, dpr) {
+  g.save();
+  g.scale(dpr, dpr);
+  const debugInfos = [];
+  for (const obj of scene.objects()) {
+    const transform = solved.getTransform(obj);
+    if (!transform || !transform.translate) continue;
+    const bounds = scene.getBounds(obj);
+    const opacity = solved.getOpacity(obj);
+    debugInfos.push({ obj, transform, bounds, opacity });
+  }
+  for (const groupInfo of debugGroups) {
+    const { members, kind, pin } = groupInfo;
+    let minX = Infinity, minY = Infinity;
+    let maxX = -Infinity, maxY = -Infinity;
+    for (const member of members) {
+      const transform = solved.getTransform(member);
+      if (!transform || !transform.translate) continue;
+      const memberBounds = scene.getBounds(member);
+      const x = transform.translate[0] + memberBounds.x;
+      const y = transform.translate[1] + memberBounds.y;
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x + memberBounds.w * transform.scale);
+      maxY = Math.max(maxY, y + memberBounds.h * transform.scale);
+    }
+    if (!isFinite(minX)) continue;
+    const bounds = { x: minX, y: minY, w: maxX - minX, h: maxY - minY };
+    const color = kind === "group" ? "rgba(255, 200, 0" : "rgba(255, 0, 255";
+    g.strokeStyle = color + ", 0.7)";
+    g.lineWidth = 2;
+    g.setLineDash([6, 4]);
+    g.strokeRect(bounds.x, bounds.y, bounds.w, bounds.h);
+    g.font = "10px monospace";
+    g.fillStyle = color + ", 0.9)";
+    g.fillText(kind, bounds.x + 2, bounds.y - 3);
+    if (pin) {
+      let anchorX = bounds.x, anchorY = bounds.y;
+      const anchor = pin.anchor;
+      if (anchor === "top" || anchor === "center" || anchor === "bottom" || anchor === "baseline") {
+        anchorX = bounds.x + bounds.w / 2;
+      } else if (anchor === "topRight" || anchor === "right" || anchor === "bottomRight") {
+        anchorX = bounds.x + bounds.w;
+      }
+      if (anchor === "left" || anchor === "center" || anchor === "right") {
+        anchorY = bounds.y + bounds.h / 2;
+      } else if (anchor === "bottomLeft" || anchor === "bottom" || anchor === "bottomRight" || anchor === "baselineLeft" || anchor === "baseline") {
+        anchorY = bounds.y + bounds.h;
+      }
+      g.fillStyle = color + ", 0.9)";
+      g.beginPath();
+      g.moveTo(anchorX, anchorY - 5);
+      g.lineTo(anchorX + 5, anchorY);
+      g.lineTo(anchorX, anchorY + 5);
+      g.lineTo(anchorX - 5, anchorY);
+      g.closePath();
+      g.fill();
+      const [tx, ty] = pin.target;
+      g.strokeStyle = color + ", 0.9)";
+      g.lineWidth = 2;
+      g.setLineDash([]);
+      g.beginPath();
+      g.moveTo(tx - 6, ty - 6);
+      g.lineTo(tx + 6, ty + 6);
+      g.moveTo(tx + 6, ty - 6);
+      g.lineTo(tx - 6, ty + 6);
+      g.stroke();
+      g.strokeStyle = color + ", 0.4)";
+      g.lineWidth = 1;
+      g.setLineDash([3, 3]);
+      g.beginPath();
+      g.moveTo(anchorX, anchorY);
+      g.lineTo(tx, ty);
+      g.stroke();
+      g.font = "9px monospace";
+      g.fillStyle = color + ", 0.9)";
+      g.fillText(anchor, anchorX + 7, anchorY - 2);
+    }
+  }
+  for (const { transform, bounds } of debugInfos) {
+    g.save();
+    g.translate(transform.translate[0], transform.translate[1]);
+    g.rotate(transform.rotate);
+    const sx = (transform.scaleX ?? 1) * transform.scale;
+    const sy = (transform.scaleY ?? 1) * transform.scale;
+    g.scale(sx, sy);
+    const avgScale = (sx + sy) / 2;
+    g.strokeStyle = "rgba(0, 200, 255, 0.8)";
+    g.lineWidth = 1 / avgScale;
+    g.setLineDash([4 / avgScale, 4 / avgScale]);
+    g.strokeRect(bounds.x, bounds.y, bounds.w, bounds.h);
+    g.restore();
+  }
+  for (const { obj, transform, bounds } of debugInfos) {
+    const x = transform.translate[0];
+    const y = transform.translate[1];
+    const sx = (transform.scaleX ?? 1) * transform.scale;
+    const sy = (transform.scaleY ?? 1) * transform.scale;
+    const cos = Math.cos(transform.rotate);
+    const sin = Math.sin(transform.rotate);
+    g.fillStyle = "rgba(255, 100, 100, 0.9)";
+    g.beginPath();
+    g.arc(x, y, 4, 0, Math.PI * 2);
+    g.fill();
+    const centerOffX = (bounds.x + bounds.w / 2) * sx;
+    const centerOffY = (bounds.y + bounds.h / 2) * sy;
+    const centerX = x + centerOffX * cos - centerOffY * sin;
+    const centerY = y + centerOffX * sin + centerOffY * cos;
+    g.fillStyle = "rgba(100, 255, 100, 0.9)";
+    g.beginPath();
+    g.arc(centerX, centerY, 3, 0, Math.PI * 2);
+    g.fill();
+    g.strokeStyle = "rgba(255, 100, 100, 0.6)";
+    g.lineWidth = 1;
+    g.setLineDash([]);
+    g.beginPath();
+    g.moveTo(x - 8, y);
+    g.lineTo(x + 8, y);
+    g.moveTo(x, y - 8);
+    g.lineTo(x, y + 8);
+    g.stroke();
+    const baseline = scene.getBaseline(obj);
+    if (baseline !== null) {
+      g.save();
+      g.translate(x, y);
+      g.rotate(transform.rotate);
+      g.scale(transform.scale, transform.scale);
+      g.strokeStyle = "rgba(255, 165, 0, 0.8)";
+      g.lineWidth = 1 / transform.scale;
+      g.setLineDash([2 / transform.scale, 2 / transform.scale]);
+      g.beginPath();
+      g.moveTo(bounds.x - 5, baseline);
+      g.lineTo(bounds.x + bounds.w + 5, baseline);
+      g.stroke();
+      g.restore();
+    }
+    const pin = pins.get(obj);
+    if (pin) {
+      const [anchorOffX, anchorOffY] = getAnchorOffset(pin.anchor, bounds);
+      const scaledOffX = anchorOffX * sx;
+      const scaledOffY = anchorOffY * sy;
+      const anchorX = x + scaledOffX * cos - scaledOffY * sin;
+      const anchorY = y + scaledOffX * sin + scaledOffY * cos;
+      const [tx, ty] = pin.world;
+      g.fillStyle = "rgba(0, 200, 255, 0.9)";
+      g.beginPath();
+      g.moveTo(anchorX, anchorY - 4);
+      g.lineTo(anchorX + 4, anchorY);
+      g.lineTo(anchorX, anchorY + 4);
+      g.lineTo(anchorX - 4, anchorY);
+      g.closePath();
+      g.fill();
+      g.strokeStyle = "rgba(0, 200, 255, 0.9)";
+      g.lineWidth = 2;
+      g.setLineDash([]);
+      g.beginPath();
+      g.moveTo(tx - 5, ty - 5);
+      g.lineTo(tx + 5, ty + 5);
+      g.moveTo(tx + 5, ty - 5);
+      g.lineTo(tx - 5, ty + 5);
+      g.stroke();
+      g.strokeStyle = "rgba(0, 200, 255, 0.4)";
+      g.lineWidth = 1;
+      g.setLineDash([3, 3]);
+      g.beginPath();
+      g.moveTo(anchorX, anchorY);
+      g.lineTo(tx, ty);
+      g.stroke();
+      g.font = "9px monospace";
+      g.fillStyle = "rgba(0, 200, 255, 0.9)";
+      g.fillText(pin.anchor, anchorX + 6, anchorY - 4);
+    }
+  }
+  g.restore();
+}
+function makePlayer(canvas, opts) {
+  const ctx = new AnimCtxImpl();
+  const { scene, timeline } = opts;
+  const duration = timeline.duration;
+  let isPlaying = false;
+  let currentTime = 0;
+  let startTime = 0;
+  let animationFrameId = null;
+  let onTimeUpdate = null;
+  let onError = null;
+  let hasError = false;
+  let debugMode = false;
+  function render(timeMs, throwOnError = false) {
+    try {
+      ctx.reset(scene);
+      timeline.evaluate(timeMs, ctx);
+      const solved = ctx.solve(scene);
+      scene.render(solved, canvas);
+      if (debugMode) {
+        const g = canvas.getContext("2d");
+        const dpr = window.devicePixelRatio || 1;
+        renderDebugOverlay(g, scene, solved, ctx.getDebugGroups(), ctx.getDebugPins(), dpr);
+      }
+      return true;
+    } catch (e) {
+      hasError = true;
+      isPlaying = false;
+      if (animationFrameId !== null) {
+        cancelAnimationFrame(animationFrameId);
+        animationFrameId = null;
+      }
+      const error = e instanceof Error ? e : new Error(String(e));
+      if (throwOnError || !onError) {
+        throw error;
+      }
+      onError(error);
+      return false;
+    }
+  }
+  function frame(now) {
+    if (!isPlaying || hasError) return;
+    currentTime = now - startTime;
+    if (currentTime >= duration) {
+      currentTime = duration;
+      isPlaying = false;
+      render(currentTime);
+      onTimeUpdate?.(currentTime);
+      return;
+    }
+    if (render(currentTime)) {
+      onTimeUpdate?.(currentTime);
+      animationFrameId = requestAnimationFrame(frame);
+    }
+  }
+  render(0, true);
+  return {
+    get isPlaying() {
+      return isPlaying;
+    },
+    get currentTime() {
+      return currentTime;
+    },
+    get duration() {
+      return duration;
+    },
+    get onTimeUpdate() {
+      return onTimeUpdate;
+    },
+    set onTimeUpdate(callback) {
+      onTimeUpdate = callback;
+    },
+    get onError() {
+      return onError;
+    },
+    set onError(callback) {
+      onError = callback;
+    },
+    get debug() {
+      return debugMode;
+    },
+    set debug(value) {
+      debugMode = value;
+      if (!isPlaying) {
+        render(currentTime);
+      }
+    },
+    play() {
+      if (isPlaying || hasError) return;
+      if (currentTime >= duration) {
+        currentTime = 0;
+      }
+      isPlaying = true;
+      startTime = performance.now() - currentTime;
+      animationFrameId = requestAnimationFrame(frame);
+    },
+    pause() {
+      isPlaying = false;
+      if (animationFrameId !== null) {
+        cancelAnimationFrame(animationFrameId);
+        animationFrameId = null;
+      }
+    },
+    stop() {
+      this.pause();
+      currentTime = 0;
+      render(0);
+      onTimeUpdate?.(0);
+    },
+    seek(timeMs) {
+      if (hasError) return;
+      currentTime = Math.max(0, Math.min(duration, timeMs));
+      startTime = performance.now() - currentTime;
+      render(currentTime);
+      onTimeUpdate?.(currentTime);
+    },
+    renderAt(timeMs) {
+      if (hasError) return;
+      render(Math.max(0, Math.min(duration, timeMs)));
+    },
+    dispose() {
+      this.pause();
+    }
+  };
+}
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  member.set(obj, value);
+  return value;
+};
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var bytes = new Uint8Array(8);
+var view = new DataView(bytes.buffer);
+var u8 = (value) => {
+  return [(value % 256 + 256) % 256];
+};
+var u16 = (value) => {
+  view.setUint16(0, value, false);
+  return [bytes[0], bytes[1]];
+};
+var i16 = (value) => {
+  view.setInt16(0, value, false);
+  return [bytes[0], bytes[1]];
+};
+var u24 = (value) => {
+  view.setUint32(0, value, false);
+  return [bytes[1], bytes[2], bytes[3]];
+};
+var u32 = (value) => {
+  view.setUint32(0, value, false);
+  return [bytes[0], bytes[1], bytes[2], bytes[3]];
+};
+var i32 = (value) => {
+  view.setInt32(0, value, false);
+  return [bytes[0], bytes[1], bytes[2], bytes[3]];
+};
+var u64 = (value) => {
+  view.setUint32(0, Math.floor(value / 2 ** 32), false);
+  view.setUint32(4, value, false);
+  return [bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7]];
+};
+var fixed_8_8 = (value) => {
+  view.setInt16(0, 2 ** 8 * value, false);
+  return [bytes[0], bytes[1]];
+};
+var fixed_16_16 = (value) => {
+  view.setInt32(0, 2 ** 16 * value, false);
+  return [bytes[0], bytes[1], bytes[2], bytes[3]];
+};
+var fixed_2_30 = (value) => {
+  view.setInt32(0, 2 ** 30 * value, false);
+  return [bytes[0], bytes[1], bytes[2], bytes[3]];
+};
+var ascii = (text, nullTerminated = false) => {
+  let bytes2 = Array(text.length).fill(null).map((_, i) => text.charCodeAt(i));
+  if (nullTerminated)
+    bytes2.push(0);
+  return bytes2;
+};
+var last = (arr) => {
+  return arr && arr[arr.length - 1];
+};
+var lastPresentedSample = (samples) => {
+  let result = void 0;
+  for (let sample of samples) {
+    if (!result || sample.presentationTimestamp > result.presentationTimestamp) {
+      result = sample;
+    }
+  }
+  return result;
+};
+var intoTimescale = (timeInSeconds, timescale, round = true) => {
+  let value = timeInSeconds * timescale;
+  return round ? Math.round(value) : value;
+};
+var rotationMatrix = (rotationInDegrees) => {
+  let theta = rotationInDegrees * (Math.PI / 180);
+  let cosTheta = Math.cos(theta);
+  let sinTheta = Math.sin(theta);
+  return [
+    cosTheta,
+    sinTheta,
+    0,
+    -sinTheta,
+    cosTheta,
+    0,
+    0,
+    0,
+    1
+  ];
+};
+var IDENTITY_MATRIX = rotationMatrix(0);
+var matrixToBytes = (matrix) => {
+  return [
+    fixed_16_16(matrix[0]),
+    fixed_16_16(matrix[1]),
+    fixed_2_30(matrix[2]),
+    fixed_16_16(matrix[3]),
+    fixed_16_16(matrix[4]),
+    fixed_2_30(matrix[5]),
+    fixed_16_16(matrix[6]),
+    fixed_16_16(matrix[7]),
+    fixed_2_30(matrix[8])
+  ];
+};
+var deepClone = (x) => {
+  if (!x)
+    return x;
+  if (typeof x !== "object")
+    return x;
+  if (Array.isArray(x))
+    return x.map(deepClone);
+  return Object.fromEntries(Object.entries(x).map(([key, value]) => [key, deepClone(value)]));
+};
+var isU32 = (value) => {
+  return value >= 0 && value < 2 ** 32;
+};
+var box = (type, contents, children) => ({
+  type,
+  contents: contents && new Uint8Array(contents.flat(10)),
+  children
+});
+var fullBox = (type, version, flags, contents, children) => box(
+  type,
+  [u8(version), u24(flags), contents ?? []],
+  children
+);
+var ftyp = (details) => {
+  let minorVersion = 512;
+  if (details.fragmented)
+    return box("ftyp", [
+      ascii("iso5"),
+      // Major brand
+      u32(minorVersion),
+      // Minor version
+      // Compatible brands
+      ascii("iso5"),
+      ascii("iso6"),
+      ascii("mp41")
+    ]);
+  return box("ftyp", [
+    ascii("isom"),
+    // Major brand
+    u32(minorVersion),
+    // Minor version
+    // Compatible brands
+    ascii("isom"),
+    details.holdsAvc ? ascii("avc1") : [],
+    ascii("mp41")
+  ]);
+};
+var mdat = (reserveLargeSize) => ({ type: "mdat", largeSize: reserveLargeSize });
+var free = (size) => ({ type: "free", size });
+var moov = (tracks, creationTime, fragmented = false) => box("moov", null, [
+  mvhd(creationTime, tracks),
+  ...tracks.map((x) => trak(x, creationTime)),
+  fragmented ? mvex(tracks) : null
+]);
+var mvhd = (creationTime, tracks) => {
+  let duration = intoTimescale(Math.max(
+    0,
+    ...tracks.filter((x) => x.samples.length > 0).map((x) => {
+      const lastSample = lastPresentedSample(x.samples);
+      return lastSample.presentationTimestamp + lastSample.duration;
+    })
+  ), GLOBAL_TIMESCALE);
+  let nextTrackId = Math.max(...tracks.map((x) => x.id)) + 1;
+  let needsU64 = !isU32(creationTime) || !isU32(duration);
+  let u32OrU64 = needsU64 ? u64 : u32;
+  return fullBox("mvhd", +needsU64, 0, [
+    u32OrU64(creationTime),
+    // Creation time
+    u32OrU64(creationTime),
+    // Modification time
+    u32(GLOBAL_TIMESCALE),
+    // Timescale
+    u32OrU64(duration),
+    // Duration
+    fixed_16_16(1),
+    // Preferred rate
+    fixed_8_8(1),
+    // Preferred volume
+    Array(10).fill(0),
+    // Reserved
+    matrixToBytes(IDENTITY_MATRIX),
+    // Matrix
+    Array(24).fill(0),
+    // Pre-defined
+    u32(nextTrackId)
+    // Next track ID
+  ]);
+};
+var trak = (track, creationTime) => box("trak", null, [
+  tkhd(track, creationTime),
+  mdia(track, creationTime)
+]);
+var tkhd = (track, creationTime) => {
+  let lastSample = lastPresentedSample(track.samples);
+  let durationInGlobalTimescale = intoTimescale(
+    lastSample ? lastSample.presentationTimestamp + lastSample.duration : 0,
+    GLOBAL_TIMESCALE
+  );
+  let needsU64 = !isU32(creationTime) || !isU32(durationInGlobalTimescale);
+  let u32OrU64 = needsU64 ? u64 : u32;
+  let matrix;
+  if (track.info.type === "video") {
+    matrix = typeof track.info.rotation === "number" ? rotationMatrix(track.info.rotation) : track.info.rotation;
+  } else {
+    matrix = IDENTITY_MATRIX;
+  }
+  return fullBox("tkhd", +needsU64, 3, [
+    u32OrU64(creationTime),
+    // Creation time
+    u32OrU64(creationTime),
+    // Modification time
+    u32(track.id),
+    // Track ID
+    u32(0),
+    // Reserved
+    u32OrU64(durationInGlobalTimescale),
+    // Duration
+    Array(8).fill(0),
+    // Reserved
+    u16(0),
+    // Layer
+    u16(0),
+    // Alternate group
+    fixed_8_8(track.info.type === "audio" ? 1 : 0),
+    // Volume
+    u16(0),
+    // Reserved
+    matrixToBytes(matrix),
+    // Matrix
+    fixed_16_16(track.info.type === "video" ? track.info.width : 0),
+    // Track width
+    fixed_16_16(track.info.type === "video" ? track.info.height : 0)
+    // Track height
+  ]);
+};
+var mdia = (track, creationTime) => box("mdia", null, [
+  mdhd(track, creationTime),
+  hdlr(track.info.type === "video" ? "vide" : "soun"),
+  minf(track)
+]);
+var mdhd = (track, creationTime) => {
+  let lastSample = lastPresentedSample(track.samples);
+  let localDuration = intoTimescale(
+    lastSample ? lastSample.presentationTimestamp + lastSample.duration : 0,
+    track.timescale
+  );
+  let needsU64 = !isU32(creationTime) || !isU32(localDuration);
+  let u32OrU64 = needsU64 ? u64 : u32;
+  return fullBox("mdhd", +needsU64, 0, [
+    u32OrU64(creationTime),
+    // Creation time
+    u32OrU64(creationTime),
+    // Modification time
+    u32(track.timescale),
+    // Timescale
+    u32OrU64(localDuration),
+    // Duration
+    u16(21956),
+    // Language ("und", undetermined)
+    u16(0)
+    // Quality
+  ]);
+};
+var hdlr = (componentSubtype) => fullBox("hdlr", 0, 0, [
+  ascii("mhlr"),
+  // Component type
+  ascii(componentSubtype),
+  // Component subtype
+  u32(0),
+  // Component manufacturer
+  u32(0),
+  // Component flags
+  u32(0),
+  // Component flags mask
+  ascii("mp4-muxer-hdlr", true)
+  // Component name
+]);
+var minf = (track) => box("minf", null, [
+  track.info.type === "video" ? vmhd() : smhd(),
+  dinf(),
+  stbl(track)
+]);
+var vmhd = () => fullBox("vmhd", 0, 1, [
+  u16(0),
+  // Graphics mode
+  u16(0),
+  // Opcolor R
+  u16(0),
+  // Opcolor G
+  u16(0)
+  // Opcolor B
+]);
+var smhd = () => fullBox("smhd", 0, 0, [
+  u16(0),
+  // Balance
+  u16(0)
+  // Reserved
+]);
+var dinf = () => box("dinf", null, [
+  dref()
+]);
+var dref = () => fullBox("dref", 0, 0, [
+  u32(1)
+  // Entry count
+], [
+  url()
+]);
+var url = () => fullBox("url ", 0, 1);
+var stbl = (track) => {
+  const needsCtts = track.compositionTimeOffsetTable.length > 1 || track.compositionTimeOffsetTable.some((x) => x.sampleCompositionTimeOffset !== 0);
+  return box("stbl", null, [
+    stsd(track),
+    stts(track),
+    stss(track),
+    stsc(track),
+    stsz(track),
+    stco(track),
+    needsCtts ? ctts(track) : null
+  ]);
+};
+var stsd = (track) => fullBox("stsd", 0, 0, [
+  u32(1)
+  // Entry count
+], [
+  track.info.type === "video" ? videoSampleDescription(
+    VIDEO_CODEC_TO_BOX_NAME[track.info.codec],
+    track
+  ) : soundSampleDescription(
+    AUDIO_CODEC_TO_BOX_NAME[track.info.codec],
+    track
+  )
+]);
+var videoSampleDescription = (compressionType, track) => box(compressionType, [
+  Array(6).fill(0),
+  // Reserved
+  u16(1),
+  // Data reference index
+  u16(0),
+  // Pre-defined
+  u16(0),
+  // Reserved
+  Array(12).fill(0),
+  // Pre-defined
+  u16(track.info.width),
+  // Width
+  u16(track.info.height),
+  // Height
+  u32(4718592),
+  // Horizontal resolution
+  u32(4718592),
+  // Vertical resolution
+  u32(0),
+  // Reserved
+  u16(1),
+  // Frame count
+  Array(32).fill(0),
+  // Compressor name
+  u16(24),
+  // Depth
+  i16(65535)
+  // Pre-defined
+], [
+  VIDEO_CODEC_TO_CONFIGURATION_BOX[track.info.codec](track),
+  track.info.decoderConfig.colorSpace ? colr(track) : null
+]);
+var COLOR_PRIMARIES_MAP = {
+  "bt709": 1,
+  // ITU-R BT.709
+  "bt470bg": 5,
+  // ITU-R BT.470BG
+  "smpte170m": 6
+  // ITU-R BT.601 525 - SMPTE 170M
+};
+var TRANSFER_CHARACTERISTICS_MAP = {
+  "bt709": 1,
+  // ITU-R BT.709
+  "smpte170m": 6,
+  // SMPTE 170M
+  "iec61966-2-1": 13
+  // IEC 61966-2-1
+};
+var MATRIX_COEFFICIENTS_MAP = {
+  "rgb": 0,
+  // Identity
+  "bt709": 1,
+  // ITU-R BT.709
+  "bt470bg": 5,
+  // ITU-R BT.470BG
+  "smpte170m": 6
+  // SMPTE 170M
+};
+var colr = (track) => box("colr", [
+  ascii("nclx"),
+  // Colour type
+  u16(COLOR_PRIMARIES_MAP[track.info.decoderConfig.colorSpace.primaries]),
+  // Colour primaries
+  u16(TRANSFER_CHARACTERISTICS_MAP[track.info.decoderConfig.colorSpace.transfer]),
+  // Transfer characteristics
+  u16(MATRIX_COEFFICIENTS_MAP[track.info.decoderConfig.colorSpace.matrix]),
+  // Matrix coefficients
+  u8((track.info.decoderConfig.colorSpace.fullRange ? 1 : 0) << 7)
+  // Full range flag
+]);
+var avcC = (track) => track.info.decoderConfig && box("avcC", [
+  // For AVC, description is an AVCDecoderConfigurationRecord, so nothing else to do here
+  ...new Uint8Array(track.info.decoderConfig.description)
+]);
+var hvcC = (track) => track.info.decoderConfig && box("hvcC", [
+  // For HEVC, description is a HEVCDecoderConfigurationRecord, so nothing else to do here
+  ...new Uint8Array(track.info.decoderConfig.description)
+]);
+var vpcC = (track) => {
+  if (!track.info.decoderConfig) {
+    return null;
+  }
+  let decoderConfig = track.info.decoderConfig;
+  if (!decoderConfig.colorSpace) {
+    throw new Error(`'colorSpace' is required in the decoder config for VP9.`);
+  }
+  let parts = decoderConfig.codec.split(".");
+  let profile = Number(parts[1]);
+  let level = Number(parts[2]);
+  let bitDepth = Number(parts[3]);
+  let chromaSubsampling = 0;
+  let thirdByte = (bitDepth << 4) + (chromaSubsampling << 1) + Number(decoderConfig.colorSpace.fullRange);
+  let colourPrimaries = 2;
+  let transferCharacteristics = 2;
+  let matrixCoefficients = 2;
+  return fullBox("vpcC", 1, 0, [
+    u8(profile),
+    // Profile
+    u8(level),
+    // Level
+    u8(thirdByte),
+    // Bit depth, chroma subsampling, full range
+    u8(colourPrimaries),
+    // Colour primaries
+    u8(transferCharacteristics),
+    // Transfer characteristics
+    u8(matrixCoefficients),
+    // Matrix coefficients
+    u16(0)
+    // Codec initialization data size
+  ]);
+};
+var av1C = () => {
+  let marker = 1;
+  let version = 1;
+  let firstByte = (marker << 7) + version;
+  return box("av1C", [
+    firstByte,
+    0,
+    0,
+    0
+  ]);
+};
+var soundSampleDescription = (compressionType, track) => box(compressionType, [
+  Array(6).fill(0),
+  // Reserved
+  u16(1),
+  // Data reference index
+  u16(0),
+  // Version
+  u16(0),
+  // Revision level
+  u32(0),
+  // Vendor
+  u16(track.info.numberOfChannels),
+  // Number of channels
+  u16(16),
+  // Sample size (bits)
+  u16(0),
+  // Compression ID
+  u16(0),
+  // Packet size
+  fixed_16_16(track.info.sampleRate)
+  // Sample rate
+], [
+  AUDIO_CODEC_TO_CONFIGURATION_BOX[track.info.codec](track)
+]);
+var esds = (track) => {
+  let description = new Uint8Array(track.info.decoderConfig.description);
+  return fullBox("esds", 0, 0, [
+    // https://stackoverflow.com/a/54803118
+    u32(58753152),
+    // TAG(3) = Object Descriptor ([2])
+    u8(32 + description.byteLength),
+    // length of this OD (which includes the next 2 tags)
+    u16(1),
+    // ES_ID = 1
+    u8(0),
+    // flags etc = 0
+    u32(75530368),
+    // TAG(4) = ES Descriptor ([2]) embedded in above OD
+    u8(18 + description.byteLength),
+    // length of this ESD
+    u8(64),
+    // MPEG-4 Audio
+    u8(21),
+    // stream type(6bits)=5 audio, flags(2bits)=1
+    u24(0),
+    // 24bit buffer size
+    u32(130071),
+    // max bitrate
+    u32(130071),
+    // avg bitrate
+    u32(92307584),
+    // TAG(5) = ASC ([2],[3]) embedded in above OD
+    u8(description.byteLength),
+    // length
+    ...description,
+    u32(109084800),
+    // TAG(6)
+    u8(1),
+    // length
+    u8(2)
+    // data
+  ]);
+};
+var dOps = (track) => {
+  let preskip = 3840;
+  let gain = 0;
+  const description = track.info.decoderConfig?.description;
+  if (description) {
+    if (description.byteLength < 18) {
+      throw new TypeError("Invalid decoder description provided for Opus; must be at least 18 bytes long.");
+    }
+    const view2 = ArrayBuffer.isView(description) ? new DataView(description.buffer, description.byteOffset, description.byteLength) : new DataView(description);
+    preskip = view2.getUint16(10, true);
+    gain = view2.getInt16(14, true);
+  }
+  return box("dOps", [
+    u8(0),
+    // Version
+    u8(track.info.numberOfChannels),
+    // OutputChannelCount
+    u16(preskip),
+    u32(track.info.sampleRate),
+    // InputSampleRate
+    fixed_8_8(gain),
+    // OutputGain
+    u8(0)
+    // ChannelMappingFamily
+  ]);
+};
+var stts = (track) => {
+  return fullBox("stts", 0, 0, [
+    u32(track.timeToSampleTable.length),
+    // Number of entries
+    track.timeToSampleTable.map((x) => [
+      // Time-to-sample table
+      u32(x.sampleCount),
+      // Sample count
+      u32(x.sampleDelta)
+      // Sample duration
+    ])
+  ]);
+};
+var stss = (track) => {
+  if (track.samples.every((x) => x.type === "key"))
+    return null;
+  let keySamples = [...track.samples.entries()].filter(([, sample]) => sample.type === "key");
+  return fullBox("stss", 0, 0, [
+    u32(keySamples.length),
+    // Number of entries
+    keySamples.map(([index]) => u32(index + 1))
+    // Sync sample table
+  ]);
+};
+var stsc = (track) => {
+  return fullBox("stsc", 0, 0, [
+    u32(track.compactlyCodedChunkTable.length),
+    // Number of entries
+    track.compactlyCodedChunkTable.map((x) => [
+      // Sample-to-chunk table
+      u32(x.firstChunk),
+      // First chunk
+      u32(x.samplesPerChunk),
+      // Samples per chunk
+      u32(1)
+      // Sample description index
+    ])
+  ]);
+};
+var stsz = (track) => fullBox("stsz", 0, 0, [
+  u32(0),
+  // Sample size (0 means non-constant size)
+  u32(track.samples.length),
+  // Number of entries
+  track.samples.map((x) => u32(x.size))
+  // Sample size table
+]);
+var stco = (track) => {
+  if (track.finalizedChunks.length > 0 && last(track.finalizedChunks).offset >= 2 ** 32) {
+    return fullBox("co64", 0, 0, [
+      u32(track.finalizedChunks.length),
+      // Number of entries
+      track.finalizedChunks.map((x) => u64(x.offset))
+      // Chunk offset table
+    ]);
+  }
+  return fullBox("stco", 0, 0, [
+    u32(track.finalizedChunks.length),
+    // Number of entries
+    track.finalizedChunks.map((x) => u32(x.offset))
+    // Chunk offset table
+  ]);
+};
+var ctts = (track) => {
+  return fullBox("ctts", 0, 0, [
+    u32(track.compositionTimeOffsetTable.length),
+    // Number of entries
+    track.compositionTimeOffsetTable.map((x) => [
+      // Time-to-sample table
+      u32(x.sampleCount),
+      // Sample count
+      u32(x.sampleCompositionTimeOffset)
+      // Sample offset
+    ])
+  ]);
+};
+var mvex = (tracks) => {
+  return box("mvex", null, tracks.map(trex));
+};
+var trex = (track) => {
+  return fullBox("trex", 0, 0, [
+    u32(track.id),
+    // Track ID
+    u32(1),
+    // Default sample description index
+    u32(0),
+    // Default sample duration
+    u32(0),
+    // Default sample size
+    u32(0)
+    // Default sample flags
+  ]);
+};
+var moof = (sequenceNumber, tracks) => {
+  return box("moof", null, [
+    mfhd(sequenceNumber),
+    ...tracks.map(traf)
+  ]);
+};
+var mfhd = (sequenceNumber) => {
+  return fullBox("mfhd", 0, 0, [
+    u32(sequenceNumber)
+    // Sequence number
+  ]);
+};
+var fragmentSampleFlags = (sample) => {
+  let byte1 = 0;
+  let byte2 = 0;
+  let byte3 = 0;
+  let byte4 = 0;
+  let sampleIsDifferenceSample = sample.type === "delta";
+  byte2 |= +sampleIsDifferenceSample;
+  if (sampleIsDifferenceSample) {
+    byte1 |= 1;
+  } else {
+    byte1 |= 2;
+  }
+  return byte1 << 24 | byte2 << 16 | byte3 << 8 | byte4;
+};
+var traf = (track) => {
+  return box("traf", null, [
+    tfhd(track),
+    tfdt(track),
+    trun(track)
+  ]);
+};
+var tfhd = (track) => {
+  let tfFlags = 0;
+  tfFlags |= 8;
+  tfFlags |= 16;
+  tfFlags |= 32;
+  tfFlags |= 131072;
+  let referenceSample = track.currentChunk.samples[1] ?? track.currentChunk.samples[0];
+  let referenceSampleInfo = {
+    duration: referenceSample.timescaleUnitsToNextSample,
+    size: referenceSample.size,
+    flags: fragmentSampleFlags(referenceSample)
+  };
+  return fullBox("tfhd", 0, tfFlags, [
+    u32(track.id),
+    // Track ID
+    u32(referenceSampleInfo.duration),
+    // Default sample duration
+    u32(referenceSampleInfo.size),
+    // Default sample size
+    u32(referenceSampleInfo.flags)
+    // Default sample flags
+  ]);
+};
+var tfdt = (track) => {
+  return fullBox("tfdt", 1, 0, [
+    u64(intoTimescale(track.currentChunk.startTimestamp, track.timescale))
+    // Base Media Decode Time
+  ]);
+};
+var trun = (track) => {
+  let allSampleDurations = track.currentChunk.samples.map((x) => x.timescaleUnitsToNextSample);
+  let allSampleSizes = track.currentChunk.samples.map((x) => x.size);
+  let allSampleFlags = track.currentChunk.samples.map(fragmentSampleFlags);
+  let allSampleCompositionTimeOffsets = track.currentChunk.samples.map((x) => intoTimescale(x.presentationTimestamp - x.decodeTimestamp, track.timescale));
+  let uniqueSampleDurations = new Set(allSampleDurations);
+  let uniqueSampleSizes = new Set(allSampleSizes);
+  let uniqueSampleFlags = new Set(allSampleFlags);
+  let uniqueSampleCompositionTimeOffsets = new Set(allSampleCompositionTimeOffsets);
+  let firstSampleFlagsPresent = uniqueSampleFlags.size === 2 && allSampleFlags[0] !== allSampleFlags[1];
+  let sampleDurationPresent = uniqueSampleDurations.size > 1;
+  let sampleSizePresent = uniqueSampleSizes.size > 1;
+  let sampleFlagsPresent = !firstSampleFlagsPresent && uniqueSampleFlags.size > 1;
+  let sampleCompositionTimeOffsetsPresent = uniqueSampleCompositionTimeOffsets.size > 1 || [...uniqueSampleCompositionTimeOffsets].some((x) => x !== 0);
+  let flags = 0;
+  flags |= 1;
+  flags |= 4 * +firstSampleFlagsPresent;
+  flags |= 256 * +sampleDurationPresent;
+  flags |= 512 * +sampleSizePresent;
+  flags |= 1024 * +sampleFlagsPresent;
+  flags |= 2048 * +sampleCompositionTimeOffsetsPresent;
+  return fullBox("trun", 1, flags, [
+    u32(track.currentChunk.samples.length),
+    // Sample count
+    u32(track.currentChunk.offset - track.currentChunk.moofOffset || 0),
+    // Data offset
+    firstSampleFlagsPresent ? u32(allSampleFlags[0]) : [],
+    track.currentChunk.samples.map((_, i) => [
+      sampleDurationPresent ? u32(allSampleDurations[i]) : [],
+      // Sample duration
+      sampleSizePresent ? u32(allSampleSizes[i]) : [],
+      // Sample size
+      sampleFlagsPresent ? u32(allSampleFlags[i]) : [],
+      // Sample flags
+      // Sample composition time offsets
+      sampleCompositionTimeOffsetsPresent ? i32(allSampleCompositionTimeOffsets[i]) : []
+    ])
+  ]);
+};
+var mfra = (tracks) => {
+  return box("mfra", null, [
+    ...tracks.map(tfra),
+    mfro()
+  ]);
+};
+var tfra = (track, trackIndex) => {
+  let version = 1;
+  return fullBox("tfra", version, 0, [
+    u32(track.id),
+    // Track ID
+    u32(63),
+    // This specifies that traf number, trun number and sample number are 32-bit ints
+    u32(track.finalizedChunks.length),
+    // Number of entries
+    track.finalizedChunks.map((chunk) => [
+      u64(intoTimescale(chunk.startTimestamp, track.timescale)),
+      // Time
+      u64(chunk.moofOffset),
+      // moof offset
+      u32(trackIndex + 1),
+      // traf number
+      u32(1),
+      // trun number
+      u32(1)
+      // Sample number
+    ])
+  ]);
+};
+var mfro = () => {
+  return fullBox("mfro", 0, 0, [
+    // This value needs to be overwritten manually from the outside, where the actual size of the enclosing mfra box
+    // is known
+    u32(0)
+    // Size
+  ]);
+};
+var VIDEO_CODEC_TO_BOX_NAME = {
+  "avc": "avc1",
+  "hevc": "hvc1",
+  "vp9": "vp09",
+  "av1": "av01"
+};
+var VIDEO_CODEC_TO_CONFIGURATION_BOX = {
+  "avc": avcC,
+  "hevc": hvcC,
+  "vp9": vpcC,
+  "av1": av1C
+};
+var AUDIO_CODEC_TO_BOX_NAME = {
+  "aac": "mp4a",
+  "opus": "Opus"
+};
+var AUDIO_CODEC_TO_CONFIGURATION_BOX = {
+  "aac": esds,
+  "opus": dOps
+};
+var Target = class {
+};
+var ArrayBufferTarget = class extends Target {
+  constructor() {
+    super(...arguments);
+    this.buffer = null;
+  }
+};
+var StreamTarget = class extends Target {
+  constructor(options) {
+    super();
+    this.options = options;
+    if (typeof options !== "object") {
+      throw new TypeError("StreamTarget requires an options object to be passed to its constructor.");
+    }
+    if (options.onData) {
+      if (typeof options.onData !== "function") {
+        throw new TypeError("options.onData, when provided, must be a function.");
+      }
+      if (options.onData.length < 2) {
+        throw new TypeError(
+          "options.onData, when provided, must be a function that takes in at least two arguments (data and position). Ignoring the position argument, which specifies the byte offset at which the data is to be written, can lead to broken outputs."
+        );
+      }
+    }
+    if (options.chunked !== void 0 && typeof options.chunked !== "boolean") {
+      throw new TypeError("options.chunked, when provided, must be a boolean.");
+    }
+    if (options.chunkSize !== void 0 && (!Number.isInteger(options.chunkSize) || options.chunkSize < 1024)) {
+      throw new TypeError("options.chunkSize, when provided, must be an integer and not smaller than 1024.");
+    }
+  }
+};
+var FileSystemWritableFileStreamTarget = class extends Target {
+  constructor(stream, options) {
+    super();
+    this.stream = stream;
+    this.options = options;
+    if (!(stream instanceof FileSystemWritableFileStream)) {
+      throw new TypeError("FileSystemWritableFileStreamTarget requires a FileSystemWritableFileStream instance.");
+    }
+    if (options !== void 0 && typeof options !== "object") {
+      throw new TypeError("FileSystemWritableFileStreamTarget's options, when provided, must be an object.");
+    }
+    if (options) {
+      if (options.chunkSize !== void 0 && (!Number.isInteger(options.chunkSize) || options.chunkSize <= 0)) {
+        throw new TypeError("options.chunkSize, when provided, must be a positive integer");
+      }
+    }
+  }
+};
+var _helper, _helperView;
+var Writer = class {
+  constructor() {
+    this.pos = 0;
+    __privateAdd(this, _helper, new Uint8Array(8));
+    __privateAdd(this, _helperView, new DataView(__privateGet(this, _helper).buffer));
+    this.offsets = /* @__PURE__ */ new WeakMap();
+  }
+  /** Sets the current position for future writes to a new one. */
+  seek(newPos) {
+    this.pos = newPos;
+  }
+  writeU32(value) {
+    __privateGet(this, _helperView).setUint32(0, value, false);
+    this.write(__privateGet(this, _helper).subarray(0, 4));
+  }
+  writeU64(value) {
+    __privateGet(this, _helperView).setUint32(0, Math.floor(value / 2 ** 32), false);
+    __privateGet(this, _helperView).setUint32(4, value, false);
+    this.write(__privateGet(this, _helper).subarray(0, 8));
+  }
+  writeAscii(text) {
+    for (let i = 0; i < text.length; i++) {
+      __privateGet(this, _helperView).setUint8(i % 8, text.charCodeAt(i));
+      if (i % 8 === 7)
+        this.write(__privateGet(this, _helper));
+    }
+    if (text.length % 8 !== 0) {
+      this.write(__privateGet(this, _helper).subarray(0, text.length % 8));
+    }
+  }
+  writeBox(box2) {
+    this.offsets.set(box2, this.pos);
+    if (box2.contents && !box2.children) {
+      this.writeBoxHeader(box2, box2.size ?? box2.contents.byteLength + 8);
+      this.write(box2.contents);
+    } else {
+      let startPos = this.pos;
+      this.writeBoxHeader(box2, 0);
+      if (box2.contents)
+        this.write(box2.contents);
+      if (box2.children) {
+        for (let child of box2.children)
+          if (child)
+            this.writeBox(child);
+      }
+      let endPos = this.pos;
+      let size = box2.size ?? endPos - startPos;
+      this.seek(startPos);
+      this.writeBoxHeader(box2, size);
+      this.seek(endPos);
+    }
+  }
+  writeBoxHeader(box2, size) {
+    this.writeU32(box2.largeSize ? 1 : size);
+    this.writeAscii(box2.type);
+    if (box2.largeSize)
+      this.writeU64(size);
+  }
+  measureBoxHeader(box2) {
+    return 8 + (box2.largeSize ? 8 : 0);
+  }
+  patchBox(box2) {
+    let endPos = this.pos;
+    this.seek(this.offsets.get(box2));
+    this.writeBox(box2);
+    this.seek(endPos);
+  }
+  measureBox(box2) {
+    if (box2.contents && !box2.children) {
+      let headerSize = this.measureBoxHeader(box2);
+      return headerSize + box2.contents.byteLength;
+    } else {
+      let result = this.measureBoxHeader(box2);
+      if (box2.contents)
+        result += box2.contents.byteLength;
+      if (box2.children) {
+        for (let child of box2.children)
+          if (child)
+            result += this.measureBox(child);
+      }
+      return result;
+    }
+  }
+};
+_helper = /* @__PURE__ */ new WeakMap();
+_helperView = /* @__PURE__ */ new WeakMap();
+var _target, _buffer, _bytes, _maxPos, _ensureSize, ensureSize_fn;
+var ArrayBufferTargetWriter = class extends Writer {
+  constructor(target) {
+    super();
+    __privateAdd(this, _ensureSize);
+    __privateAdd(this, _target, void 0);
+    __privateAdd(this, _buffer, new ArrayBuffer(2 ** 16));
+    __privateAdd(this, _bytes, new Uint8Array(__privateGet(this, _buffer)));
+    __privateAdd(this, _maxPos, 0);
+    __privateSet(this, _target, target);
+  }
+  write(data) {
+    __privateMethod(this, _ensureSize, ensureSize_fn).call(this, this.pos + data.byteLength);
+    __privateGet(this, _bytes).set(data, this.pos);
+    this.pos += data.byteLength;
+    __privateSet(this, _maxPos, Math.max(__privateGet(this, _maxPos), this.pos));
+  }
+  finalize() {
+    __privateMethod(this, _ensureSize, ensureSize_fn).call(this, this.pos);
+    __privateGet(this, _target).buffer = __privateGet(this, _buffer).slice(0, Math.max(__privateGet(this, _maxPos), this.pos));
+  }
+};
+_target = /* @__PURE__ */ new WeakMap();
+_buffer = /* @__PURE__ */ new WeakMap();
+_bytes = /* @__PURE__ */ new WeakMap();
+_maxPos = /* @__PURE__ */ new WeakMap();
+_ensureSize = /* @__PURE__ */ new WeakSet();
+ensureSize_fn = function(size) {
+  let newLength = __privateGet(this, _buffer).byteLength;
+  while (newLength < size)
+    newLength *= 2;
+  if (newLength === __privateGet(this, _buffer).byteLength)
+    return;
+  let newBuffer = new ArrayBuffer(newLength);
+  let newBytes = new Uint8Array(newBuffer);
+  newBytes.set(__privateGet(this, _bytes), 0);
+  __privateSet(this, _buffer, newBuffer);
+  __privateSet(this, _bytes, newBytes);
+};
+var DEFAULT_CHUNK_SIZE = 2 ** 24;
+var MAX_CHUNKS_AT_ONCE = 2;
+var _target2, _sections, _chunked, _chunkSize, _chunks, _writeDataIntoChunks, writeDataIntoChunks_fn, _insertSectionIntoChunk, insertSectionIntoChunk_fn, _createChunk, createChunk_fn, _flushChunks, flushChunks_fn;
+var StreamTargetWriter = class extends Writer {
+  constructor(target) {
+    super();
+    __privateAdd(this, _writeDataIntoChunks);
+    __privateAdd(this, _insertSectionIntoChunk);
+    __privateAdd(this, _createChunk);
+    __privateAdd(this, _flushChunks);
+    __privateAdd(this, _target2, void 0);
+    __privateAdd(this, _sections, []);
+    __privateAdd(this, _chunked, void 0);
+    __privateAdd(this, _chunkSize, void 0);
+    __privateAdd(this, _chunks, []);
+    __privateSet(this, _target2, target);
+    __privateSet(this, _chunked, target.options?.chunked ?? false);
+    __privateSet(this, _chunkSize, target.options?.chunkSize ?? DEFAULT_CHUNK_SIZE);
+  }
+  write(data) {
+    __privateGet(this, _sections).push({
+      data: data.slice(),
+      start: this.pos
+    });
+    this.pos += data.byteLength;
+  }
+  flush() {
+    if (__privateGet(this, _sections).length === 0)
+      return;
+    let chunks = [];
+    let sorted = [...__privateGet(this, _sections)].sort((a, b) => a.start - b.start);
+    chunks.push({
+      start: sorted[0].start,
+      size: sorted[0].data.byteLength
+    });
+    for (let i = 1; i < sorted.length; i++) {
+      let lastChunk = chunks[chunks.length - 1];
+      let section = sorted[i];
+      if (section.start <= lastChunk.start + lastChunk.size) {
+        lastChunk.size = Math.max(lastChunk.size, section.start + section.data.byteLength - lastChunk.start);
+      } else {
+        chunks.push({
+          start: section.start,
+          size: section.data.byteLength
+        });
+      }
+    }
+    for (let chunk of chunks) {
+      chunk.data = new Uint8Array(chunk.size);
+      for (let section of __privateGet(this, _sections)) {
+        if (chunk.start <= section.start && section.start < chunk.start + chunk.size) {
+          chunk.data.set(section.data, section.start - chunk.start);
+        }
+      }
+      if (__privateGet(this, _chunked)) {
+        __privateMethod(this, _writeDataIntoChunks, writeDataIntoChunks_fn).call(this, chunk.data, chunk.start);
+        __privateMethod(this, _flushChunks, flushChunks_fn).call(this);
+      } else {
+        __privateGet(this, _target2).options.onData?.(chunk.data, chunk.start);
+      }
+    }
+    __privateGet(this, _sections).length = 0;
+  }
+  finalize() {
+    if (__privateGet(this, _chunked)) {
+      __privateMethod(this, _flushChunks, flushChunks_fn).call(this, true);
+    }
+  }
+};
+_target2 = /* @__PURE__ */ new WeakMap();
+_sections = /* @__PURE__ */ new WeakMap();
+_chunked = /* @__PURE__ */ new WeakMap();
+_chunkSize = /* @__PURE__ */ new WeakMap();
+_chunks = /* @__PURE__ */ new WeakMap();
+_writeDataIntoChunks = /* @__PURE__ */ new WeakSet();
+writeDataIntoChunks_fn = function(data, position) {
+  let chunkIndex = __privateGet(this, _chunks).findIndex((x) => x.start <= position && position < x.start + __privateGet(this, _chunkSize));
+  if (chunkIndex === -1)
+    chunkIndex = __privateMethod(this, _createChunk, createChunk_fn).call(this, position);
+  let chunk = __privateGet(this, _chunks)[chunkIndex];
+  let relativePosition = position - chunk.start;
+  let toWrite = data.subarray(0, Math.min(__privateGet(this, _chunkSize) - relativePosition, data.byteLength));
+  chunk.data.set(toWrite, relativePosition);
+  let section = {
+    start: relativePosition,
+    end: relativePosition + toWrite.byteLength
+  };
+  __privateMethod(this, _insertSectionIntoChunk, insertSectionIntoChunk_fn).call(this, chunk, section);
+  if (chunk.written[0].start === 0 && chunk.written[0].end === __privateGet(this, _chunkSize)) {
+    chunk.shouldFlush = true;
+  }
+  if (__privateGet(this, _chunks).length > MAX_CHUNKS_AT_ONCE) {
+    for (let i = 0; i < __privateGet(this, _chunks).length - 1; i++) {
+      __privateGet(this, _chunks)[i].shouldFlush = true;
+    }
+    __privateMethod(this, _flushChunks, flushChunks_fn).call(this);
+  }
+  if (toWrite.byteLength < data.byteLength) {
+    __privateMethod(this, _writeDataIntoChunks, writeDataIntoChunks_fn).call(this, data.subarray(toWrite.byteLength), position + toWrite.byteLength);
+  }
+};
+_insertSectionIntoChunk = /* @__PURE__ */ new WeakSet();
+insertSectionIntoChunk_fn = function(chunk, section) {
+  let low = 0;
+  let high = chunk.written.length - 1;
+  let index = -1;
+  while (low <= high) {
+    let mid = Math.floor(low + (high - low + 1) / 2);
+    if (chunk.written[mid].start <= section.start) {
+      low = mid + 1;
+      index = mid;
+    } else {
+      high = mid - 1;
+    }
+  }
+  chunk.written.splice(index + 1, 0, section);
+  if (index === -1 || chunk.written[index].end < section.start)
+    index++;
+  while (index < chunk.written.length - 1 && chunk.written[index].end >= chunk.written[index + 1].start) {
+    chunk.written[index].end = Math.max(chunk.written[index].end, chunk.written[index + 1].end);
+    chunk.written.splice(index + 1, 1);
+  }
+};
+_createChunk = /* @__PURE__ */ new WeakSet();
+createChunk_fn = function(includesPosition) {
+  let start = Math.floor(includesPosition / __privateGet(this, _chunkSize)) * __privateGet(this, _chunkSize);
+  let chunk = {
+    start,
+    data: new Uint8Array(__privateGet(this, _chunkSize)),
+    written: [],
+    shouldFlush: false
+  };
+  __privateGet(this, _chunks).push(chunk);
+  __privateGet(this, _chunks).sort((a, b) => a.start - b.start);
+  return __privateGet(this, _chunks).indexOf(chunk);
+};
+_flushChunks = /* @__PURE__ */ new WeakSet();
+flushChunks_fn = function(force = false) {
+  for (let i = 0; i < __privateGet(this, _chunks).length; i++) {
+    let chunk = __privateGet(this, _chunks)[i];
+    if (!chunk.shouldFlush && !force)
+      continue;
+    for (let section of chunk.written) {
+      __privateGet(this, _target2).options.onData?.(
+        chunk.data.subarray(section.start, section.end),
+        chunk.start + section.start
+      );
+    }
+    __privateGet(this, _chunks).splice(i--, 1);
+  }
+};
+var FileSystemWritableFileStreamTargetWriter = class extends StreamTargetWriter {
+  constructor(target) {
+    super(new StreamTarget({
+      onData: (data, position) => target.stream.write({
+        type: "write",
+        data,
+        position
+      }),
+      chunked: true,
+      chunkSize: target.options?.chunkSize
+    }));
+  }
+};
+var GLOBAL_TIMESCALE = 1e3;
+var SUPPORTED_VIDEO_CODECS = ["avc", "hevc", "vp9", "av1"];
+var SUPPORTED_AUDIO_CODECS = ["aac", "opus"];
+var TIMESTAMP_OFFSET = 2082844800;
+var FIRST_TIMESTAMP_BEHAVIORS = ["strict", "offset", "cross-track-offset"];
+var _options, _writer, _ftypSize, _mdat, _videoTrack, _audioTrack, _creationTime, _finalizedChunks, _nextFragmentNumber, _videoSampleQueue, _audioSampleQueue, _finalized, _validateOptions, validateOptions_fn, _writeHeader, writeHeader_fn, _computeMoovSizeUpperBound, computeMoovSizeUpperBound_fn, _prepareTracks, prepareTracks_fn, _generateMpeg4AudioSpecificConfig, generateMpeg4AudioSpecificConfig_fn, _createSampleForTrack, createSampleForTrack_fn, _addSampleToTrack, addSampleToTrack_fn, _validateTimestamp, validateTimestamp_fn, _finalizeCurrentChunk, finalizeCurrentChunk_fn, _finalizeFragment, finalizeFragment_fn, _maybeFlushStreamingTargetWriter, maybeFlushStreamingTargetWriter_fn, _ensureNotFinalized, ensureNotFinalized_fn;
+var Muxer = class {
+  constructor(options) {
+    __privateAdd(this, _validateOptions);
+    __privateAdd(this, _writeHeader);
+    __privateAdd(this, _computeMoovSizeUpperBound);
+    __privateAdd(this, _prepareTracks);
+    __privateAdd(this, _generateMpeg4AudioSpecificConfig);
+    __privateAdd(this, _createSampleForTrack);
+    __privateAdd(this, _addSampleToTrack);
+    __privateAdd(this, _validateTimestamp);
+    __privateAdd(this, _finalizeCurrentChunk);
+    __privateAdd(this, _finalizeFragment);
+    __privateAdd(this, _maybeFlushStreamingTargetWriter);
+    __privateAdd(this, _ensureNotFinalized);
+    __privateAdd(this, _options, void 0);
+    __privateAdd(this, _writer, void 0);
+    __privateAdd(this, _ftypSize, void 0);
+    __privateAdd(this, _mdat, void 0);
+    __privateAdd(this, _videoTrack, null);
+    __privateAdd(this, _audioTrack, null);
+    __privateAdd(this, _creationTime, Math.floor(Date.now() / 1e3) + TIMESTAMP_OFFSET);
+    __privateAdd(this, _finalizedChunks, []);
+    __privateAdd(this, _nextFragmentNumber, 1);
+    __privateAdd(this, _videoSampleQueue, []);
+    __privateAdd(this, _audioSampleQueue, []);
+    __privateAdd(this, _finalized, false);
+    __privateMethod(this, _validateOptions, validateOptions_fn).call(this, options);
+    options.video = deepClone(options.video);
+    options.audio = deepClone(options.audio);
+    options.fastStart = deepClone(options.fastStart);
+    this.target = options.target;
+    __privateSet(this, _options, {
+      firstTimestampBehavior: "strict",
+      ...options
+    });
+    if (options.target instanceof ArrayBufferTarget) {
+      __privateSet(this, _writer, new ArrayBufferTargetWriter(options.target));
+    } else if (options.target instanceof StreamTarget) {
+      __privateSet(this, _writer, new StreamTargetWriter(options.target));
+    } else if (options.target instanceof FileSystemWritableFileStreamTarget) {
+      __privateSet(this, _writer, new FileSystemWritableFileStreamTargetWriter(options.target));
+    } else {
+      throw new Error(`Invalid target: ${options.target}`);
+    }
+    __privateMethod(this, _prepareTracks, prepareTracks_fn).call(this);
+    __privateMethod(this, _writeHeader, writeHeader_fn).call(this);
+  }
+  addVideoChunk(sample, meta, timestamp, compositionTimeOffset) {
+    if (!(sample instanceof EncodedVideoChunk)) {
+      throw new TypeError("addVideoChunk's first argument (sample) must be of type EncodedVideoChunk.");
+    }
+    if (meta && typeof meta !== "object") {
+      throw new TypeError("addVideoChunk's second argument (meta), when provided, must be an object.");
+    }
+    if (timestamp !== void 0 && (!Number.isFinite(timestamp) || timestamp < 0)) {
+      throw new TypeError(
+        "addVideoChunk's third argument (timestamp), when provided, must be a non-negative real number."
+      );
+    }
+    if (compositionTimeOffset !== void 0 && !Number.isFinite(compositionTimeOffset)) {
+      throw new TypeError(
+        "addVideoChunk's fourth argument (compositionTimeOffset), when provided, must be a real number."
+      );
+    }
+    let data = new Uint8Array(sample.byteLength);
+    sample.copyTo(data);
+    this.addVideoChunkRaw(
+      data,
+      sample.type,
+      timestamp ?? sample.timestamp,
+      sample.duration,
+      meta,
+      compositionTimeOffset
+    );
+  }
+  addVideoChunkRaw(data, type, timestamp, duration, meta, compositionTimeOffset) {
+    if (!(data instanceof Uint8Array)) {
+      throw new TypeError("addVideoChunkRaw's first argument (data) must be an instance of Uint8Array.");
+    }
+    if (type !== "key" && type !== "delta") {
+      throw new TypeError("addVideoChunkRaw's second argument (type) must be either 'key' or 'delta'.");
+    }
+    if (!Number.isFinite(timestamp) || timestamp < 0) {
+      throw new TypeError("addVideoChunkRaw's third argument (timestamp) must be a non-negative real number.");
+    }
+    if (!Number.isFinite(duration) || duration < 0) {
+      throw new TypeError("addVideoChunkRaw's fourth argument (duration) must be a non-negative real number.");
+    }
+    if (meta && typeof meta !== "object") {
+      throw new TypeError("addVideoChunkRaw's fifth argument (meta), when provided, must be an object.");
+    }
+    if (compositionTimeOffset !== void 0 && !Number.isFinite(compositionTimeOffset)) {
+      throw new TypeError(
+        "addVideoChunkRaw's sixth argument (compositionTimeOffset), when provided, must be a real number."
+      );
+    }
+    __privateMethod(this, _ensureNotFinalized, ensureNotFinalized_fn).call(this);
+    if (!__privateGet(this, _options).video)
+      throw new Error("No video track declared.");
+    if (typeof __privateGet(this, _options).fastStart === "object" && __privateGet(this, _videoTrack).samples.length === __privateGet(this, _options).fastStart.expectedVideoChunks) {
+      throw new Error(`Cannot add more video chunks than specified in 'fastStart' (${__privateGet(this, _options).fastStart.expectedVideoChunks}).`);
+    }
+    let videoSample = __privateMethod(this, _createSampleForTrack, createSampleForTrack_fn).call(this, __privateGet(this, _videoTrack), data, type, timestamp, duration, meta, compositionTimeOffset);
+    if (__privateGet(this, _options).fastStart === "fragmented" && __privateGet(this, _audioTrack)) {
+      while (__privateGet(this, _audioSampleQueue).length > 0 && __privateGet(this, _audioSampleQueue)[0].decodeTimestamp <= videoSample.decodeTimestamp) {
+        let audioSample = __privateGet(this, _audioSampleQueue).shift();
+        __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _audioTrack), audioSample);
+      }
+      if (videoSample.decodeTimestamp <= __privateGet(this, _audioTrack).lastDecodeTimestamp) {
+        __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _videoTrack), videoSample);
+      } else {
+        __privateGet(this, _videoSampleQueue).push(videoSample);
+      }
+    } else {
+      __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _videoTrack), videoSample);
+    }
+  }
+  addAudioChunk(sample, meta, timestamp) {
+    if (!(sample instanceof EncodedAudioChunk)) {
+      throw new TypeError("addAudioChunk's first argument (sample) must be of type EncodedAudioChunk.");
+    }
+    if (meta && typeof meta !== "object") {
+      throw new TypeError("addAudioChunk's second argument (meta), when provided, must be an object.");
+    }
+    if (timestamp !== void 0 && (!Number.isFinite(timestamp) || timestamp < 0)) {
+      throw new TypeError(
+        "addAudioChunk's third argument (timestamp), when provided, must be a non-negative real number."
+      );
+    }
+    let data = new Uint8Array(sample.byteLength);
+    sample.copyTo(data);
+    this.addAudioChunkRaw(data, sample.type, timestamp ?? sample.timestamp, sample.duration, meta);
+  }
+  addAudioChunkRaw(data, type, timestamp, duration, meta) {
+    if (!(data instanceof Uint8Array)) {
+      throw new TypeError("addAudioChunkRaw's first argument (data) must be an instance of Uint8Array.");
+    }
+    if (type !== "key" && type !== "delta") {
+      throw new TypeError("addAudioChunkRaw's second argument (type) must be either 'key' or 'delta'.");
+    }
+    if (!Number.isFinite(timestamp) || timestamp < 0) {
+      throw new TypeError("addAudioChunkRaw's third argument (timestamp) must be a non-negative real number.");
+    }
+    if (!Number.isFinite(duration) || duration < 0) {
+      throw new TypeError("addAudioChunkRaw's fourth argument (duration) must be a non-negative real number.");
+    }
+    if (meta && typeof meta !== "object") {
+      throw new TypeError("addAudioChunkRaw's fifth argument (meta), when provided, must be an object.");
+    }
+    __privateMethod(this, _ensureNotFinalized, ensureNotFinalized_fn).call(this);
+    if (!__privateGet(this, _options).audio)
+      throw new Error("No audio track declared.");
+    if (typeof __privateGet(this, _options).fastStart === "object" && __privateGet(this, _audioTrack).samples.length === __privateGet(this, _options).fastStart.expectedAudioChunks) {
+      throw new Error(`Cannot add more audio chunks than specified in 'fastStart' (${__privateGet(this, _options).fastStart.expectedAudioChunks}).`);
+    }
+    let audioSample = __privateMethod(this, _createSampleForTrack, createSampleForTrack_fn).call(this, __privateGet(this, _audioTrack), data, type, timestamp, duration, meta);
+    if (__privateGet(this, _options).fastStart === "fragmented" && __privateGet(this, _videoTrack)) {
+      while (__privateGet(this, _videoSampleQueue).length > 0 && __privateGet(this, _videoSampleQueue)[0].decodeTimestamp <= audioSample.decodeTimestamp) {
+        let videoSample = __privateGet(this, _videoSampleQueue).shift();
+        __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _videoTrack), videoSample);
+      }
+      if (audioSample.decodeTimestamp <= __privateGet(this, _videoTrack).lastDecodeTimestamp) {
+        __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _audioTrack), audioSample);
+      } else {
+        __privateGet(this, _audioSampleQueue).push(audioSample);
+      }
+    } else {
+      __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _audioTrack), audioSample);
+    }
+  }
+  /** Finalizes the file, making it ready for use. Must be called after all video and audio chunks have been added. */
+  finalize() {
+    if (__privateGet(this, _finalized)) {
+      throw new Error("Cannot finalize a muxer more than once.");
+    }
+    if (__privateGet(this, _options).fastStart === "fragmented") {
+      for (let videoSample of __privateGet(this, _videoSampleQueue))
+        __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _videoTrack), videoSample);
+      for (let audioSample of __privateGet(this, _audioSampleQueue))
+        __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _audioTrack), audioSample);
+      __privateMethod(this, _finalizeFragment, finalizeFragment_fn).call(this, false);
+    } else {
+      if (__privateGet(this, _videoTrack))
+        __privateMethod(this, _finalizeCurrentChunk, finalizeCurrentChunk_fn).call(this, __privateGet(this, _videoTrack));
+      if (__privateGet(this, _audioTrack))
+        __privateMethod(this, _finalizeCurrentChunk, finalizeCurrentChunk_fn).call(this, __privateGet(this, _audioTrack));
+    }
+    let tracks = [__privateGet(this, _videoTrack), __privateGet(this, _audioTrack)].filter(Boolean);
+    if (__privateGet(this, _options).fastStart === "in-memory") {
+      let mdatSize;
+      for (let i = 0; i < 2; i++) {
+        let movieBox2 = moov(tracks, __privateGet(this, _creationTime));
+        let movieBoxSize = __privateGet(this, _writer).measureBox(movieBox2);
+        mdatSize = __privateGet(this, _writer).measureBox(__privateGet(this, _mdat));
+        let currentChunkPos = __privateGet(this, _writer).pos + movieBoxSize + mdatSize;
+        for (let chunk of __privateGet(this, _finalizedChunks)) {
+          chunk.offset = currentChunkPos;
+          for (let { data } of chunk.samples) {
+            currentChunkPos += data.byteLength;
+            mdatSize += data.byteLength;
+          }
+        }
+        if (currentChunkPos < 2 ** 32)
+          break;
+        if (mdatSize >= 2 ** 32)
+          __privateGet(this, _mdat).largeSize = true;
+      }
+      let movieBox = moov(tracks, __privateGet(this, _creationTime));
+      __privateGet(this, _writer).writeBox(movieBox);
+      __privateGet(this, _mdat).size = mdatSize;
+      __privateGet(this, _writer).writeBox(__privateGet(this, _mdat));
+      for (let chunk of __privateGet(this, _finalizedChunks)) {
+        for (let sample of chunk.samples) {
+          __privateGet(this, _writer).write(sample.data);
+          sample.data = null;
+        }
+      }
+    } else if (__privateGet(this, _options).fastStart === "fragmented") {
+      let startPos = __privateGet(this, _writer).pos;
+      let mfraBox = mfra(tracks);
+      __privateGet(this, _writer).writeBox(mfraBox);
+      let mfraBoxSize = __privateGet(this, _writer).pos - startPos;
+      __privateGet(this, _writer).seek(__privateGet(this, _writer).pos - 4);
+      __privateGet(this, _writer).writeU32(mfraBoxSize);
+    } else {
+      let mdatPos = __privateGet(this, _writer).offsets.get(__privateGet(this, _mdat));
+      let mdatSize = __privateGet(this, _writer).pos - mdatPos;
+      __privateGet(this, _mdat).size = mdatSize;
+      __privateGet(this, _mdat).largeSize = mdatSize >= 2 ** 32;
+      __privateGet(this, _writer).patchBox(__privateGet(this, _mdat));
+      let movieBox = moov(tracks, __privateGet(this, _creationTime));
+      if (typeof __privateGet(this, _options).fastStart === "object") {
+        __privateGet(this, _writer).seek(__privateGet(this, _ftypSize));
+        __privateGet(this, _writer).writeBox(movieBox);
+        let remainingBytes = mdatPos - __privateGet(this, _writer).pos;
+        __privateGet(this, _writer).writeBox(free(remainingBytes));
+      } else {
+        __privateGet(this, _writer).writeBox(movieBox);
+      }
+    }
+    __privateMethod(this, _maybeFlushStreamingTargetWriter, maybeFlushStreamingTargetWriter_fn).call(this);
+    __privateGet(this, _writer).finalize();
+    __privateSet(this, _finalized, true);
+  }
+};
+_options = /* @__PURE__ */ new WeakMap();
+_writer = /* @__PURE__ */ new WeakMap();
+_ftypSize = /* @__PURE__ */ new WeakMap();
+_mdat = /* @__PURE__ */ new WeakMap();
+_videoTrack = /* @__PURE__ */ new WeakMap();
+_audioTrack = /* @__PURE__ */ new WeakMap();
+_creationTime = /* @__PURE__ */ new WeakMap();
+_finalizedChunks = /* @__PURE__ */ new WeakMap();
+_nextFragmentNumber = /* @__PURE__ */ new WeakMap();
+_videoSampleQueue = /* @__PURE__ */ new WeakMap();
+_audioSampleQueue = /* @__PURE__ */ new WeakMap();
+_finalized = /* @__PURE__ */ new WeakMap();
+_validateOptions = /* @__PURE__ */ new WeakSet();
+validateOptions_fn = function(options) {
+  if (typeof options !== "object") {
+    throw new TypeError("The muxer requires an options object to be passed to its constructor.");
+  }
+  if (!(options.target instanceof Target)) {
+    throw new TypeError("The target must be provided and an instance of Target.");
+  }
+  if (options.video) {
+    if (!SUPPORTED_VIDEO_CODECS.includes(options.video.codec)) {
+      throw new TypeError(`Unsupported video codec: ${options.video.codec}`);
+    }
+    if (!Number.isInteger(options.video.width) || options.video.width <= 0) {
+      throw new TypeError(`Invalid video width: ${options.video.width}. Must be a positive integer.`);
+    }
+    if (!Number.isInteger(options.video.height) || options.video.height <= 0) {
+      throw new TypeError(`Invalid video height: ${options.video.height}. Must be a positive integer.`);
+    }
+    const videoRotation = options.video.rotation;
+    if (typeof videoRotation === "number" && ![0, 90, 180, 270].includes(videoRotation)) {
+      throw new TypeError(`Invalid video rotation: ${videoRotation}. Has to be 0, 90, 180 or 270.`);
+    } else if (Array.isArray(videoRotation) && (videoRotation.length !== 9 || videoRotation.some((value) => typeof value !== "number"))) {
+      throw new TypeError(`Invalid video transformation matrix: ${videoRotation.join()}`);
+    }
+    if (options.video.frameRate !== void 0 && (!Number.isInteger(options.video.frameRate) || options.video.frameRate <= 0)) {
+      throw new TypeError(
+        `Invalid video frame rate: ${options.video.frameRate}. Must be a positive integer.`
+      );
+    }
+  }
+  if (options.audio) {
+    if (!SUPPORTED_AUDIO_CODECS.includes(options.audio.codec)) {
+      throw new TypeError(`Unsupported audio codec: ${options.audio.codec}`);
+    }
+    if (!Number.isInteger(options.audio.numberOfChannels) || options.audio.numberOfChannels <= 0) {
+      throw new TypeError(
+        `Invalid number of audio channels: ${options.audio.numberOfChannels}. Must be a positive integer.`
+      );
+    }
+    if (!Number.isInteger(options.audio.sampleRate) || options.audio.sampleRate <= 0) {
+      throw new TypeError(
+        `Invalid audio sample rate: ${options.audio.sampleRate}. Must be a positive integer.`
+      );
+    }
+  }
+  if (options.firstTimestampBehavior && !FIRST_TIMESTAMP_BEHAVIORS.includes(options.firstTimestampBehavior)) {
+    throw new TypeError(`Invalid first timestamp behavior: ${options.firstTimestampBehavior}`);
+  }
+  if (typeof options.fastStart === "object") {
+    if (options.video) {
+      if (options.fastStart.expectedVideoChunks === void 0) {
+        throw new TypeError(`'fastStart' is an object but is missing property 'expectedVideoChunks'.`);
+      } else if (!Number.isInteger(options.fastStart.expectedVideoChunks) || options.fastStart.expectedVideoChunks < 0) {
+        throw new TypeError(`'expectedVideoChunks' must be a non-negative integer.`);
+      }
+    }
+    if (options.audio) {
+      if (options.fastStart.expectedAudioChunks === void 0) {
+        throw new TypeError(`'fastStart' is an object but is missing property 'expectedAudioChunks'.`);
+      } else if (!Number.isInteger(options.fastStart.expectedAudioChunks) || options.fastStart.expectedAudioChunks < 0) {
+        throw new TypeError(`'expectedAudioChunks' must be a non-negative integer.`);
+      }
+    }
+  } else if (![false, "in-memory", "fragmented"].includes(options.fastStart)) {
+    throw new TypeError(`'fastStart' option must be false, 'in-memory', 'fragmented' or an object.`);
+  }
+  if (options.minFragmentDuration !== void 0 && (!Number.isFinite(options.minFragmentDuration) || options.minFragmentDuration < 0)) {
+    throw new TypeError(`'minFragmentDuration' must be a non-negative number.`);
+  }
+};
+_writeHeader = /* @__PURE__ */ new WeakSet();
+writeHeader_fn = function() {
+  __privateGet(this, _writer).writeBox(ftyp({
+    holdsAvc: __privateGet(this, _options).video?.codec === "avc",
+    fragmented: __privateGet(this, _options).fastStart === "fragmented"
+  }));
+  __privateSet(this, _ftypSize, __privateGet(this, _writer).pos);
+  if (__privateGet(this, _options).fastStart === "in-memory") {
+    __privateSet(this, _mdat, mdat(false));
+  } else if (__privateGet(this, _options).fastStart === "fragmented") ;
+  else {
+    if (typeof __privateGet(this, _options).fastStart === "object") {
+      let moovSizeUpperBound = __privateMethod(this, _computeMoovSizeUpperBound, computeMoovSizeUpperBound_fn).call(this);
+      __privateGet(this, _writer).seek(__privateGet(this, _writer).pos + moovSizeUpperBound);
+    }
+    __privateSet(this, _mdat, mdat(true));
+    __privateGet(this, _writer).writeBox(__privateGet(this, _mdat));
+  }
+  __privateMethod(this, _maybeFlushStreamingTargetWriter, maybeFlushStreamingTargetWriter_fn).call(this);
+};
+_computeMoovSizeUpperBound = /* @__PURE__ */ new WeakSet();
+computeMoovSizeUpperBound_fn = function() {
+  if (typeof __privateGet(this, _options).fastStart !== "object")
+    return;
+  let upperBound = 0;
+  let sampleCounts = [
+    __privateGet(this, _options).fastStart.expectedVideoChunks,
+    __privateGet(this, _options).fastStart.expectedAudioChunks
+  ];
+  for (let n of sampleCounts) {
+    if (!n)
+      continue;
+    upperBound += (4 + 4) * Math.ceil(2 / 3 * n);
+    upperBound += 4 * n;
+    upperBound += (4 + 4 + 4) * Math.ceil(2 / 3 * n);
+    upperBound += 4 * n;
+    upperBound += 8 * n;
+  }
+  upperBound += 4096;
+  return upperBound;
+};
+_prepareTracks = /* @__PURE__ */ new WeakSet();
+prepareTracks_fn = function() {
+  if (__privateGet(this, _options).video) {
+    __privateSet(this, _videoTrack, {
+      id: 1,
+      info: {
+        type: "video",
+        codec: __privateGet(this, _options).video.codec,
+        width: __privateGet(this, _options).video.width,
+        height: __privateGet(this, _options).video.height,
+        rotation: __privateGet(this, _options).video.rotation ?? 0,
+        decoderConfig: null
+      },
+      // The fallback contains many common frame rates as factors
+      timescale: __privateGet(this, _options).video.frameRate ?? 57600,
+      samples: [],
+      finalizedChunks: [],
+      currentChunk: null,
+      firstDecodeTimestamp: void 0,
+      lastDecodeTimestamp: -1,
+      timeToSampleTable: [],
+      compositionTimeOffsetTable: [],
+      lastTimescaleUnits: null,
+      lastSample: null,
+      compactlyCodedChunkTable: []
+    });
+  }
+  if (__privateGet(this, _options).audio) {
+    __privateSet(this, _audioTrack, {
+      id: __privateGet(this, _options).video ? 2 : 1,
+      info: {
+        type: "audio",
+        codec: __privateGet(this, _options).audio.codec,
+        numberOfChannels: __privateGet(this, _options).audio.numberOfChannels,
+        sampleRate: __privateGet(this, _options).audio.sampleRate,
+        decoderConfig: null
+      },
+      timescale: __privateGet(this, _options).audio.sampleRate,
+      samples: [],
+      finalizedChunks: [],
+      currentChunk: null,
+      firstDecodeTimestamp: void 0,
+      lastDecodeTimestamp: -1,
+      timeToSampleTable: [],
+      compositionTimeOffsetTable: [],
+      lastTimescaleUnits: null,
+      lastSample: null,
+      compactlyCodedChunkTable: []
+    });
+    if (__privateGet(this, _options).audio.codec === "aac") {
+      let guessedCodecPrivate = __privateMethod(this, _generateMpeg4AudioSpecificConfig, generateMpeg4AudioSpecificConfig_fn).call(
+        this,
+        2,
+        // Object type for AAC-LC, since it's the most common
+        __privateGet(this, _options).audio.sampleRate,
+        __privateGet(this, _options).audio.numberOfChannels
+      );
+      __privateGet(this, _audioTrack).info.decoderConfig = {
+        codec: __privateGet(this, _options).audio.codec,
+        description: guessedCodecPrivate,
+        numberOfChannels: __privateGet(this, _options).audio.numberOfChannels,
+        sampleRate: __privateGet(this, _options).audio.sampleRate
+      };
+    }
+  }
+};
+_generateMpeg4AudioSpecificConfig = /* @__PURE__ */ new WeakSet();
+generateMpeg4AudioSpecificConfig_fn = function(objectType, sampleRate, numberOfChannels) {
+  let frequencyIndices = [96e3, 88200, 64e3, 48e3, 44100, 32e3, 24e3, 22050, 16e3, 12e3, 11025, 8e3, 7350];
+  let frequencyIndex = frequencyIndices.indexOf(sampleRate);
+  let channelConfig = numberOfChannels;
+  let configBits = "";
+  configBits += objectType.toString(2).padStart(5, "0");
+  configBits += frequencyIndex.toString(2).padStart(4, "0");
+  if (frequencyIndex === 15)
+    configBits += sampleRate.toString(2).padStart(24, "0");
+  configBits += channelConfig.toString(2).padStart(4, "0");
+  let paddingLength = Math.ceil(configBits.length / 8) * 8;
+  configBits = configBits.padEnd(paddingLength, "0");
+  let configBytes = new Uint8Array(configBits.length / 8);
+  for (let i = 0; i < configBits.length; i += 8) {
+    configBytes[i / 8] = parseInt(configBits.slice(i, i + 8), 2);
+  }
+  return configBytes;
+};
+_createSampleForTrack = /* @__PURE__ */ new WeakSet();
+createSampleForTrack_fn = function(track, data, type, timestamp, duration, meta, compositionTimeOffset) {
+  let presentationTimestampInSeconds = timestamp / 1e6;
+  let decodeTimestampInSeconds = (timestamp - (compositionTimeOffset ?? 0)) / 1e6;
+  let durationInSeconds = duration / 1e6;
+  let adjusted = __privateMethod(this, _validateTimestamp, validateTimestamp_fn).call(this, presentationTimestampInSeconds, decodeTimestampInSeconds, track);
+  presentationTimestampInSeconds = adjusted.presentationTimestamp;
+  decodeTimestampInSeconds = adjusted.decodeTimestamp;
+  if (meta?.decoderConfig) {
+    if (track.info.decoderConfig === null) {
+      track.info.decoderConfig = meta.decoderConfig;
+    } else {
+      Object.assign(track.info.decoderConfig, meta.decoderConfig);
+    }
+  }
+  let sample = {
+    presentationTimestamp: presentationTimestampInSeconds,
+    decodeTimestamp: decodeTimestampInSeconds,
+    duration: durationInSeconds,
+    data,
+    size: data.byteLength,
+    type,
+    // Will be refined once the next sample comes in
+    timescaleUnitsToNextSample: intoTimescale(durationInSeconds, track.timescale)
+  };
+  return sample;
+};
+_addSampleToTrack = /* @__PURE__ */ new WeakSet();
+addSampleToTrack_fn = function(track, sample) {
+  if (__privateGet(this, _options).fastStart !== "fragmented") {
+    track.samples.push(sample);
+  }
+  const sampleCompositionTimeOffset = intoTimescale(sample.presentationTimestamp - sample.decodeTimestamp, track.timescale);
+  if (track.lastTimescaleUnits !== null) {
+    let timescaleUnits = intoTimescale(sample.decodeTimestamp, track.timescale, false);
+    let delta = Math.round(timescaleUnits - track.lastTimescaleUnits);
+    track.lastTimescaleUnits += delta;
+    track.lastSample.timescaleUnitsToNextSample = delta;
+    if (__privateGet(this, _options).fastStart !== "fragmented") {
+      let lastTableEntry = last(track.timeToSampleTable);
+      if (lastTableEntry.sampleCount === 1) {
+        lastTableEntry.sampleDelta = delta;
+        lastTableEntry.sampleCount++;
+      } else if (lastTableEntry.sampleDelta === delta) {
+        lastTableEntry.sampleCount++;
+      } else {
+        lastTableEntry.sampleCount--;
+        track.timeToSampleTable.push({
+          sampleCount: 2,
+          sampleDelta: delta
+        });
+      }
+      const lastCompositionTimeOffsetTableEntry = last(track.compositionTimeOffsetTable);
+      if (lastCompositionTimeOffsetTableEntry.sampleCompositionTimeOffset === sampleCompositionTimeOffset) {
+        lastCompositionTimeOffsetTableEntry.sampleCount++;
+      } else {
+        track.compositionTimeOffsetTable.push({
+          sampleCount: 1,
+          sampleCompositionTimeOffset
+        });
+      }
+    }
+  } else {
+    track.lastTimescaleUnits = 0;
+    if (__privateGet(this, _options).fastStart !== "fragmented") {
+      track.timeToSampleTable.push({
+        sampleCount: 1,
+        sampleDelta: intoTimescale(sample.duration, track.timescale)
+      });
+      track.compositionTimeOffsetTable.push({
+        sampleCount: 1,
+        sampleCompositionTimeOffset
+      });
+    }
+  }
+  track.lastSample = sample;
+  let beginNewChunk = false;
+  if (!track.currentChunk) {
+    beginNewChunk = true;
+  } else {
+    let currentChunkDuration = sample.presentationTimestamp - track.currentChunk.startTimestamp;
+    if (__privateGet(this, _options).fastStart === "fragmented") {
+      let mostImportantTrack = __privateGet(this, _videoTrack) ?? __privateGet(this, _audioTrack);
+      const chunkDuration = __privateGet(this, _options).minFragmentDuration ?? 1;
+      if (track === mostImportantTrack && sample.type === "key" && currentChunkDuration >= chunkDuration) {
+        beginNewChunk = true;
+        __privateMethod(this, _finalizeFragment, finalizeFragment_fn).call(this);
+      }
+    } else {
+      beginNewChunk = currentChunkDuration >= 0.5;
+    }
+  }
+  if (beginNewChunk) {
+    if (track.currentChunk) {
+      __privateMethod(this, _finalizeCurrentChunk, finalizeCurrentChunk_fn).call(this, track);
+    }
+    track.currentChunk = {
+      startTimestamp: sample.presentationTimestamp,
+      samples: []
+    };
+  }
+  track.currentChunk.samples.push(sample);
+};
+_validateTimestamp = /* @__PURE__ */ new WeakSet();
+validateTimestamp_fn = function(presentationTimestamp, decodeTimestamp, track) {
+  const strictTimestampBehavior = __privateGet(this, _options).firstTimestampBehavior === "strict";
+  const noLastDecodeTimestamp = track.lastDecodeTimestamp === -1;
+  const timestampNonZero = decodeTimestamp !== 0;
+  if (strictTimestampBehavior && noLastDecodeTimestamp && timestampNonZero) {
+    throw new Error(
+      `The first chunk for your media track must have a timestamp of 0 (received DTS=${decodeTimestamp}).Non-zero first timestamps are often caused by directly piping frames or audio data from a MediaStreamTrack into the encoder. Their timestamps are typically relative to the age of thedocument, which is probably what you want.
+
+If you want to offset all timestamps of a track such that the first one is zero, set firstTimestampBehavior: 'offset' in the options.
+`
+    );
+  } else if (__privateGet(this, _options).firstTimestampBehavior === "offset" || __privateGet(this, _options).firstTimestampBehavior === "cross-track-offset") {
+    if (track.firstDecodeTimestamp === void 0) {
+      track.firstDecodeTimestamp = decodeTimestamp;
+    }
+    let baseDecodeTimestamp;
+    if (__privateGet(this, _options).firstTimestampBehavior === "offset") {
+      baseDecodeTimestamp = track.firstDecodeTimestamp;
+    } else {
+      baseDecodeTimestamp = Math.min(
+        __privateGet(this, _videoTrack)?.firstDecodeTimestamp ?? Infinity,
+        __privateGet(this, _audioTrack)?.firstDecodeTimestamp ?? Infinity
+      );
+    }
+    decodeTimestamp -= baseDecodeTimestamp;
+    presentationTimestamp -= baseDecodeTimestamp;
+  }
+  if (decodeTimestamp < track.lastDecodeTimestamp) {
+    throw new Error(
+      `Timestamps must be monotonically increasing (DTS went from ${track.lastDecodeTimestamp * 1e6} to ${decodeTimestamp * 1e6}).`
+    );
+  }
+  track.lastDecodeTimestamp = decodeTimestamp;
+  return { presentationTimestamp, decodeTimestamp };
+};
+_finalizeCurrentChunk = /* @__PURE__ */ new WeakSet();
+finalizeCurrentChunk_fn = function(track) {
+  if (__privateGet(this, _options).fastStart === "fragmented") {
+    throw new Error("Can't finalize individual chunks if 'fastStart' is set to 'fragmented'.");
+  }
+  if (!track.currentChunk)
+    return;
+  track.finalizedChunks.push(track.currentChunk);
+  __privateGet(this, _finalizedChunks).push(track.currentChunk);
+  if (track.compactlyCodedChunkTable.length === 0 || last(track.compactlyCodedChunkTable).samplesPerChunk !== track.currentChunk.samples.length) {
+    track.compactlyCodedChunkTable.push({
+      firstChunk: track.finalizedChunks.length,
+      // 1-indexed
+      samplesPerChunk: track.currentChunk.samples.length
+    });
+  }
+  if (__privateGet(this, _options).fastStart === "in-memory") {
+    track.currentChunk.offset = 0;
+    return;
+  }
+  track.currentChunk.offset = __privateGet(this, _writer).pos;
+  for (let sample of track.currentChunk.samples) {
+    __privateGet(this, _writer).write(sample.data);
+    sample.data = null;
+  }
+  __privateMethod(this, _maybeFlushStreamingTargetWriter, maybeFlushStreamingTargetWriter_fn).call(this);
+};
+_finalizeFragment = /* @__PURE__ */ new WeakSet();
+finalizeFragment_fn = function(flushStreamingWriter = true) {
+  if (__privateGet(this, _options).fastStart !== "fragmented") {
+    throw new Error("Can't finalize a fragment unless 'fastStart' is set to 'fragmented'.");
+  }
+  let tracks = [__privateGet(this, _videoTrack), __privateGet(this, _audioTrack)].filter((track) => track && track.currentChunk);
+  if (tracks.length === 0)
+    return;
+  let fragmentNumber = __privateWrapper(this, _nextFragmentNumber)._++;
+  if (fragmentNumber === 1) {
+    let movieBox = moov(tracks, __privateGet(this, _creationTime), true);
+    __privateGet(this, _writer).writeBox(movieBox);
+  }
+  let moofOffset = __privateGet(this, _writer).pos;
+  let moofBox = moof(fragmentNumber, tracks);
+  __privateGet(this, _writer).writeBox(moofBox);
+  {
+    let mdatBox = mdat(false);
+    let totalTrackSampleSize = 0;
+    for (let track of tracks) {
+      for (let sample of track.currentChunk.samples) {
+        totalTrackSampleSize += sample.size;
+      }
+    }
+    let mdatSize = __privateGet(this, _writer).measureBox(mdatBox) + totalTrackSampleSize;
+    if (mdatSize >= 2 ** 32) {
+      mdatBox.largeSize = true;
+      mdatSize = __privateGet(this, _writer).measureBox(mdatBox) + totalTrackSampleSize;
+    }
+    mdatBox.size = mdatSize;
+    __privateGet(this, _writer).writeBox(mdatBox);
+  }
+  for (let track of tracks) {
+    track.currentChunk.offset = __privateGet(this, _writer).pos;
+    track.currentChunk.moofOffset = moofOffset;
+    for (let sample of track.currentChunk.samples) {
+      __privateGet(this, _writer).write(sample.data);
+      sample.data = null;
+    }
+  }
+  let endPos = __privateGet(this, _writer).pos;
+  __privateGet(this, _writer).seek(__privateGet(this, _writer).offsets.get(moofBox));
+  let newMoofBox = moof(fragmentNumber, tracks);
+  __privateGet(this, _writer).writeBox(newMoofBox);
+  __privateGet(this, _writer).seek(endPos);
+  for (let track of tracks) {
+    track.finalizedChunks.push(track.currentChunk);
+    __privateGet(this, _finalizedChunks).push(track.currentChunk);
+    track.currentChunk = null;
+  }
+  if (flushStreamingWriter) {
+    __privateMethod(this, _maybeFlushStreamingTargetWriter, maybeFlushStreamingTargetWriter_fn).call(this);
+  }
+};
+_maybeFlushStreamingTargetWriter = /* @__PURE__ */ new WeakSet();
+maybeFlushStreamingTargetWriter_fn = function() {
+  if (__privateGet(this, _writer) instanceof StreamTargetWriter) {
+    __privateGet(this, _writer).flush();
+  }
+};
+_ensureNotFinalized = /* @__PURE__ */ new WeakSet();
+ensureNotFinalized_fn = function() {
+  if (__privateGet(this, _finalized)) {
+    throw new Error("Cannot add new video or audio chunks after the file has been finalized.");
+  }
+};
+const CANVAS_WIDTH = 1280;
+const CANVAS_HEIGHT = 720;
+function isWebCodecsSupported() {
+  return typeof VideoEncoder !== "undefined" && typeof VideoFrame !== "undefined";
+}
+function createVideoRenderer(options) {
+  const { scene, timeline, fps, bitrate, scale, onProgress } = options;
+  let cancelled = false;
+  let encoder = null;
+  let muxer = null;
+  let encoderError = null;
+  return {
+    async start() {
+      if (!isWebCodecsSupported()) {
+        throw new Error("WebCodecs is not supported in this browser. Please use Chrome, Edge, or Opera.");
+      }
+      const duration = timeline.duration;
+      const totalFrames = Math.ceil(duration / 1e3 * fps);
+      const frameDurationUs = 1e6 / fps;
+      const videoWidth = CANVAS_WIDTH * scale;
+      const videoHeight = CANVAS_HEIGHT * scale;
+      const canvas = document.createElement("canvas");
+      canvas.width = videoWidth;
+      canvas.height = videoHeight;
+      const ctx = canvas.getContext("2d");
+      const animCtx = new AnimCtxImpl();
+      muxer = new Muxer({
+        target: new ArrayBufferTarget(),
+        video: {
+          codec: "avc",
+          width: videoWidth,
+          height: videoHeight
+        },
+        fastStart: "in-memory"
+      });
+      encoder = new VideoEncoder({
+        output: (chunk, meta) => {
+          if (cancelled || !muxer) return;
+          muxer.addVideoChunk(chunk, meta);
+        },
+        error: (e) => {
+          console.error("VideoEncoder error:", e);
+          encoderError = e;
+        }
+      });
+      encoder.configure({
+        codec: "avc1.640032",
+        // H.264 High Profile Level 5.1 (supports up to 4K)
+        width: videoWidth,
+        height: videoHeight,
+        bitrate,
+        framerate: fps
+      });
+      for (let frame = 0; frame < totalFrames && !cancelled && !encoderError; frame++) {
+        const timeMs = frame / fps * 1e3;
+        animCtx.reset(scene);
+        timeline.evaluate(timeMs, animCtx);
+        const solved = animCtx.solve(scene);
+        ctx.fillStyle = "#ffffff";
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
+        scene.render(solved, canvas, scale);
+        const videoFrame = new VideoFrame(canvas, {
+          timestamp: frame * frameDurationUs
+        });
+        const keyFrame = frame % fps === 0;
+        encoder.encode(videoFrame, { keyFrame });
+        videoFrame.close();
+        onProgress((frame + 1) / totalFrames, frame + 1, totalFrames);
+        if (frame % 5 === 0) {
+          await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+      }
+      if (encoderError) {
+        throw encoderError;
+      }
+      if (cancelled) {
+        encoder.close();
+        throw new Error("Rendering cancelled");
+      }
+      await encoder.flush();
+      encoder.close();
+      encoder = null;
+      if (cancelled || !muxer) {
+        throw new Error("Rendering cancelled");
+      }
+      muxer.finalize();
+      const buffer = muxer.target.buffer;
+      muxer = null;
+      const blob = new Blob([buffer], { type: "video/mp4" });
+      return {
+        blob,
+        duration,
+        frames: totalFrames
+      };
+    },
+    cancel() {
+      cancelled = true;
+      if (encoder && encoder.state !== "closed") {
+        encoder.close();
+      }
+    }
+  };
+}
+function downloadBlob(blob, filename) {
+  const url2 = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url2;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url2);
+}
+export {
+  Screen as S,
+  Vec as V,
+  isExpr as a,
+  angle as b,
+  createVideoRenderer as c,
+  isWebCodecsSupported as d,
+  downloadBlob as e,
+  isGroup as i,
+  lerp as l,
+  makePlayer as m,
+  vec as v
+};
+//# sourceMappingURL=video-renderer-Buv1c43x.js.map