@pixerate/editor 0.115.0 → 0.117.0

package/dist/chunk-SMJGE7HM.cjs

@@ -0,0 +1,1908 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/video-editor/types.ts
+var VIDEO_FITS = ["contain", "cover", "fill", "none"];
+var VIDEO_TRANSITION_TYPES = ["crossfade", "dip", "wipe", "push", "slide", "iris"];
+var VIDEO_WIPE_DIRECTIONS = ["left", "right", "up", "down"];
+var videoTransitionAudioCurve = (t) => _nullishCoalesce(t.audioCurve, () => ( (t.type === "dip" ? "linear" : "equal-power")));
+var VIDEO_BLEND_MODES = ["normal", "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn", "hard-light", "soft-light", "difference", "exclusion", "add"];
+var VIDEO_CLIP_ANIMATION_EFFECTS = ["fade", "rise", "drop", "slide-left", "slide-right", "zoom", "pop"];
+var VIDEO_FADE_CURVES = ["linear", "equal-power", "s-curve", "exponential", "logarithmic"];
+var VIDEO_PLACEMENT_MODES = ["refuse", "overwrite", "insert"];
+var VIDEO_CLIP_TYPES = ["media", "text", "color", "sequence"];
+
+// src/video-editor/keyframes.ts
+var VIDEO_EASE_NAMES = ["linear", "hold", "ease-in", "ease-out", "ease-in-out"];
+var VIDEO_KEYFRAME_PROPERTIES = ["opacity", "volume", "x", "y", "scale", "rotation"];
+var VIDEO_TRANSFORM_PROPERTIES = ["x", "y", "scale", "rotation"];
+var VIDEO_KEYFRAME_LIMITS = {
+  opacity: { default: 1, min: 0, max: 1 },
+  volume: { default: 1, min: 0, max: 4 },
+  x: { default: 0 },
+  y: { default: 0 },
+  scale: { default: 1, min: 0 },
+  rotation: { default: 0 }
+};
+var NAMED = {
+  "ease-in": [0.42, 0, 1, 1],
+  "ease-out": [0, 0, 0.58, 1],
+  "ease-in-out": [0.42, 0, 0.58, 1]
+};
+var isVideoKeyframes = (v) => typeof v === "object" && v !== null && Array.isArray(v.keys);
+function videoEaseBezier(ease) {
+  if (ease === void 0 || ease === "linear" || ease === "hold") return null;
+  return Array.isArray(ease) ? ease : NAMED[ease];
+}
+var bez = (a, b, s) => 3 * a * (1 - s) * (1 - s) * s + 3 * b * (1 - s) * s * s + s * s * s;
+var bezSlope = (a, b, s) => 3 * a * (1 - s) * (1 - s) + 6 * (b - a) * (1 - s) * s + 3 * (1 - b) * s * s;
+function bezierParam(x1, x2, x) {
+  let s = x;
+  for (let i = 0; i < 8; i++) {
+    const err = bez(x1, x2, s) - x;
+    if (Math.abs(err) < 1e-7) return s;
+    const d = bezSlope(x1, x2, s);
+    if (Math.abs(d) < 1e-6) break;
+    s -= err / d;
+    if (s < 0 || s > 1) break;
+  }
+  let lo = 0;
+  let hi = 1;
+  s = x;
+  for (let i = 0; i < 60; i++) {
+    const v = bez(x1, x2, s);
+    if (Math.abs(v - x) < 1e-9) break;
+    if (v < x) lo = s;
+    else hi = s;
+    s = (lo + hi) / 2;
+  }
+  return s;
+}
+function videoEaseProgress(ease, p) {
+  if (p <= 0) return 0;
+  if (p >= 1) return ease === "hold" ? 0 : 1;
+  if (ease === "hold") return 0;
+  const b = videoEaseBezier(ease);
+  if (!b) return p;
+  return bez(b[1], b[3], bezierParam(b[0], b[2], p));
+}
+function keyBefore(keys, t) {
+  let lo = 0;
+  let hi = keys.length - 1;
+  if (t < keys[0].t) return -1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (keys[mid].t <= t) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo;
+}
+function videoValueAt(prop, clipTime, fallback = 0) {
+  if (prop === void 0) return fallback;
+  if (typeof prop === "number") return prop;
+  const { keys } = prop;
+  if (!keys.length) return fallback;
+  const i = keyBefore(keys, clipTime);
+  if (i < 0) return keys[0].v;
+  if (i >= keys.length - 1) return keys[keys.length - 1].v;
+  const a = keys[i];
+  const b = keys[i + 1];
+  if (a.ease === "hold") return a.v;
+  return a.v + (b.v - a.v) * videoEaseProgress(a.ease, (clipTime - a.t) / (b.t - a.t));
+}
+var videoKeysOf = (prop) => isVideoKeyframes(prop) ? prop.keys : [];
+function retimeVideoAnimatable(prop, dt, k = 1) {
+  if (!isVideoKeyframes(prop)) return prop;
+  return { keys: prop.keys.map((key) => ({ ...key, t: key.t * k + dt })) };
+}
+function splitEase(ease, p) {
+  if (ease === "hold") return ["hold", "hold"];
+  const b = videoEaseBezier(ease);
+  if (!b) return [ease, ease];
+  const s = bezierParam(b[0], b[2], p);
+  const lerp = (u, v, k) => [u[0] + (v[0] - u[0]) * k, u[1] + (v[1] - u[1]) * k];
+  const P0 = [0, 0];
+  const P1 = [b[0], b[1]];
+  const P2 = [b[2], b[3]];
+  const P3 = [1, 1];
+  const A = lerp(P0, P1, s);
+  const B = lerp(P1, P2, s);
+  const C = lerp(P2, P3, s);
+  const AB = lerp(A, B, s);
+  const BC = lerp(B, C, s);
+  const M = lerp(AB, BC, s);
+  const r = (v) => Math.round(v * 1e6) / 1e6;
+  const left = Math.abs(M[1]) < 1e-9 ? "linear" : [r(A[0] / M[0]), r(A[1] / M[1]), r(AB[0] / M[0]), r(AB[1] / M[1])];
+  const dx = 1 - M[0];
+  const dy = 1 - M[1];
+  const right = Math.abs(dy) < 1e-9 ? "linear" : [r((BC[0] - M[0]) / dx), r((BC[1] - M[1]) / dy), r((C[0] - M[0]) / dx), r((C[1] - M[1]) / dy)];
+  return [left, right];
+}
+function splitVideoAnimatable(prop, at) {
+  if (!isVideoKeyframes(prop)) return [prop, prop];
+  const keys = prop.keys;
+  const eps = 1e-6;
+  const v = videoValueAt(prop, at);
+  const i = keyBefore(keys, at);
+  const exact = i >= 0 && Math.abs(keys[i].t - at) < eps;
+  let leftEase;
+  let rightEase;
+  if (exact) rightEase = keys[i].ease;
+  else if (i >= 0 && i < keys.length - 1) {
+    const a = keys[i];
+    [leftEase, rightEase] = splitEase(a.ease, (at - a.t) / (keys[i + 1].t - a.t));
+  }
+  const before = keys.slice(0, exact ? i : i + 1).map((k) => ({ ...k }));
+  if (before.length && leftEase !== void 0) before[before.length - 1] = withEase(before[before.length - 1], leftEase);
+  const left = [...before, { t: at, v }];
+  const right = [withEase({ t: 0, v }, rightEase), ...keys.slice(i + 1).map((k) => ({ ...k, t: k.t - at }))];
+  return [{ keys: left }, { keys: right }];
+}
+var withEase = (key, ease) => {
+  const { ease: _old, ...rest } = key;
+  return ease === void 0 || ease === "linear" ? rest : { ...rest, ease };
+};
+function sortVideoKeys(keys) {
+  const sorted = [...keys].sort((a, b) => a.t - b.t);
+  for (let i = 1; i < sorted.length; i++) if (Math.abs(sorted[i].t - sorted[i - 1].t) < 1e-6) throw new Error(`Two keys are at ${sorted[i].t} ms; give each key its own time.`);
+  return sorted;
+}
+function setVideoKey(prop, key, fallback) {
+  const keys = isVideoKeyframes(prop) ? prop.keys.filter((k) => Math.abs(k.t - key.t) >= 1e-6) : [];
+  if (!isVideoKeyframes(prop)) {
+    const v = _nullishCoalesce(prop, () => ( fallback));
+    if (key.t !== 0) keys.push({ t: 0, v });
+  }
+  return { keys: sortVideoKeys([...keys, key]) };
+}
+function removeVideoKey(prop, t) {
+  const keys = prop.keys.filter((k) => Math.abs(k.t - t) >= 1e-6);
+  return keys.length ? { keys } : prop.keys[0].v;
+}
+var fmt = (v) => {
+  const r = Math.round(v * 1e4) / 1e4;
+  return Object.is(r, -0) ? "0" : String(r);
+};
+var signed = (v) => fmt(v).startsWith("-") ? fmt(v) : `+${fmt(v)}`;
+function videoKeyframeBreakpoints(prop, step) {
+  const { keys } = prop;
+  const points = [];
+  const holds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < keys.length; i++) {
+    const a = keys[i];
+    points.push([a.t, a.v]);
+    const b = keys[i + 1];
+    if (!b) break;
+    if (a.ease === "hold") {
+      holds.add(points.length - 1);
+      continue;
+    }
+    if (!videoEaseBezier(a.ease)) continue;
+    const n2 = Math.max(1, Math.ceil((b.t - a.t) / step));
+    for (let k = 1; k < n2; k++) {
+      const t = a.t + (b.t - a.t) * k / n2;
+      points.push([t, videoValueAt(prop, t)]);
+    }
+  }
+  return { points, holds };
+}
+function videoKeyframeFfmpegExpr(prop, time, fallback, step) {
+  if (!isVideoKeyframes(prop)) return fmt(_nullishCoalesce(prop, () => ( fallback)));
+  const { points, holds } = videoKeyframeBreakpoints(prop, step);
+  if (points.length === 1 || points.every(([, v]) => v === points[0][1])) return fmt(points[0][1]);
+  let expr = fmt(points[points.length - 1][1]);
+  for (let i = points.length - 2; i >= 0; i--) {
+    const [t0, v0] = points[i];
+    const [t1, v1] = points[i + 1];
+    const seg = holds.has(i) || v0 === v1 ? fmt(v0) : `${fmt(v0)}${signed((v1 - v0) / (t1 - t0))}*(${time}${signed(-t0)})`;
+    expr = `if(lt(${time},${fmt(t1)}),${seg},${expr})`;
+  }
+  return `if(lt(${time},${fmt(points[0][0])}),${fmt(points[0][1])},${expr})`;
+}
+
+// src/video-editor/lut.ts
+var VIDEO_LUT_MAX_SIZE = 129;
+function parseVideoCubeLut(text) {
+  let size = 0;
+  let size1 = 0;
+  let title;
+  const domainMin = [0, 0, 0];
+  const domainMax = [1, 1, 1];
+  let data = null;
+  let rows = 0;
+  const lines = text.split(/\r\n|\r|\n/);
+  const fail = (line, message) => {
+    throw new Error(`Line ${line + 1} of the .cube file: ${message}.`);
+  };
+  const numbers = (parts, line) => parts.map((p) => {
+    const v = Number(p);
+    if (!Number.isFinite(v)) fail(line, `"${p}" is not a number`);
+    return v;
+  });
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].replace(/#.*/, "").trim();
+    if (!line) continue;
+    const parts = line.split(/\s+/);
+    const key = parts[0];
+    if (/^[A-Za-z]/.test(key)) {
+      if (rows) fail(i, `"${key}" comes after the table; keywords go before it`);
+      if (key === "TITLE") title = line.slice(5).trim().replace(/^"|"$/g, "");
+      else if (key === "LUT_3D_SIZE") {
+        size = Number(parts[1]);
+        if (!Number.isInteger(size) || size < 2 || size > VIDEO_LUT_MAX_SIZE) fail(i, `LUT_3D_SIZE must be a whole number from 2 to ${VIDEO_LUT_MAX_SIZE}, not "${_nullishCoalesce(parts[1], () => ( ""))}"`);
+      } else if (key === "LUT_1D_SIZE") size1 = Number(parts[1]) || 1;
+      else if (key === "DOMAIN_MIN" || key === "DOMAIN_MAX") {
+        const v2 = numbers(parts.slice(1), i);
+        if (v2.length !== 3) fail(i, `${key} needs 3 numbers`);
+        (key === "DOMAIN_MIN" ? domainMin : domainMax).splice(0, 3, ...v2);
+      } else if (key === "LUT_3D_INPUT_RANGE") {
+        const v2 = numbers(parts.slice(1), i);
+        if (v2.length !== 2 || !(v2[1] > v2[0])) fail(i, "LUT_3D_INPUT_RANGE needs a minimum and a larger maximum");
+        domainMin.fill(v2[0]);
+        domainMax.fill(v2[1]);
+      }
+      continue;
+    }
+    if (!size) fail(i, size1 ? "this is a 1D LUT (LUT_1D_SIZE); only 3D LUTs (LUT_3D_SIZE) are supported" : "the table starts before LUT_3D_SIZE");
+    data ??= new Float32Array(size * size * size * 3);
+    const v = numbers(parts, i);
+    if (v.length !== 3) fail(i, `a table row needs 3 numbers, not ${v.length}`);
+    if (rows >= size ** 3) fail(i, `the table has more than the ${size ** 3} rows LUT_3D_SIZE ${size} needs`);
+    data.set(v, rows * 3);
+    rows++;
+  }
+  if (!size) throw new Error(size1 ? "The .cube file is a 1D LUT (LUT_1D_SIZE); only 3D LUTs (LUT_3D_SIZE) are supported." : "The .cube file has no LUT_3D_SIZE line, so it is not a 3D LUT.");
+  if (rows !== size ** 3) throw new Error(`The .cube file has ${rows} table rows; LUT_3D_SIZE ${size} needs ${size ** 3}.`);
+  for (let c = 0; c < 3; c++) if (!(domainMax[c] > domainMin[c])) throw new Error("The .cube file's DOMAIN_MAX must be larger than its DOMAIN_MIN on every channel.");
+  return { ...title ? { title } : {}, size, domainMin, domainMax, data };
+}
+function videoLutFromFunction(size, fn, title) {
+  const n2 = size - 1;
+  const data = new Float32Array(size ** 3 * 3);
+  let i = 0;
+  for (let b = 0; b < size; b++)
+    for (let g = 0; g < size; g++)
+      for (let r = 0; r < size; r++) {
+        data.set(fn([r / n2, g / n2, b / n2]), i);
+        i += 3;
+      }
+  return { ...title ? { title } : {}, size, domainMin: [0, 0, 0], domainMax: [1, 1, 1], data };
+}
+function videoLutToCube(lut) {
+  const f = (v) => (Math.round(v * 1e6) / 1e6).toString();
+  const head = [...lut.title ? [`TITLE "${lut.title.replace(/"/g, "'")}"`] : [], `LUT_3D_SIZE ${lut.size}`];
+  if (lut.domainMin.some((v) => v !== 0) || lut.domainMax.some((v) => v !== 1)) head.push(`DOMAIN_MIN ${lut.domainMin.map(f).join(" ")}`, `DOMAIN_MAX ${lut.domainMax.map(f).join(" ")}`);
+  const rows = [];
+  for (let i = 0; i < lut.data.length; i += 3) rows.push(`${f(lut.data[i])} ${f(lut.data[i + 1])} ${f(lut.data[i + 2])}`);
+  return `${head.join("\n")}
+${rows.join("\n")}
+`;
+}
+var clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function applyVideoLut(lut, rgb, out = [0, 0, 0]) {
+  const { size, data, domainMin, domainMax } = lut;
+  const n2 = size - 1;
+  const x = clamp01((rgb[0] - domainMin[0]) / (domainMax[0] - domainMin[0])) * n2;
+  const y = clamp01((rgb[1] - domainMin[1]) / (domainMax[1] - domainMin[1])) * n2;
+  const z = clamp01((rgb[2] - domainMin[2]) / (domainMax[2] - domainMin[2])) * n2;
+  const r0 = Math.min(n2 - 1, Math.floor(x));
+  const g0 = Math.min(n2 - 1, Math.floor(y));
+  const b0 = Math.min(n2 - 1, Math.floor(z));
+  const fr = x - r0;
+  const fg = y - g0;
+  const fb = z - b0;
+  const sr = 3;
+  const sg = 3 * size;
+  const sb = 3 * size * size;
+  const o = r0 * sr + g0 * sg + b0 * sb;
+  let a, c, w0, w1, w2, w3;
+  if (fr > fg) {
+    if (fg > fb) [a, c, w0, w1, w2, w3] = [sr, sr + sg, 1 - fr, fr - fg, fg - fb, fb];
+    else if (fr > fb) [a, c, w0, w1, w2, w3] = [sr, sr + sb, 1 - fr, fr - fb, fb - fg, fg];
+    else [a, c, w0, w1, w2, w3] = [sb, sb + sr, 1 - fb, fb - fr, fr - fg, fg];
+  } else if (fb > fg) [a, c, w0, w1, w2, w3] = [sb, sb + sg, 1 - fb, fb - fg, fg - fr, fr];
+  else if (fb > fr) [a, c, w0, w1, w2, w3] = [sg, sg + sb, 1 - fg, fg - fb, fb - fr, fr];
+  else [a, c, w0, w1, w2, w3] = [sg, sg + sr, 1 - fg, fg - fr, fr - fb, fb];
+  const d = sr + sg + sb;
+  for (let k = 0; k < 3; k++) out[k] = clamp01(w0 * data[o + k] + w1 * data[o + a + k] + w2 * data[o + c + k] + w3 * data[o + d + k]);
+  return out;
+}
+function applyVideoLutToPixels(lut, data, strength = 1) {
+  const s = clamp01(strength);
+  if (!s) return;
+  const rgb = [0, 0, 0];
+  const out = [0, 0, 0];
+  for (let i = 0; i < data.length; i += 4) {
+    if (!data[i + 3]) continue;
+    rgb[0] = data[i] / 255;
+    rgb[1] = data[i + 1] / 255;
+    rgb[2] = data[i + 2] / 255;
+    applyVideoLut(lut, rgb, out);
+    for (let k = 0; k < 3; k++) data[i + k] = Math.round((rgb[k] + (out[k] - rgb[k]) * s) * 255);
+  }
+}
+var approximations = /* @__PURE__ */ new WeakMap();
+function videoLutSvgApproximation(lut) {
+  const cached = approximations.get(lut);
+  if (cached) return cached;
+  const points = 17;
+  const tables = [[], [], []];
+  for (let i = 0; i < points; i++) {
+    const v = i / (points - 1);
+    const out = applyVideoLut(lut, [v, v, v]);
+    for (let k = 0; k < 3; k++) tables[k].push(out[k]);
+  }
+  const curve = (k, v) => {
+    const x = clamp01(v) * (points - 1);
+    const i = Math.min(points - 2, Math.floor(x));
+    return tables[k][i] + (tables[k][i + 1] - tables[k][i]) * (x - i);
+  };
+  const ata = Array.from({ length: 4 }, () => [0, 0, 0, 0]);
+  const atb = Array.from({ length: 3 }, () => [0, 0, 0, 0]);
+  const grid = 9;
+  for (let b = 0; b < grid; b++)
+    for (let g = 0; g < grid; g++)
+      for (let r = 0; r < grid; r++) {
+        const x = [r / (grid - 1), g / (grid - 1), b / (grid - 1)];
+        const z = [curve(0, x[0]), curve(1, x[1]), curve(2, x[2]), 1];
+        const y = applyVideoLut(lut, x);
+        for (let i = 0; i < 4; i++) {
+          for (let j = 0; j < 4; j++) ata[i][j] += z[i] * z[j];
+          for (let k = 0; k < 3; k++) atb[k][i] += z[i] * y[k];
+        }
+      }
+  const matrix = atb.map((rhs) => solve4(ata, rhs));
+  const result = { tables, matrix };
+  approximations.set(lut, result);
+  return result;
+}
+function solve4(a, b) {
+  const m = a.map((row, i) => [...row, b[i]]);
+  for (let col = 0; col < 4; col++) {
+    let pivot = col;
+    for (let r = col + 1; r < 4; r++) if (Math.abs(m[r][col]) > Math.abs(m[pivot][col])) pivot = r;
+    if (Math.abs(m[pivot][col]) < 1e-12) continue;
+    [m[col], m[pivot]] = [m[pivot], m[col]];
+    for (let r = 0; r < 4; r++) {
+      if (r === col) continue;
+      const f = m[r][col] / m[col][col];
+      for (let c = col; c < 5; c++) m[r][c] -= f * m[col][c];
+    }
+  }
+  return m.map((row, i) => Math.abs(row[i]) < 1e-12 ? 0 : row[4] / row[i]);
+}
+var VideoLutCache = (_class = class {
+  constructor(loader = async (src) => {
+    const res = await fetch(src);
+    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`.trim());
+    return res.text();
+  }) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
+    this.loader = loader;
+  }
+  
+  __init() {this.ready = /* @__PURE__ */ new Map()}
+  __init2() {this.pending = /* @__PURE__ */ new Map()}
+  __init3() {this.failed = /* @__PURE__ */ new Map()}
+  __init4() {this.listeners = /* @__PURE__ */ new Set()}
+  /** The LUT if loaded, without starting to load it. */
+  peek(src) {
+    return this.ready.get(src);
+  }
+  /** The LUT if loaded; otherwise `undefined`, and loading starts (once) unless it failed. */
+  get(src) {
+    const lut = this.ready.get(src);
+    if (!lut && !this.failed.has(src)) void this.load(src).catch(() => {
+    });
+    return lut;
+  }
+  /** Why loading a LUT failed, if it did. */
+  error(src) {
+    return this.failed.get(src);
+  }
+  /** The LUT, loading and reading it if needed. Rejects with a readable error. */
+  load(src) {
+    const ready = this.ready.get(src);
+    if (ready) return Promise.resolve(ready);
+    const failed = this.failed.get(src);
+    if (failed) return Promise.reject(new Error(failed));
+    let pending = this.pending.get(src);
+    if (!pending) {
+      pending = Promise.resolve().then(() => this.loader(src)).then((v) => typeof v === "string" ? parseVideoCubeLut(v) : v).then(
+        (lut) => {
+          this.pending.delete(src);
+          this.ready.set(src, lut);
+          this.emit();
+          return lut;
+        },
+        (e) => {
+          this.pending.delete(src);
+          const message = `The LUT "${src}" could not be read: ${e instanceof Error ? e.message : String(e)}`;
+          this.failed.set(src, message);
+          this.emit();
+          throw new Error(message);
+        }
+      );
+      this.pending.set(src, pending);
+    }
+    return pending;
+  }
+  /** Uses a LUT the host already has (`.cube` text or a parsed LUT), under `src`. */
+  set(src, lut) {
+    const parsed = typeof lut === "string" ? parseVideoCubeLut(lut) : lut;
+    this.ready.set(src, parsed);
+    this.failed.delete(src);
+    this.emit();
+    return parsed;
+  }
+  /** Forgets a failure so the next `get` tries again. */
+  retry(src) {
+    if (this.failed.delete(src)) this.emit();
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => {
+      this.listeners.delete(fn);
+    };
+  }
+  emit() {
+    for (const l of [...this.listeners]) l();
+  }
+}, _class);
+
+// src/video-editor/grade.ts
+var VIDEO_GRADE_CONTROLS = [
+  { key: "exposure", label: "Exposure", min: -3, max: 3, step: 0.1, description: "Exposure in stops: +1 doubles every channel, -1 halves it (default 0)." },
+  { key: "contrast", label: "Contrast", min: -1, max: 1, step: 0.05, description: "Contrast around mid grey, -1 (flat grey) to 1 (twice as steep); default 0." },
+  { key: "saturation", label: "Saturation", min: -1, max: 1, step: 0.05, description: "Saturation, -1 (black and white) to 1 (twice as saturated); default 0." },
+  { key: "hue", label: "Hue", min: -180, max: 180, step: 1, description: "Hue rotation in degrees (default 0)." },
+  { key: "temperature", label: "Temperature", min: -1, max: 1, step: 0.05, description: "White balance, -1 (cool, bluer) to 1 (warm, more orange); default 0." },
+  { key: "tint", label: "Tint", min: -1, max: 1, step: 0.05, description: "White balance, -1 (greener) to 1 (more magenta); default 0." }
+];
+var VIDEO_GRADE_PRESETS = {
+  warm: { temperature: 0.4, saturation: 0.1 },
+  cool: { temperature: -0.4, tint: -0.05 },
+  punchy: { contrast: 0.25, saturation: 0.3 },
+  faded: { exposure: 0.15, contrast: -0.3, saturation: -0.3 },
+  "black-and-white": { saturation: -1, contrast: 0.15 },
+  "bleach-bypass": { saturation: -0.6, contrast: 0.4 },
+  "day-for-night": { exposure: -1.5, saturation: -0.4, temperature: -0.6 }
+};
+var VIDEO_GRADE_PRESET_NAMES = Object.keys(VIDEO_GRADE_PRESETS);
+var clampTo = (c, v) => Math.min(c.max, Math.max(c.min, v));
+function normalizeVideoGradeLut(lut) {
+  if (!lut || typeof lut.src !== "string" || !lut.src) return void 0;
+  const strength = typeof lut.strength === "number" && Number.isFinite(lut.strength) ? Math.round(Math.min(1, Math.max(0, lut.strength)) * 1e3) / 1e3 : 1;
+  if (!strength) return void 0;
+  return { src: lut.src, ...strength !== 1 ? { strength } : {}, ...lut.name ? { name: lut.name } : {} };
+}
+function normalizeVideoGrade(grade) {
+  if (!grade) return void 0;
+  const out = {};
+  for (const c of VIDEO_GRADE_CONTROLS) {
+    const v = grade[c.key];
+    if (typeof v === "number" && Number.isFinite(v) && v !== 0) out[c.key] = Math.round(clampTo(c, v) * 1e3) / 1e3;
+  }
+  const lut = normalizeVideoGradeLut(grade.lut);
+  if (lut) out.lut = lut;
+  return Object.keys(out).length ? out : void 0;
+}
+function videoGradePreset(name, amount = 1) {
+  const preset = VIDEO_GRADE_PRESETS[name];
+  if (!preset) throw new Error(`There is no grade preset "${name}"; the presets are ${VIDEO_GRADE_PRESET_NAMES.join(", ")}.`);
+  const k = Math.min(1, Math.max(0, amount));
+  return normalizeVideoGrade(Object.fromEntries(Object.entries(preset).map(([key, v]) => [key, v * k])));
+}
+function videoGradeLook(current, name, amount = 1) {
+  return normalizeVideoGrade({ ...videoGradePreset(name, amount), ..._optionalChain([current, 'optionalAccess', _2 => _2.lut]) ? { lut: current.lut } : {} });
+}
+function videoGradeSteps(grade) {
+  const g = normalizeVideoGrade(grade);
+  if (!g) return [];
+  const steps = [];
+  if (g.exposure) steps.push({ kind: "brightness", amount: 2 ** g.exposure });
+  if (g.contrast) steps.push({ kind: "contrast", amount: 1 + g.contrast });
+  if (g.saturation) steps.push({ kind: "saturate", amount: 1 + g.saturation });
+  if (g.hue) steps.push({ kind: "hue-rotate", degrees: g.hue });
+  if (g.temperature || g.tint) {
+    const t = _nullishCoalesce(g.temperature, () => ( 0));
+    steps.push({ kind: "gains", r: 1 + 0.25 * t, g: 1 - 0.25 * (_nullishCoalesce(g.tint, () => ( 0))), b: 1 - 0.25 * t });
+  }
+  return steps;
+}
+function videoGradeStepMatrix(step) {
+  switch (step.kind) {
+    case "brightness":
+      return [
+        [step.amount, 0, 0, 0],
+        [0, step.amount, 0, 0],
+        [0, 0, step.amount, 0]
+      ];
+    case "contrast": {
+      const c = step.amount;
+      const o = 0.5 - 0.5 * c;
+      return [
+        [c, 0, 0, o],
+        [0, c, 0, o],
+        [0, 0, c, o]
+      ];
+    }
+    case "gains":
+      return [
+        [step.r, 0, 0, 0],
+        [0, step.g, 0, 0],
+        [0, 0, step.b, 0]
+      ];
+    case "saturate": {
+      const s = step.amount;
+      return [
+        [0.213 + 0.787 * s, 0.715 - 0.715 * s, 0.072 - 0.072 * s, 0],
+        [0.213 - 0.213 * s, 0.715 + 0.285 * s, 0.072 - 0.072 * s, 0],
+        [0.213 - 0.213 * s, 0.715 - 0.715 * s, 0.072 + 0.928 * s, 0]
+      ];
+    }
+    case "hue-rotate": {
+      const a = step.degrees * Math.PI / 180;
+      const cos = Math.cos(a);
+      const sin = Math.sin(a);
+      return [
+        [0.213 + cos * 0.787 - sin * 0.213, 0.715 - cos * 0.715 - sin * 0.715, 0.072 - cos * 0.072 + sin * 0.928, 0],
+        [0.213 - cos * 0.213 + sin * 0.143, 0.715 + cos * 0.285 + sin * 0.14, 0.072 - cos * 0.072 - sin * 0.283, 0],
+        [0.213 - cos * 0.213 - sin * 0.787, 0.715 - cos * 0.715 + sin * 0.715, 0.072 + cos * 0.928 + sin * 0.072, 0]
+      ];
+    }
+  }
+}
+function applyVideoGrade(grade, rgb, lut) {
+  let v = rgb.map((x) => x / 255);
+  for (const step of videoGradeSteps(grade)) {
+    const m = videoGradeStepMatrix(step);
+    v = m.map((row) => Math.min(1, Math.max(0, row[0] * v[0] + row[1] * v[1] + row[2] * v[2] + row[3])));
+  }
+  const setting = normalizeVideoGradeLut(_optionalChain([grade, 'optionalAccess', _3 => _3.lut]));
+  if (setting && lut) {
+    const out = applyVideoLut(lut, v);
+    const s = _nullishCoalesce(setting.strength, () => ( 1));
+    v = v.map((x, k) => x + (out[k] - x) * s);
+  }
+  return v.map((x) => Math.round(x * 255));
+}
+var fmt2 = (v) => String(Math.round(v * 1e5) / 1e5);
+function videoGradeStepSvgValues(step) {
+  return videoGradeStepMatrix(step).map((row) => [row[0], row[1], row[2], 0, row[3]].map(fmt2).join(" ")).concat("0 0 0 1 0").join(" ");
+}
+function videoLutSvgPrimitives(lut, strength = 1) {
+  const { tables, matrix } = videoLutSvgApproximation(lut);
+  const table = (k) => tables[k].map(fmt2).join(" ");
+  const values = matrix.map((row) => [row[0], row[1], row[2], 0, row[3]].map(fmt2).join(" ")).concat("0 0 0 1 0").join(" ");
+  const s = Math.min(1, Math.max(0, strength));
+  return `<feComponentTransfer result="lutIn"><feFuncA type="identity"/></feComponentTransfer><feComponentTransfer><feFuncR type="table" tableValues="${table(0)}"/><feFuncG type="table" tableValues="${table(1)}"/><feFuncB type="table" tableValues="${table(2)}"/></feComponentTransfer><feColorMatrix type="matrix" values="${values}"/>` + (s < 1 ? `<feComposite in2="lutIn" operator="arithmetic" k1="0" k2="${fmt2(s)}" k3="${fmt2(1 - s)}" k4="0"/>` : "");
+}
+function videoGradeSvgFilter(id, grade, lut) {
+  const steps = videoGradeSteps(grade);
+  const setting = normalizeVideoGradeLut(_optionalChain([grade, 'optionalAccess', _4 => _4.lut]));
+  return `<filter id="${id}" color-interpolation-filters="sRGB" x="0" y="0" width="100%" height="100%">${steps.map((s) => `<feColorMatrix type="matrix" values="${videoGradeStepSvgValues(s)}"/>`).join("")}${setting && lut ? videoLutSvgPrimitives(lut, setting.strength) : ""}</filter>`;
+}
+var videoGradeGainsFilterId = (step) => `pixerate-wb-${[step.r, step.g, step.b].map((v) => Math.round(v * 1e3)).join("-")}`;
+function videoGradeCssFilter(grade) {
+  return videoGradeSteps(grade).map((s) => s.kind === "brightness" ? `brightness(${fmt2(s.amount)})` : s.kind === "contrast" ? `contrast(${fmt2(s.amount)})` : s.kind === "saturate" ? `saturate(${fmt2(s.amount)})` : s.kind === "hue-rotate" ? `hue-rotate(${fmt2(s.degrees)}deg)` : `url(#${videoGradeGainsFilterId(s)})`).join(" ");
+}
+function videoGradeSvgDefs(grade) {
+  return videoGradeSteps(grade).filter((s) => s.kind === "gains").map((s) => {
+    const id = videoGradeGainsFilterId(s);
+    return { id, markup: `<filter id="${id}" color-interpolation-filters="sRGB"><feColorMatrix type="matrix" values="${videoGradeStepSvgValues(s)}"/></filter>` };
+  });
+}
+function videoGradeFfmpegFilters(grade) {
+  return videoGradeSteps(grade).map((step) => {
+    const m = videoGradeStepMatrix(step);
+    if (step.kind === "brightness" || step.kind === "contrast") {
+      const lut = (i) => `clip(val*${fmt2(m[i][i])}+${fmt2(m[i][3] * 255)},0,255)`;
+      return `lutrgb=r='${lut(0)}':g='${lut(1)}':b='${lut(2)}'`;
+    }
+    const k = ["r", "g", "b"];
+    return `colorchannelmixer=${m.flatMap((row, i) => row.slice(0, 3).map((v, j) => `${k[i]}${k[j]}=${fmt2(v)}`)).join(":")}`;
+  });
+}
+
+// src/video-editor/remap.ts
+function videoClipSourceTime(clip, clipTime) {
+  const base = _nullishCoalesce(clip.in, () => ( 0));
+  return clip.timeRemap ? base + videoValueAt(clip.timeRemap, clipTime, 0) : base + clipTime * (_nullishCoalesce(clip.speed, () => ( 1)));
+}
+function videoClipSpeedAt(clip, clipTime) {
+  if (clip.type !== "media") return 1;
+  if (!clip.timeRemap) return _nullishCoalesce(clip.speed, () => ( 1));
+  const t = Math.min(Math.max(clipTime, 0), Math.max(0, clip.duration - 1));
+  return Math.max(0, videoClipSourceTime(clip, t + 1) - videoClipSourceTime(clip, t));
+}
+function videoSpeedRampKeys(segments) {
+  if (!segments.length) throw new Error("Give at least one stretch { duration, speed }.");
+  const keys = [];
+  let t = 0;
+  let v = 0;
+  segments.forEach((s, i) => {
+    if (!(s.duration > 0)) throw new Error(`Stretch ${i + 1} needs a duration above 0 ms.`);
+    for (const [name, x] of [["speed", s.speed], ["toSpeed", s.toSpeed]])
+      if (x !== void 0 && !(x >= 0 && x <= 20)) throw new Error(`Stretch ${i + 1}'s ${name} must be from 0 (a freeze) to 20; got ${x}.`);
+    const a = s.speed;
+    const b = _nullishCoalesce(s.toSpeed, () => ( s.speed));
+    const avg = (a + b) / 2;
+    let ease = "linear";
+    if (a !== b && avg > 0) {
+      ease = [1 / 3, 2 * a / (3 * (a + b)), 2 / 3, 1 - 2 * b / (3 * (a + b))].map((n2) => Math.round(n2 * 1e6) / 1e6);
+    }
+    keys.push({ t, v, ...ease === "linear" ? {} : { ease } });
+    t += s.duration;
+    v += avg * s.duration;
+  });
+  keys.push({ t, v });
+  return { keys: mergeLinear(keys), duration: t, source: v };
+}
+function mergeLinear(keys) {
+  const out = [keys[0]];
+  for (let i = 1; i < keys.length; i++) {
+    const prev = out[out.length - 1];
+    const k = keys[i];
+    const before = out.length > 1 ? out[out.length - 2] : null;
+    if (before && !before.ease && !prev.ease) {
+      const s1 = (prev.v - before.v) / (prev.t - before.t);
+      const s2 = (k.v - prev.v) / (k.t - prev.t);
+      if (Math.abs(s1 - s2) < 1e-9) {
+        out[out.length - 1] = k;
+        continue;
+      }
+    }
+    out.push(k);
+  }
+  return out;
+}
+function checkVideoTimeRemap(remap, path = "timeRemap") {
+  const { keys } = remap;
+  if (!keys.length) throw new Error(`${path} needs at least one key.`);
+  keys.forEach((k, i) => {
+    if (k.v < 0) throw new Error(`${path}.keys[${i}].v must be at least 0 (ms after the in point).`);
+    const next = keys[i + 1];
+    if (!next) return;
+    if (next.v < k.v - 1e-6) throw new Error(`${path}.keys[${i + 1}] goes back in the source (${next.v} ms after ${k.v} ms); a ramp only plays forwards, so make each value at least the one before.`);
+    if (!videoEaseBezier(k.ease)) return;
+    let prev = k.v;
+    for (let n2 = 1; n2 <= 32; n2++) {
+      const v = videoValueAt(remap, k.t + (next.t - k.t) * n2 / 32);
+      if (v < prev - 1e-3) throw new Error(`${path}.keys[${i}].ease overshoots, which would play backwards; use a curve that only moves forwards (or linear).`);
+      prev = v;
+    }
+  });
+}
+function videoTimeRemapSpan(remap) {
+  return { from: remap.keys[0].v, to: remap.keys[remap.keys.length - 1].v };
+}
+function videoTimeRemapBreakpoints(remap, step) {
+  const { points, holds } = videoKeyframeBreakpoints(remap, step);
+  const out = [];
+  points.forEach(([t, v], i) => {
+    out.push({ t, v });
+    if (holds.has(i) && points[i + 1]) out.push({ t: points[i + 1][0], v });
+  });
+  return out;
+}
+function videoSpeedRampEdit(clip, segments, ripple = true) {
+  const ramp = videoSpeedRampKeys(segments);
+  const offset = videoClipSourceTime(clip, 0) - (_nullishCoalesce(clip.in, () => ( 0)));
+  return { op: "set_time_remap", clip: clip.id, keys: ramp.keys.map((k) => ({ ...k, v: k.v + offset })), duration: ramp.duration, ripple };
+}
+function videoFreezeFrameEdit(clip, at, duration, ripple = true) {
+  if (at < 0 || at > clip.duration) throw new Error(`${Math.round(at)} ms is outside clip "${clip.id}" (0\u2013${clip.duration} ms of clip time).`);
+  const remap = _nullishCoalesce(clip.timeRemap, () => ( { keys: [{ t: 0, v: 0 }, { t: clip.duration, v: clip.duration * (_nullishCoalesce(clip.speed, () => ( 1))) }] }));
+  const [left, right] = splitVideoAnimatable(remap, at);
+  const keys = [...left.keys.slice(0, -1), { ...left.keys[left.keys.length - 1], ease: "linear" }, ...right.keys.map((k) => ({ ...k, t: k.t + at + duration }))];
+  return { op: "set_time_remap", clip: clip.id, keys, duration: clip.duration + duration, ripple };
+}
+var videoSlowMotionRamp = (duration) => [
+  { duration: Math.max(1, duration / 2), speed: 1 },
+  { duration: 500, speed: 1, toSpeed: 0.3 },
+  { duration: 1500, speed: 0.3 }
+];
+
+// src/video-editor/timeline.ts
+var VIDEO_TIME_EPSILON = 0.5;
+var videoClipEnd = (clip) => clip.start + clip.duration;
+var videoTrackSyncLocked = (track) => track.syncLocked !== false;
+var videoClipSpeed = (clip) => clip.type === "media" ? _nullishCoalesce(clip.speed, () => ( 1)) : 1;
+function videoClipSourceRange(clip) {
+  if (clip.type === "sequence") return { in: _nullishCoalesce(clip.in, () => ( 0)), out: (_nullishCoalesce(clip.in, () => ( 0))) + clip.duration };
+  if (clip.type !== "media") return null;
+  const start = _nullishCoalesce(clip.in, () => ( 0));
+  if (_optionalChain([clip, 'access', _5 => _5.timeRemap, 'optionalAccess', _6 => _6.keys, 'access', _7 => _7.length])) return { in: start + clip.timeRemap.keys[0].v, out: start + clip.timeRemap.keys[clip.timeRemap.keys.length - 1].v };
+  return { in: start, out: start + clip.duration * videoClipSpeed(clip) };
+}
+var videoFrameDuration = (fps) => 1e3 / fps;
+function snapToVideoFrame(time, fps) {
+  const frame = Math.round(time * fps / 1e3);
+  return Math.round(frame * 1e3 / fps * 1e3) / 1e3;
+}
+var videoFrames = (time, fps) => Math.round(time * fps / 1e3);
+function isVideoDropFrameRate(fps) {
+  const nominal = Math.round(fps);
+  return (nominal === 30 || nominal === 60) && Math.abs(fps - nominal * 1e3 / 1001) < 5e-3;
+}
+var exactVideoRate = (fps) => {
+  const nominal = Math.round(fps);
+  return nominal !== fps && Math.abs(fps - nominal * 1e3 / 1001) < 5e-3 ? nominal * 1e3 / 1001 : fps;
+};
+var videoTimecodeFrames = (time, fps) => Math.max(0, Math.round(time * exactVideoRate(fps) / 1e3));
+function formatVideoTimecode(time, fps, dropFrame = isVideoDropFrameRate(fps)) {
+  return formatVideoTimecodeFrames(videoTimecodeFrames(time, fps), fps, dropFrame);
+}
+function formatVideoTimecodeFrames(frames, fps, dropFrame = isVideoDropFrameRate(fps)) {
+  const base = Math.round(fps);
+  let total = Math.max(0, Math.round(frames));
+  const drop = dropFrame && isVideoDropFrameRate(fps);
+  if (drop) {
+    const skip = base / 15;
+    const perMinute = base * 60 - skip;
+    const perTen = perMinute * 10 + skip;
+    const tens = Math.floor(total / perTen);
+    const rest = total % perTen;
+    total += skip * 9 * tens + (rest > skip ? skip * Math.floor((rest - skip) / perMinute) : 0);
+  }
+  const ff = total % base;
+  const secs = Math.floor(total / base);
+  const pad = (n2) => String(n2).padStart(2, "0");
+  return `${pad(Math.floor(secs / 3600))}:${pad(Math.floor(secs / 60) % 60)}:${pad(secs % 60)}${drop ? ";" : ":"}${pad(ff)}`;
+}
+var videoHourFrames = (fps, dropFrame = isVideoDropFrameRate(fps)) => {
+  const base = Math.round(fps);
+  return dropFrame && isVideoDropFrameRate(fps) ? base * 3600 - base / 15 * 54 : base * 3600;
+};
+var formatVideoSeconds = (time) => `${(time / 1e3).toFixed(2)} s`;
+var videoAssetHasSound = (asset) => !!asset && (asset.kind === "audio" || asset.kind === "video" && asset.hasAudio !== false);
+function videoAssetMap(project) {
+  return new Map(project.assets.map((a) => [a.id, a]));
+}
+function videoSequenceMap(project) {
+  return new Map((_nullishCoalesce(project.sequences, () => ( []))).map((q) => [q.id, q]));
+}
+function videoSequenceDuration(sequence) {
+  let end = 0;
+  for (const track of sequence.tracks) for (const clip of track.clips) end = Math.max(end, videoClipEnd(clip));
+  return end;
+}
+var videoSequenceChildren = (sequence) => [...new Set(sequence.tracks.flatMap((t) => t.clips.flatMap((c) => c.type === "sequence" ? [c.sequence] : [])))];
+function findVideoSequenceCycle(project, id) {
+  const sequences = videoSequenceMap(project);
+  const walk = (at, path) => {
+    const seq = sequences.get(at);
+    if (!seq) return null;
+    for (const child of videoSequenceChildren(seq)) {
+      if (child === id) return [...path, child];
+      if (path.includes(child)) continue;
+      const found = walk(child, [...path, child]);
+      if (found) return found;
+    }
+    return null;
+  };
+  return walk(id, [id]);
+}
+function allVideoTracks(project) {
+  return [...project.tracks.map((track) => ({ track })), ...(_nullishCoalesce(project.sequences, () => ( []))).flatMap((q) => q.tracks.map((track) => ({ sequence: q.id, track })))];
+}
+function sortedVideoClips(track) {
+  return [...track.clips].sort((a, b) => a.start - b.start || a.duration - b.duration);
+}
+function findVideoClip(project, id) {
+  for (let trackIndex = 0; trackIndex < project.tracks.length; trackIndex++) {
+    const track = project.tracks[trackIndex];
+    const index = track.clips.findIndex((c) => c.id === id);
+    if (index >= 0) return { track, trackIndex, clip: track.clips[index], index };
+  }
+  return null;
+}
+function allVideoClipIds(project) {
+  return allVideoTracks(project).flatMap(({ track }) => track.clips.map((c) => c.id));
+}
+function findVideoSequenceClip(project, id) {
+  for (const sequence of _nullishCoalesce(project.sequences, () => ( [])))
+    for (const track of sequence.tracks) {
+      const clip = track.clips.find((c) => c.id === id);
+      if (clip) return { sequence, track, clip };
+    }
+  return null;
+}
+function videoProjectDuration(project) {
+  let end = 0;
+  for (const track of project.tracks) for (const clip of track.clips) end = Math.max(end, videoClipEnd(clip));
+  return end;
+}
+function videoClipBefore(track, clip) {
+  let best = null;
+  for (const c of track.clips) if (c !== clip && Math.abs(videoClipEnd(c) - clip.start) <= VIDEO_TIME_EPSILON) best = c;
+  return best;
+}
+function videoClipAfter(track, clip) {
+  for (const c of track.clips) if (c !== clip && Math.abs(c.start - videoClipEnd(clip)) <= VIDEO_TIME_EPSILON) return c;
+  return null;
+}
+function videoClipHandles(clip, assets, sequences) {
+  if (clip.type === "sequence") {
+    const seq = _optionalChain([sequences, 'optionalAccess', _8 => _8.get, 'call', _9 => _9(clip.sequence)]);
+    const range2 = videoClipSourceRange(clip);
+    return { before: range2.in, after: seq ? Math.max(0, videoSequenceDuration(seq) - range2.out) : Infinity };
+  }
+  if (clip.type !== "media") return { before: Infinity, after: Infinity };
+  const asset = assets.get(clip.asset);
+  const speed = videoClipSpeed(clip);
+  const range = videoClipSourceRange(clip);
+  const before = range.in / speed;
+  if (!asset || asset.kind === "image" || asset.duration === void 0) return { before: _optionalChain([asset, 'optionalAccess', _10 => _10.kind]) === "image" ? Infinity : before, after: Infinity };
+  return { before, after: Math.max(0, (asset.duration - range.out) / speed) };
+}
+function videoClipOverhang(track, clip) {
+  const lead = clip.transition && clip.transition.type !== "dip" && videoClipBefore(track, clip) ? clip.transition.duration / 2 : 0;
+  const next = videoClipAfter(track, clip);
+  const tail = _optionalChain([next, 'optionalAccess', _11 => _11.transition]) && next.transition.type !== "dip" ? next.transition.duration / 2 : 0;
+  return { lead, tail };
+}
+function videoSnapPoints(project, options = {}) {
+  const exclude = new Set(_nullishCoalesce(options.exclude, () => ( [])));
+  const points = /* @__PURE__ */ new Set([0]);
+  for (const track of project.tracks)
+    for (const clip of track.clips) {
+      if (exclude.has(clip.id)) continue;
+      points.add(clip.start);
+      points.add(videoClipEnd(clip));
+    }
+  for (const marker of _nullishCoalesce(project.markers, () => ( []))) points.add(marker.time);
+  if (options.playhead !== void 0) points.add(options.playhead);
+  return [...points].sort((a, b) => a - b);
+}
+function snapVideoTime(time, points, threshold) {
+  let best = null;
+  for (const p of points) if (Math.abs(p - time) <= threshold && (best === null || Math.abs(p - time) < Math.abs(best - time))) best = p;
+  return best === null ? { time, snapped: null } : { time: best, snapped: best };
+}
+function findVideoGaps(project, trackId) {
+  const gaps = [];
+  for (const track of project.tracks) {
+    if (trackId !== void 0 && track.id !== trackId) continue;
+    let at = 0;
+    for (const clip of sortedVideoClips(track)) {
+      if (clip.start - at > VIDEO_TIME_EPSILON) gaps.push({ track: track.id, start: at, end: clip.start });
+      at = Math.max(at, videoClipEnd(clip));
+    }
+  }
+  return gaps;
+}
+function videoOverlap(track, start, end, ignore = /* @__PURE__ */ new Set()) {
+  for (const c of sortedVideoClips(track)) {
+    if (ignore.has(c.id)) continue;
+    if (c.start < end - VIDEO_TIME_EPSILON && videoClipEnd(c) > start + VIDEO_TIME_EPSILON) return c;
+  }
+  return null;
+}
+function nextFreeVideoSlot(track, from, duration, ignore = /* @__PURE__ */ new Set()) {
+  let at = from;
+  for (const c of sortedVideoClips(track)) {
+    if (ignore.has(c.id)) continue;
+    if (videoClipEnd(c) <= at + VIDEO_TIME_EPSILON) continue;
+    if (c.start >= at + duration - VIDEO_TIME_EPSILON) break;
+    at = videoClipEnd(c);
+  }
+  return at;
+}
+function videoClipsAt(project, time) {
+  const out = [];
+  for (const track of project.tracks) for (const clip of track.clips) if (time >= clip.start && time < videoClipEnd(clip)) out.push({ track: track.id, clip });
+  return out;
+}
+
+// src/video-editor/clip-animation.ts
+var VIDEO_CLIP_ANIMATION_DURATION = 500;
+var EFFECTS = {
+  fade: { easeIn: "linear", easeOut: "linear" },
+  rise: { y: 0.06, easeIn: "ease-out", easeOut: "ease-in" },
+  drop: { y: -0.06, easeIn: "ease-out", easeOut: "ease-in" },
+  "slide-left": { x: 0.15, easeIn: "ease-out", easeOut: "ease-in" },
+  "slide-right": { x: -0.15, easeIn: "ease-out", easeOut: "ease-in" },
+  zoom: { scale: 0.6, easeIn: "ease-out", easeOut: "ease-in" },
+  // Overshoots past full size, then settles (a "back" curve).
+  pop: { scale: 0.3, easeIn: [0.34, 1.56, 0.64, 1], easeOut: [0.36, 0, 0.66, -0.56] }
+};
+var PROPS = ["opacity", "x", "y", "scale"];
+function videoClipAnimationProperties(animation) {
+  const spec = EFFECTS[animation.effect];
+  return PROPS.filter((p) => p === "opacity" || spec[p] !== void 0);
+}
+function videoClipAnimationSpans(clip) {
+  const a = clip.animateIn ? _nullishCoalesce(clip.animateIn.duration, () => ( VIDEO_CLIP_ANIMATION_DURATION)) : 0;
+  const b = clip.animateOut ? _nullishCoalesce(clip.animateOut.duration, () => ( VIDEO_CLIP_ANIMATION_DURATION)) : 0;
+  const k = a + b > clip.duration ? clip.duration / (a + b) : 1;
+  return { in: a * k, out: b * k };
+}
+function videoClipAnimated(clip, project) {
+  if (!clip.animateIn && !clip.animateOut) return clip;
+  const spans = videoClipAnimationSpans(clip);
+  const out = { ...clip, transform: { ...clip.transform } };
+  for (const prop of PROPS) {
+    const current = prop === "opacity" ? clip.opacity : _optionalChain([clip, 'access', _12 => _12.transform, 'optionalAccess', _13 => _13[prop]]);
+    if (isVideoKeyframes(current)) continue;
+    const base = _nullishCoalesce(current, () => ( (prop === "opacity" || prop === "scale" ? 1 : 0)));
+    const away = (spec) => {
+      if (prop === "opacity") return 0;
+      const v = spec[prop];
+      if (v === void 0) return void 0;
+      return prop === "scale" ? base * v : base + v * (prop === "x" ? project.width : project.height);
+    };
+    const keys = [];
+    if (clip.animateIn) {
+      const spec = EFFECTS[clip.animateIn.effect];
+      const from = away(spec);
+      if (from !== void 0) keys.push({ t: 0, v: from, ease: spec.easeIn }, { t: spans.in, v: base });
+    }
+    if (clip.animateOut) {
+      const spec = EFFECTS[clip.animateOut.effect];
+      const to = away(spec);
+      if (to !== void 0) {
+        const start = clip.duration - spans.out;
+        if (!keys.length || keys[keys.length - 1].t < start) keys.push({ t: start, v: base, ease: spec.easeOut });
+        else keys[keys.length - 1] = { ...keys[keys.length - 1], ease: spec.easeOut };
+        keys.push({ t: clip.duration, v: to });
+      }
+    }
+    if (!keys.length) continue;
+    if (prop === "opacity") out.opacity = { keys };
+    else out.transform[prop] = { keys };
+  }
+  return out;
+}
+
+// src/video-editor/evaluate.ts
+function videoTransformAt(transform, clipTime = 0) {
+  return { x: videoValueAt(_optionalChain([transform, 'optionalAccess', _14 => _14.x]), clipTime, 0), y: videoValueAt(_optionalChain([transform, 'optionalAccess', _15 => _15.y]), clipTime, 0), scale: videoValueAt(_optionalChain([transform, 'optionalAccess', _16 => _16.scale]), clipTime, 1), rotation: videoValueAt(_optionalChain([transform, 'optionalAccess', _17 => _17.rotation]), clipTime, 0) };
+}
+function placeVideoRect(frame, size, fit = "contain", transform = {}, clipTime = 0) {
+  let w = size.width;
+  let h = size.height;
+  if (fit === "fill") {
+    w = frame.width;
+    h = frame.height;
+  } else if (fit !== "none") {
+    const k = fit === "cover" ? Math.max(frame.width / w, frame.height / h) : Math.min(frame.width / w, frame.height / h);
+    w *= k;
+    h *= k;
+  }
+  const t = videoTransformAt(transform, clipTime);
+  w *= t.scale;
+  h *= t.scale;
+  const cx = frame.width / 2 + t.x;
+  const cy = frame.height / 2 + t.y;
+  return { x: cx - w / 2, y: cy - h / 2, width: w, height: h };
+}
+function videoTextStyle(clip) {
+  return { text: clip.text, color: _nullishCoalesce(clip.color, () => ( "#ffffff")), fontSize: _nullishCoalesce(clip.fontSize, () => ( 64)), fontFamily: _nullishCoalesce(clip.fontFamily, () => ( "sans-serif")), fontWeight: _nullishCoalesce(clip.fontWeight, () => ( 700)), ...clip.background ? { background: clip.background } : {} };
+}
+function videoTitleFrame(project, clip, clipTime = 0) {
+  const layer = { clip: clip.id, track: "", type: "text", opacity: 1, rect: placeVideoRect(project, project, "fill", clip.transform, clipTime), rotation: videoTransformAt(clip.transform, clipTime).rotation, text: videoTextStyle(clip) };
+  return { time: clip.start, width: project.width, height: project.height, background: "rgba(0,0,0,0)", layers: [layer], audio: [] };
+}
+var clamp012 = (v) => Math.min(1, Math.max(0, v));
+var videoTransitionEase = (progress) => (1 - Math.cos(Math.PI * clamp012(progress))) / 2;
+function videoFadeCurveGain(curve, x) {
+  const t = clamp012(x);
+  switch (curve) {
+    case "equal-power":
+      return Math.sin(t * Math.PI / 2);
+    case "s-curve":
+      return (1 - Math.cos(t * Math.PI)) / 2;
+    case "exponential":
+      return t * t * t;
+    case "logarithmic":
+      return 1 - (1 - t) * (1 - t);
+    default:
+      return t;
+  }
+}
+function fadeGain(clip, time, sound = false) {
+  let g = 1;
+  const shape = sound && (clip.type === "media" || clip.type === "sequence") ? clip : void 0;
+  if (clip.fadeIn) g *= videoFadeCurveGain(_optionalChain([shape, 'optionalAccess', _18 => _18.fadeInCurve]), (time - clip.start) / clip.fadeIn);
+  if (clip.fadeOut) g *= videoFadeCurveGain(_optionalChain([shape, 'optionalAccess', _19 => _19.fadeOutCurve]), (videoClipEnd(clip) - time) / clip.fadeOut);
+  return g;
+}
+function videoClipSoundGain(clip, clipTime) {
+  const volume = clip.type === "media" || clip.type === "sequence" ? videoValueAt(clip.volume, clipTime, 1) : 1;
+  return volume * fadeGain(clip, clip.start + Math.min(Math.max(clipTime, 0), clip.duration), true);
+}
+function activeOnTrack(track, time) {
+  const out = [];
+  for (const clip of sortedVideoClips(track)) {
+    const before = clip.transition ? videoClipBefore(track, clip) : null;
+    const lead = before ? clip.transition.duration / 2 : 0;
+    const next = videoClipAfter(track, clip);
+    const tail = _optionalChain([next, 'optionalAccess', _20 => _20.transition]) ? next.transition.duration / 2 : 0;
+    if (time < clip.start - lead || time >= videoClipEnd(clip) + tail) continue;
+    const a = { clip };
+    if (lead && time < clip.start + lead) a.incoming = { progress: clamp012((time - (clip.start - lead)) / (2 * lead)), type: clip.transition.type, transition: clip.transition };
+    if (tail && time >= videoClipEnd(clip) - tail) a.outgoing = { progress: clamp012((time - (videoClipEnd(clip) - tail)) / (2 * tail)), type: next.transition.type, next };
+    out.push(a);
+  }
+  return out;
+}
+var sourceTimeAt = (clip, time) => clip.type === "media" ? videoClipSourceTime(clip, time - clip.start) : 0;
+function videoFrameAt(project, time) {
+  const { layers, audio } = tracksAt(project, project.tracks, time, { assets: videoAssetMap(project), sequences: videoSequenceMap(project), within: [], prefix: "" });
+  return { time, width: project.width, height: project.height, background: _nullishCoalesce(project.background, () => ( "#000000")), layers, audio };
+}
+function tracksAt(project, tracks, time, scope) {
+  const { assets, prefix } = scope;
+  const layers = [];
+  const audio = [];
+  for (let ti = tracks.length - 1; ti >= 0; ti--) {
+    const track = tracks[ti];
+    for (const { clip, incoming, outgoing } of activeOnTrack(track, time)) {
+      if (_optionalChain([incoming, 'optionalAccess', _21 => _21.type]) === "dip" && incoming.progress < 0.5) continue;
+      if (_optionalChain([outgoing, 'optionalAccess', _22 => _22.type]) === "dip" && outgoing.progress >= 0.5) continue;
+      const inside = Math.min(Math.max(time, clip.start), videoClipEnd(clip));
+      const fade = fadeGain(clip, inside);
+      const level = (t, transition, into) => videoFadeCurveGain(videoTransitionAudioCurve(transition), t.type === "dip" ? Math.abs(1 - 2 * t.progress) : into ? t.progress : 1 - t.progress);
+      const mix = (incoming ? level(incoming, incoming.transition, true) : 1) * (outgoing ? level(outgoing, outgoing.next.transition, false) : 1);
+      const asset = clip.type === "media" ? assets.get(clip.asset) : void 0;
+      const sourceTime = clip.type === "sequence" ? (_nullishCoalesce(clip.in, () => ( 0))) + time - clip.start : sourceTimeAt(clip, time);
+      const clipTime = time - clip.start;
+      let nested = null;
+      if (clip.type === "sequence") {
+        const seq = scope.sequences.get(clip.sequence);
+        if (!seq || scope.within.includes(seq.id)) continue;
+        nested = tracksAt(project, seq.tracks, sourceTime, { ...scope, within: [...scope.within, seq.id], prefix: `${prefix}${clip.id}/` });
+      }
+      const audible = videoAssetHasSound(asset);
+      if (audible && clip.type === "media" && !clip.muted && !track.muted) {
+        const gain = videoValueAt(clip.volume, clipTime, 1) * (_nullishCoalesce(track.volume, () => ( 1))) * fadeGain(clip, inside, true) * mix;
+        audio.push({ clip: prefix + clip.id, track: track.id, asset: asset.id, src: asset.src, sourceTime, gain, speed: videoClipSpeedAt(clip, clipTime) });
+      }
+      if (nested && clip.type === "sequence" && !clip.muted && !track.muted) {
+        const gain = videoValueAt(clip.volume, clipTime, 1) * (_nullishCoalesce(track.volume, () => ( 1))) * fadeGain(clip, inside, true) * mix;
+        for (const a of nested.audio) audio.push({ ...a, gain: a.gain * gain });
+      }
+      if (track.kind !== "video" || track.hidden) continue;
+      if (clip.type === "media" && (!asset || asset.kind === "audio")) continue;
+      if (nested && !nested.layers.length) continue;
+      const shown = videoClipAnimated(clip, project);
+      let opacity = videoValueAt(shown.opacity, clipTime, 1) * fade;
+      let wipe;
+      let dip = null;
+      let iris;
+      let shift = 0;
+      let shiftDirection = "right";
+      if (incoming) {
+        if (incoming.type === "crossfade") opacity *= incoming.progress;
+        else if (incoming.type === "wipe") wipe = { direction: _nullishCoalesce(incoming.transition.direction, () => ( "right")), progress: incoming.progress };
+        else if (incoming.type === "iris") iris = { progress: incoming.progress };
+        else if (incoming.type === "push" || incoming.type === "slide") {
+          shiftDirection = _nullishCoalesce(incoming.transition.direction, () => ( "right"));
+          shift = videoTransitionEase(incoming.progress) - 1;
+        } else dip = { color: _nullishCoalesce(incoming.transition.color, () => ( "#000000")), opacity: (1 - incoming.progress) * 2 };
+      }
+      if (_optionalChain([outgoing, 'optionalAccess', _23 => _23.type]) === "dip") dip = { color: _nullishCoalesce(outgoing.next.transition.color, () => ( "#000000")), opacity: outgoing.progress * 2 };
+      if (_optionalChain([outgoing, 'optionalAccess', _24 => _24.type]) === "push") {
+        shiftDirection = _nullishCoalesce(outgoing.next.transition.direction, () => ( "right"));
+        shift = videoTransitionEase(outgoing.progress);
+      }
+      const size = clip.type === "media" ? { width: _nullishCoalesce(asset.width, () => ( project.width)), height: _nullishCoalesce(asset.height, () => ( project.height)) } : { width: project.width, height: project.height };
+      const fit = _nullishCoalesce(clip.fit, () => ( (clip.type === "media" || clip.type === "sequence" ? "contain" : "fill")));
+      const placed = placeVideoRect(project, size, clip.type === "text" ? "fill" : fit, shown.transform, clipTime);
+      const across = shiftDirection === "left" || shiftDirection === "right";
+      const sign = shiftDirection === "left" || shiftDirection === "up" ? -1 : 1;
+      const rect = shift ? { ...placed, ...across ? { x: placed.x + sign * shift * project.width } : { y: placed.y + sign * shift * project.height } } : placed;
+      const layer = { clip: prefix + clip.id, track: track.id, type: clip.type, opacity: clamp012(opacity), rect, rotation: videoValueAt(_optionalChain([shown, 'access', _25 => _25.transform, 'optionalAccess', _26 => _26.rotation]), clipTime, 0) };
+      if (wipe) layer.wipe = wipe;
+      if (iris) layer.iris = iris;
+      if (clip.blend && clip.blend !== "normal") layer.blend = clip.blend;
+      const grade = normalizeVideoGrade(clip.grade);
+      if (grade) layer.grade = grade;
+      if (clip.type === "media") Object.assign(layer, { asset: asset.id, assetKind: asset.kind, src: asset.src, sourceTime });
+      if (clip.type === "sequence") Object.assign(layer, { sequence: clip.sequence, sourceTime, layers: nested.layers });
+      if (clip.type === "text") layer.text = videoTextStyle(clip);
+      if (clip.type === "color") layer.color = clip.color;
+      if (layer.opacity > 0) layers.push(layer);
+      if (dip && dip.opacity > 0) layers.push({ clip: `transition:${prefix}${incoming ? clip.id : outgoing.next.id}`, track: track.id, type: "color", color: dip.color, opacity: clamp012(dip.opacity), rect: { x: 0, y: 0, width: project.width, height: project.height }, rotation: 0 });
+    }
+  }
+  return { layers, audio };
+}
+function videoFrameLeafLayers(layers) {
+  return layers.flatMap((l) => l.layers ? videoFrameLeafLayers(l.layers) : [l]);
+}
+
+// src/video-editor/render.ts
+var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var n = (v) => String(Math.round(v * 100) / 100);
+var n4 = (v) => String(Math.round(v * 1e4) / 1e4);
+var videoIrisRadius = (frame, progress) => progress * Math.hypot(frame.width / 2, frame.height / 2);
+function videoWipeRect(rect, wipe) {
+  const { direction, progress } = wipe;
+  const w = rect.width * progress;
+  const h = rect.height * progress;
+  if (direction === "right") return { ...rect, width: w };
+  if (direction === "left") return { ...rect, x: rect.x + rect.width - w, width: w };
+  if (direction === "down") return { ...rect, height: h };
+  return { ...rect, y: rect.y + rect.height - h, height: h };
+}
+function videoFrameToSvg(frame, options = {}, assets = []) {
+  const defs = [];
+  const posters = new Map(assets.map((a) => [a.id, a.poster]));
+  const draw = (layers, prefix) => layers.map((layer, index) => {
+    const i = `${prefix}${index}`;
+    const { rect } = layer;
+    const attrs = [];
+    const style = [];
+    if (layer.opacity < 1) attrs.push(`opacity="${n(layer.opacity)}"`);
+    if (layer.blend) style.push(`mix-blend-mode:${layer.blend === "add" ? "plus-lighter" : layer.blend}`);
+    if (layer.layers) style.push("isolation:isolate");
+    if (style.length) attrs.push(`style="${style.join(";")}"`);
+    if (layer.grade) {
+      defs.push(videoGradeSvgFilter(`g${i}`, layer.grade, layer.grade.lut ? _optionalChain([options, 'access', _27 => _27.lutFor, 'optionalCall', _28 => _28(layer.grade.lut.src)]) : null));
+      attrs.push(`filter="url(#g${i})"`);
+    }
+    if (layer.rotation) attrs.push(`transform="rotate(${n(layer.rotation)} ${n(rect.x + rect.width / 2)} ${n(rect.y + rect.height / 2)})"`);
+    if (layer.wipe) {
+      const r = videoWipeRect(rect, layer.wipe);
+      defs.push(`<clipPath id="w${i}"><rect x="${n(r.x)}" y="${n(r.y)}" width="${n(r.width)}" height="${n(r.height)}"/></clipPath>`);
+      attrs.push(`clip-path="url(#w${i})"`);
+    }
+    const box = `x="${n(rect.x)}" y="${n(rect.y)}" width="${n(rect.width)}" height="${n(rect.height)}"`;
+    let inner = "";
+    if (layer.layers) {
+      inner = `<g transform="translate(${n(rect.x)} ${n(rect.y)}) scale(${n4(rect.width / frame.width)} ${n4(rect.height / frame.height)})">${draw(layer.layers, `${i}-`)}</g>`;
+    } else if (layer.type === "color") inner = `<rect ${box} fill="${esc(_nullishCoalesce(layer.color, () => ( "#000000")))}"/>`;
+    else if (layer.type === "text" && layer.text) {
+      const t = layer.text;
+      const lines = t.text.split("\n");
+      const lh = t.fontSize * 1.2;
+      const cx = rect.x + rect.width / 2;
+      const cy = rect.y + rect.height / 2;
+      const top = cy - lh * (lines.length - 1) / 2;
+      if (t.background) {
+        const w = Math.max(...lines.map((l) => l.length)) * t.fontSize * 0.6 + t.fontSize;
+        const h = lh * lines.length + t.fontSize * 0.4;
+        inner += `<rect x="${n(cx - w / 2)}" y="${n(cy - h / 2)}" width="${n(w)}" height="${n(h)}" fill="${esc(t.background)}"/>`;
+      }
+      inner += `<text x="${n(cx)}" text-anchor="middle" dominant-baseline="central" font-family="${esc(t.fontFamily)}" font-size="${n(t.fontSize)}" font-weight="${t.fontWeight}" fill="${esc(t.color)}">${lines.map((l, k) => `<tspan x="${n(cx)}" y="${n(top + k * lh)}">${esc(l)}</tspan>`).join("")}</text>`;
+    } else {
+      const href = options.imageFor ? options.imageFor(layer, frame) : layer.assetKind === "image" ? _nullishCoalesce(layer.src, () => ( null)) : _nullishCoalesce(posters.get(_nullishCoalesce(layer.asset, () => ( ""))), () => ( null));
+      if (href) inner = `<image href="${esc(href)}" ${box} preserveAspectRatio="none"/>`;
+      else {
+        const label = `${_nullishCoalesce(layer.asset, () => ( layer.clip))} \xB7 ${formatVideoTimecode(_nullishCoalesce(layer.sourceTime, () => ( 0)), _nullishCoalesce(options.fps, () => ( 30)))}`;
+        const size = Math.max(10, Math.min(rect.height / 8, rect.width / Math.max(8, label.length * 0.6)));
+        inner = `<rect ${box} fill="#334155" stroke="#94a3b8" stroke-width="2"/><text x="${n(rect.x + rect.width / 2)}" y="${n(rect.y + rect.height / 2)}" text-anchor="middle" dominant-baseline="central" font-family="sans-serif" font-size="${n(size)}" fill="#e2e8f0">${esc(label)}</text>`;
+      }
+    }
+    let item = attrs.length ? `<g ${attrs.join(" ")}>${inner}</g>` : inner;
+    if (layer.iris) {
+      defs.push(`<clipPath id="i${i}"><circle cx="${n(frame.width / 2)}" cy="${n(frame.height / 2)}" r="${n(videoIrisRadius(frame, layer.iris.progress))}"/></clipPath>`);
+      item = `<g clip-path="url(#i${i})">${item}</g>`;
+    }
+    return item;
+  }).join("");
+  const body = draw(frame.layers, "");
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${n(frame.width)} ${n(frame.height)}" width="${n(frame.width)}" height="${n(frame.height)}">${defs.length ? `<defs>${defs.join("")}</defs>` : ""}<rect width="100%" height="100%" fill="${esc(frame.background)}"/>${body}</svg>`;
+}
+function videoProjectSvg(project, time, options = {}) {
+  return videoFrameToSvg(videoFrameAt(project, time), { fps: project.fps, ...options }, project.assets);
+}
+function videoContactSheetSvg(project, times, options = {}) {
+  const columns = _nullishCoalesce(options.columns, () => ( Math.ceil(Math.sqrt(times.length))));
+  const w = _nullishCoalesce(options.width, () => ( 320));
+  const h = w * project.height / project.width;
+  const label = 18;
+  const gap = 8;
+  const rows = Math.ceil(times.length / columns);
+  const W = columns * w + (columns + 1) * gap;
+  const H = rows * (h + label) + (rows + 1) * gap;
+  const cells = times.map((t, i) => {
+    const x = gap + i % columns * (w + gap);
+    const y = gap + Math.floor(i / columns) * (h + label + gap);
+    const svg = videoProjectSvg(project, t, options).replace(/^<svg xmlns="http:\/\/www.w3.org\/2000\/svg"/, `<svg x="${n(x)}" y="${n(y)}" width="${n(w)}" height="${n(h)}"`).replace(/ width="[\d.]+" height="[\d.]+">/, ">");
+    return `${svg}<text x="${n(x)}" y="${n(y + h + 14)}" font-family="sans-serif" font-size="12" fill="#0f172a">${(t / 1e3).toFixed(2)} s \xB7 ${formatVideoTimecode(t, project.fps)}</text>`;
+  });
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${n(W)} ${n(H)}" width="${n(W)}" height="${n(H)}"><rect width="100%" height="100%" fill="#f8fafc"/>${cells.join("")}</svg>`;
+}
+function paintVideoLayer(ctx, frame, layer, sourceFor, options) {
+  const { rect } = layer;
+  if (layer.iris) {
+    ctx.beginPath();
+    ctx.arc(frame.width / 2, frame.height / 2, videoIrisRadius(frame, layer.iris.progress), 0, 2 * Math.PI);
+    ctx.clip();
+  }
+  if (layer.grade) {
+    const defs = videoGradeSvgDefs(layer.grade);
+    if (options.defineSvgFilter) for (const d of defs) options.defineSvgFilter(d.id, d.markup);
+    const css = videoGradeCssFilter(layer.grade);
+    ctx.filter = options.defineSvgFilter ? css || "none" : css.replace(/\s*url\([^)]*\)/g, "").trim() || "none";
+  }
+  if (layer.rotation) {
+    ctx.translate(rect.x + rect.width / 2, rect.y + rect.height / 2);
+    ctx.rotate(layer.rotation * Math.PI / 180);
+    ctx.translate(-(rect.x + rect.width / 2), -(rect.y + rect.height / 2));
+  }
+  if (layer.wipe) {
+    const r = videoWipeRect(rect, layer.wipe);
+    ctx.beginPath();
+    ctx.rect(r.x, r.y, r.width, r.height);
+    ctx.clip();
+  }
+  if (layer.type === "color") {
+    ctx.fillStyle = _nullishCoalesce(layer.color, () => ( "#000000"));
+    ctx.fillRect(rect.x, rect.y, rect.width, rect.height);
+  } else if (layer.type === "text" && layer.text) {
+    const t = layer.text;
+    const lines = t.text.split("\n");
+    const lh = t.fontSize * 1.2;
+    const cx = rect.x + rect.width / 2;
+    const top = rect.y + rect.height / 2 - lh * (lines.length - 1) / 2;
+    ctx.font = `${t.fontWeight} ${t.fontSize}px ${t.fontFamily}`;
+    ctx.textAlign = "center";
+    ctx.textBaseline = "middle";
+    if (t.background) {
+      const w = Math.max(...lines.map((l) => ctx.measureText(l).width)) + t.fontSize;
+      const h = lh * lines.length + t.fontSize * 0.4;
+      ctx.fillStyle = t.background;
+      ctx.fillRect(cx - w / 2, rect.y + rect.height / 2 - h / 2, w, h);
+    }
+    ctx.fillStyle = t.color;
+    lines.forEach((l, k) => ctx.fillText(l, cx, top + k * lh));
+  } else {
+    const source = sourceFor(layer);
+    if (source) ctx.drawImage(source, rect.x, rect.y, rect.width, rect.height);
+    else {
+      ctx.fillStyle = "#334155";
+      ctx.fillRect(rect.x, rect.y, rect.width, rect.height);
+      ctx.strokeStyle = "#94a3b8";
+      ctx.lineWidth = 2;
+      ctx.strokeRect(rect.x, rect.y, rect.width, rect.height);
+    }
+  }
+}
+function drawVideoFrame(ctx, frame, sourceFor, scale = 1, options = {}) {
+  ctx.save();
+  ctx.setTransform(scale, 0, 0, scale, 0, 0);
+  ctx.globalAlpha = 1;
+  ctx.fillStyle = frame.background;
+  ctx.fillRect(0, 0, frame.width, frame.height);
+  drawVideoLayers(ctx, frame, frame.layers, sourceFor, scale, options, 0);
+  ctx.restore();
+}
+function drawVideoLayers(ctx, frame, layers, sourceFor, scale, options, depth) {
+  const cw = Math.max(1, Math.round(frame.width * scale));
+  const ch = Math.max(1, Math.round(frame.height * scale));
+  for (const layer of layers) {
+    let source = sourceFor;
+    if (layer.layers) {
+      const group = _optionalChain([options, 'access', _29 => _29.scratch, 'optionalCall', _30 => _30(cw, ch, 2 * depth)]);
+      if (!group) {
+        drawVideoLayers(ctx, frame, layer.layers, sourceFor, scale, options, depth + 1);
+        continue;
+      }
+      const g = group.ctx;
+      g.save();
+      g.setTransform(1, 0, 0, 1, 0, 0);
+      g.clearRect(0, 0, cw, ch);
+      g.setTransform(scale, 0, 0, scale, 0, 0);
+      g.globalAlpha = 1;
+      g.globalCompositeOperation = "source-over";
+      drawVideoLayers(g, frame, layer.layers, sourceFor, scale, options, depth + 1);
+      g.restore();
+      source = (l) => l === layer ? group.canvas : sourceFor(l);
+    }
+    const setting = _optionalChain([layer, 'access', _31 => _31.grade, 'optionalAccess', _32 => _32.lut]);
+    const lut = setting ? _optionalChain([options, 'access', _33 => _33.lutFor, 'optionalCall', _34 => _34(setting.src)]) : null;
+    const scratch = lut ? _optionalChain([options, 'access', _35 => _35.scratch, 'optionalCall', _36 => _36(cw, ch, 2 * depth + 1)]) : null;
+    ctx.save();
+    ctx.setTransform(scale, 0, 0, scale, 0, 0);
+    if (lut && scratch) {
+      const s = scratch.ctx;
+      s.save();
+      s.setTransform(1, 0, 0, 1, 0, 0);
+      s.clearRect(0, 0, cw, ch);
+      s.setTransform(scale, 0, 0, scale, 0, 0);
+      s.globalAlpha = 1;
+      s.globalCompositeOperation = "source-over";
+      paintVideoLayer(s, frame, layer, source, options);
+      s.restore();
+      const img = s.getImageData(0, 0, cw, ch);
+      applyVideoLutToPixels(lut, img.data, _nullishCoalesce(setting.strength, () => ( 1)));
+      s.putImageData(img, 0, 0);
+      ctx.setTransform(1, 0, 0, 1, 0, 0);
+      ctx.globalAlpha = layer.opacity;
+      if (layer.blend && layer.blend !== "normal") ctx.globalCompositeOperation = layer.blend === "add" ? "lighter" : layer.blend;
+      ctx.drawImage(scratch.canvas, 0, 0, cw, ch);
+    } else {
+      ctx.globalAlpha = layer.opacity;
+      if (layer.blend && layer.blend !== "normal") ctx.globalCompositeOperation = layer.blend === "add" ? "lighter" : layer.blend;
+      paintVideoLayer(ctx, frame, layer, source, options);
+    }
+    ctx.restore();
+  }
+}
+
+// src/video-editor/export.ts
+var reelName = (asset) => (_nullishCoalesce(_nullishCoalesce(_optionalChain([asset, 'optionalAccess', _37 => _37.name]), () => ( _optionalChain([asset, 'optionalAccess', _38 => _38.id]))), () => ( "AX"))).replace(/\.[a-z0-9]+$/i, "").replace(/[^A-Za-z0-9]/g, "").toUpperCase().slice(0, 8) || "AX";
+function toVideoEdl(project, options = {}) {
+  const track = options.track !== void 0 ? project.tracks.find((t) => t.id === options.track) : [...project.tracks].reverse().find((t) => t.kind === "video");
+  if (!track) throw new Error(options.track !== void 0 ? `There is no track "${options.track}".` : "The project has no video track.");
+  const fps = project.fps;
+  const dropFrame = (_nullishCoalesce(options.dropFrame, () => ( true))) && isVideoDropFrameRate(fps);
+  const tc = (ms) => formatVideoTimecode(ms, fps, dropFrame);
+  const rec0 = options.recordStart !== void 0 ? videoTimecodeFrames(options.recordStart, fps) : videoHourFrames(fps, dropFrame);
+  const rtc = (ms) => formatVideoTimecodeFrames(rec0 + videoTimecodeFrames(ms, fps), fps, dropFrame);
+  const assets = videoAssetMap(project);
+  const channel = track.kind === "video" ? "V" : "A";
+  const lines = [`TITLE: ${(_nullishCoalesce(_nullishCoalesce(options.title, () => ( project.name)), () => ( "Untitled"))).toUpperCase()}`, `FCM: ${dropFrame ? "DROP FRAME" : "NON-DROP FRAME"}`, ""];
+  let event = 0;
+  const num = () => String(++event).padStart(3, "0");
+  const sourceAt = (clip, time) => clip.type === "media" ? (_nullishCoalesce(clip.in, () => ( 0))) + (time - clip.start) * videoClipSpeed(clip) : time - clip.start;
+  const row = (n2, reel, kind, srcIn, srcOut, recIn, recOut) => `${n2}  ${reel.padEnd(8)} ${channel.padEnd(5)} ${kind.padEnd(8)} ${tc(srcIn)} ${tc(srcOut)} ${rtc(recIn)} ${rtc(recOut)}`;
+  for (const clip of sortedVideoClips(track)) {
+    const asset = clip.type === "media" ? assets.get(clip.asset) : void 0;
+    const reel = clip.type === "media" ? reelName(asset) : "BL";
+    const end = videoClipEnd(clip);
+    const before = clip.transition ? videoClipBefore(track, clip) : null;
+    const half = before && clip.transition.type !== "dip" ? clip.transition.duration / 2 : 0;
+    const next = sortedVideoClips(track).find((c) => c !== clip && Math.abs(c.start - end) < 0.5 && c.transition && c.transition.type !== "dip");
+    const recOut = next ? end - next.transition.duration / 2 : end;
+    const recIn = clip.start - half;
+    const n2 = num();
+    if (before) {
+      const t = clip.transition;
+      const frames = String(Math.round(t.duration * fps / 1e3)).padStart(3, "0");
+      const outReel = before.type === "media" ? reelName(assets.get(before.asset)) : "BL";
+      const at = sourceAt(before, recIn);
+      lines.push(row(n2, outReel, "C", at, at, recIn, recIn));
+      lines.push(row(n2, reel, `${t.type === "crossfade" || t.type === "dip" ? "D" : "W001"}    ${frames}`, sourceAt(clip, recIn), sourceAt(clip, recOut), recIn, recOut));
+    } else lines.push(row(n2, reel, "C", sourceAt(clip, recIn), sourceAt(clip, recOut), recIn, recOut));
+    if (clip.type === "media" && videoClipSpeed(clip) !== 1) lines.push(`M2   ${reel.padEnd(8)} ${(videoClipSpeed(clip) * fps).toFixed(1).padStart(6)}      ${tc(sourceAt(clip, recIn))}`);
+    if (clip.type === "media") lines.push(`* FROM CLIP NAME: ${_nullishCoalesce(_nullishCoalesce(_optionalChain([asset, 'optionalAccess', _39 => _39.name]), () => ( _optionalChain([asset, 'optionalAccess', _40 => _40.src]))), () => ( clip.asset))}`);
+    if (clip.type === "text") lines.push(`* TITLE: ${clip.text.replace(/\n/g, " ")}`);
+    if (clip.type === "color") lines.push(`* COLOR: ${clip.color}`);
+    if (clip.type === "sequence") lines.push(`* COMPOUND CLIP: ${_nullishCoalesce(clip.name, () => ( clip.sequence))} (sequence ${clip.sequence} from ${tc(_nullishCoalesce(clip.in, () => ( 0)))}, not flattened)`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function loudnormFilter(target = {}, measure = false) {
+  const I = _nullishCoalesce(target.integrated, () => ( -14));
+  const TP = _nullishCoalesce(target.truePeak, () => ( -1));
+  const LRA = _nullishCoalesce(target.range, () => ( 11));
+  if (!(I >= -70 && I <= -5)) throw new Error(`The loudness target must be between -70 and -5 LUFS (got ${I}); -14 suits streaming, -23 broadcast.`);
+  if (!(TP >= -9 && TP <= 0)) throw new Error(`The true peak ceiling must be between -9 and 0 dBTP (got ${TP}); -1 is usual.`);
+  if (!(LRA >= 1 && LRA <= 50)) throw new Error(`The loudness range must be between 1 and 50 LU (got ${LRA}).`);
+  const parts = [`loudnorm=I=${I}:TP=${TP}:LRA=${LRA}`];
+  const m = target.measured;
+  if (m && !measure) {
+    for (const [k, v] of Object.entries(m)) if (!Number.isFinite(v)) throw new Error(`The measured ${k} is not a number (${v}); measure again, or leave "measured" out for a one-pass normalisation.`);
+    parts.push(`measured_I=${m.integrated}:measured_TP=${m.truePeak}:measured_LRA=${m.range}:measured_thresh=${m.threshold}:offset=${m.offset}:linear=true`);
+  }
+  if (measure) parts.push("print_format=json");
+  return `${parts.join(":")},aresample=48000`;
+}
+function parseVideoLoudnessMeasurement(output) {
+  const blocks = output.match(/\{[^{}]*"input_i"[^{}]*\}/g);
+  if (!blocks) throw new Error("No loudness measurement found: pass the stderr of the command from toVideoLoudnessMeasure.");
+  const json = JSON.parse(blocks[blocks.length - 1]);
+  const n2 = (k) => Number(json[k]);
+  const m = { integrated: n2("input_i"), truePeak: n2("input_tp"), range: n2("input_lra"), threshold: n2("input_thresh"), offset: n2("target_offset") };
+  if (!Number.isFinite(m.integrated)) throw new Error("The mix is silent, so its loudness cannot be normalised.");
+  return m;
+}
+var sec = (ms) => String(Math.round(ms) / 1e3);
+var fmtMs = (v) => String(Math.round(v * 100) / 100);
+var FFMPEG_BLEND = {
+  multiply: "multiply",
+  screen: "screen",
+  overlay: "overlay",
+  darken: "darken",
+  lighten: "lighten",
+  "color-dodge": "dodge",
+  "color-burn": "burn",
+  "hard-light": "hardlight",
+  "soft-light": "softlight",
+  difference: "difference",
+  exclusion: "exclusion",
+  add: "addition"
+};
+var AFADE_CURVES = { linear: "tri", "equal-power": "qsin", "s-curve": "hsin", exponential: "cub", logarithmic: "ipar" };
+var afadeCurve = (curve) => curve && curve !== "linear" ? `:curve=${AFADE_CURVES[curve]}` : "";
+var even = (v) => Math.max(2, 2 * Math.round(v / 2));
+var ffmpegFilterValue = (s) => s.replace(/[\\':%]/g, (c) => `\\${c}`).replace(/[\\'[\],;]/g, (c) => `\\${c}`);
+var color = (c) => {
+  const hex = /^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(c);
+  if (!hex) return c.replace(/[^A-Za-z0-9@.]/g, "");
+  const h = hex[1].length === 3 ? [...hex[1]].map((x) => x + x).join("") : hex[1];
+  return `0x${h.slice(0, 6)}${h.length === 8 ? `@${(parseInt(h.slice(6), 16) / 255).toFixed(3)}` : ""}`;
+};
+var videoShellQuote = (s) => /^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
+function atempo(speed) {
+  const out = [];
+  let s = speed;
+  while (s > 2) {
+    out.push("atempo=2");
+    s /= 2;
+  }
+  while (s < 0.5) {
+    out.push("atempo=0.5");
+    s /= 0.5;
+  }
+  if (Math.abs(s - 1) > 1e-6) out.push(`atempo=${Math.round(s * 1e6) / 1e6}`);
+  return out;
+}
+function toVideoFfmpeg(project, options = {}) {
+  return buildFfmpeg(project, options, false);
+}
+function toVideoLoudnessMeasure(project, options = {}) {
+  return buildFfmpeg(project, { ...options, loudness: { ...options.loudness, measured: void 0 } }, true);
+}
+function buildFfmpeg(project, options, measure) {
+  const notes = [];
+  const assets = videoAssetMap(project);
+  const sequences = videoSequenceMap(project);
+  const D = videoProjectDuration(project);
+  if (D <= 0) throw new Error("The project has no clips, so there is nothing to render.");
+  const W = even(project.width);
+  const H = even(project.height);
+  const fps = project.fps;
+  const inputs = [];
+  const graph = measure ? [] : [`color=c=${color(_nullishCoalesce(project.background, () => ( "#000000")))}:s=${W}x${H}:r=${fps}:d=${sec(D)},format=yuva420p[base]`];
+  let usesDrawtext = false;
+  const animated = /* @__PURE__ */ new Set();
+  const ramped = /* @__PURE__ */ new Set();
+  const rampedPicture = (remap, lead, end) => {
+    const pts = videoTimeRemapBreakpoints(remap, 2e3 / fps);
+    const first = pts[0];
+    const last = pts[pts.length - 1];
+    const s = `(T*1000+${fmtMs(first.v)})`;
+    let e = fmtMs(last.t - first.t);
+    for (let i = pts.length - 2; i >= 0; i--) {
+      const a = pts[i];
+      const b = pts[i + 1];
+      if (b.v - a.v < 1e-6) continue;
+      e = `if(lt(${s},${fmtMs(b.v)}),${fmtMs(a.t - first.t)}+(${s}-${fmtMs(a.v)})*${fmtMs((b.t - a.t) / (b.v - a.v))},${e})`;
+    }
+    const before = lead + first.t;
+    const after = Math.max(0, end - last.t);
+    return ["setpts=PTS-STARTPTS", `setpts='(${e})/1000/TB'`, `fps=${fps}`, ...before > 0.5 || after > 0.5 ? [`tpad=start_mode=clone:start_duration=${sec(before)}:stop_mode=clone:stop_duration=${sec(after + 1e3 / fps)}`] : [`tpad=stop_mode=clone:stop_duration=${sec(1e3 / fps)}`], `trim=duration=${sec(lead + end)}`];
+  };
+  const rampedSound = (remap, input2, output, lead, end) => {
+    const pts = videoTimeRemapBreakpoints(remap, Math.max(80, 2e3 / fps));
+    const first = pts[0];
+    const last = pts[pts.length - 1];
+    const n2 = ak;
+    const fmtA = "aformat=sample_fmts=fltp:sample_rates=48000:channel_layouts=stereo";
+    const silence = (ms) => `anullsrc=r=48000:cl=stereo,atrim=duration=${sec(ms)},${fmtA}`;
+    const pieces = [];
+    const out = [];
+    const parts = [];
+    if (lead + first.t > 0.5) parts.push(silence(lead + first.t));
+    const played = [];
+    for (let i = 0; i + 1 < pts.length; i++) {
+      const dt = pts[i + 1].t - pts[i].t;
+      if (dt < 0.5) continue;
+      const speed = (pts[i + 1].v - pts[i].v) / dt;
+      if (speed < 0.1) parts.push(silence(dt));
+      else {
+        played.push({ from: pts[i].v - first.v, to: pts[i + 1].v - first.v, speed });
+        parts.push(`#${played.length - 1}`);
+      }
+    }
+    if (end - last.t > 0.5) parts.push(silence(end - last.t));
+    if (played.length) out.push(`[${input2}]asplit=${played.length}${played.map((_, k2) => `[r${n2}s${k2}]`).join("")}`);
+    parts.forEach((p, k2) => {
+      const label = `[r${n2}p${k2}]`;
+      if (p.startsWith("#")) {
+        const piece = played[Number(p.slice(1))];
+        out.push(`[r${n2}s${p.slice(1)}]atrim=start=${sec(piece.from)}:end=${sec(piece.to)},asetpts=PTS-STARTPTS,${atempo(piece.speed).join(",") || "anull"},${fmtA}${label}`);
+      } else out.push(`${p}${label}`);
+      pieces.push(label);
+    });
+    out.push(`${pieces.join("")}concat=n=${pieces.length}:v=0:a=1${output}`);
+    return out;
+  };
+  const blended = /* @__PURE__ */ new Set();
+  let k = 0;
+  const step = 2e3 / fps;
+  const expr = (prop, clipTime, fallback, what) => {
+    if (isVideoKeyframes(prop)) animated.add(what);
+    return videoKeyframeFfmpegExpr(prop, clipTime, fallback, step);
+  };
+  const input = (clip, asset, lead, tail) => {
+    const speed = videoClipSpeed(clip);
+    const src = options.resolve ? options.resolve(asset) : asset.src;
+    const span = clip.duration + lead + tail;
+    if (asset.kind === "image") inputs.push(["-loop", "1", "-framerate", String(fps), "-t", sec(span), "-i", src]);
+    else if (clip.timeRemap) {
+      const { from, to } = videoTimeRemapSpan(clip.timeRemap);
+      inputs.push(["-ss", sec((_nullishCoalesce(clip.in, () => ( 0))) + from), "-t", sec(to - from + 1e3 / fps), "-i", src]);
+    } else inputs.push(["-ss", sec((_nullishCoalesce(clip.in, () => ( 0))) - lead * speed), "-t", sec(span * speed), "-i", src]);
+    return inputs.length - 1;
+  };
+  let ak = 0;
+  let q = 0;
+  const compose = (tracks, base, length, scope) => {
+    let cur2 = base;
+    const sounds = [];
+    for (const track of [...tracks].reverse()) {
+      for (const raw of sortedVideoClips(track)) {
+        const clip = videoClipAnimated(raw, project);
+        const { lead, tail } = videoClipOverhang(track, clip);
+        const t0 = clip.start - lead;
+        const span = clip.duration + lead + tail;
+        const end = videoClipEnd(clip);
+        const asset = clip.type === "media" ? assets.get(clip.asset) : void 0;
+        if (clip.type === "media" && !asset) {
+          notes.push(`Clip "${clip.id}" was left out: its asset "${clip.asset}" is missing.`);
+          continue;
+        }
+        const shows = scope.picture && track.kind === "video" && !track.hidden;
+        let compound = null;
+        if (clip.type === "sequence") {
+          const seq = sequences.get(clip.sequence);
+          if (!seq || scope.within.includes(seq.id)) {
+            notes.push(`Compound clip "${clip.id}" was left out: its sequence "${clip.sequence}" ${seq ? "contains itself" : "is missing"}.`);
+            continue;
+          }
+          const from = (_nullishCoalesce(clip.in, () => ( 0))) - lead;
+          if (from < -0.5) notes.push(`Compound clip "${clip.id}"'s transition needs ${Math.round(-from)} ms of sequence "${seq.id}" before its start, which is not there; it shows nothing then.`);
+          const length2 = Math.max(videoSequenceDuration(seq), from + span);
+          const hears = scope.sound && !clip.muted && !track.muted;
+          const n2 = q++;
+          const nestedBase = shows ? `nb${n2}` : null;
+          if (nestedBase) graph.push(`color=c=black@0:s=${W}x${H}:r=${fps}:d=${sec(length2)},format=yuva420p[${nestedBase}]`);
+          const sub = compose(seq.tracks, nestedBase, length2, { within: [...scope.within, seq.id], picture: shows, sound: hears });
+          compound = { picture: null, sound: null };
+          if (sub.video) {
+            graph.push(`[${sub.video}]trim=start=${sec(Math.max(0, from))}:duration=${sec(span)},setpts=PTS-STARTPTS[sq${n2}]`);
+            compound.picture = `[sq${n2}]`;
+          }
+          if (sub.audio.length) {
+            graph.push(`${sub.audio.join("")}amix=inputs=${sub.audio.length}:normalize=0:duration=longest,apad,atrim=start=${sec(Math.max(0, from))}:end=${sec(from + span)}[sm${n2}]`);
+            compound.sound = `[sm${n2}]`;
+          }
+        }
+        let index;
+        if (shows && asset && asset.kind !== "audio") index = input(clip, asset, lead, tail);
+        const audible = clip.type === "sequence" ? !!_optionalChain([compound, 'optionalAccess', _41 => _41.sound]) : videoAssetHasSound(asset);
+        if (scope.sound && audible && (clip.type === "media" || clip.type === "sequence") && !clip.muted && !track.muted) {
+          const trackGain = _nullishCoalesce(track.volume, () => ( 1));
+          const volume = isVideoKeyframes(clip.volume) ? `volume='${trackGain}*(${expr(clip.volume, `(t*1000${lead ? `-${Math.round(lead)}` : ""})`, 1, "volume")})':eval=frame` : `volume=${(_nullishCoalesce(clip.volume, () => ( 1))) * trackGain}`;
+          const ramp = clip.type === "media" ? clip.timeRemap : void 0;
+          const ai = compound ? -1 : _nullishCoalesce(index, () => ( input(clip, asset, lead, tail)));
+          let source2 = _nullishCoalesce(_optionalChain([compound, 'optionalAccess', _42 => _42.sound]), () => ( `[${ai}:a]`));
+          if (ramp) {
+            source2 = `[r${ak}]`;
+            graph.push(...rampedSound(ramp, `${ai}:a`, source2, lead, clip.duration + tail));
+            ramped.add("sound");
+          }
+          const chain2 = [...ramp ? [] : ["asetpts=PTS-STARTPTS", ...atempo(videoClipSpeed(clip))], volume];
+          const before2 = clip.transition ? videoClipBefore(track, clip) : null;
+          const next2 = sortedVideoClips(track).find((c) => c !== clip && Math.abs(c.start - end) < 0.5 && c.transition);
+          const inCurve = clip.transition ? afadeCurve(videoTransitionAudioCurve(clip.transition)) : "";
+          const outCurve = next2 ? afadeCurve(videoTransitionAudioCurve(next2.transition)) : "";
+          if (lead) chain2.push(`afade=t=in:st=0:d=${sec(2 * lead)}${inCurve}`);
+          if (tail) chain2.push(`afade=t=out:st=${sec(span - 2 * tail)}:d=${sec(2 * tail)}${outCurve}`);
+          if (before2 && clip.transition.type === "dip") chain2.push(`afade=t=in:st=0:d=${sec(clip.transition.duration / 2)}${inCurve}`);
+          if (_optionalChain([next2, 'optionalAccess', _43 => _43.transition, 'access', _44 => _44.type]) === "dip") chain2.push(`afade=t=out:st=${sec(span - next2.transition.duration / 2)}:d=${sec(next2.transition.duration / 2)}${outCurve}`);
+          if (clip.fadeIn) chain2.push(`afade=t=in:st=${sec(lead)}:d=${sec(clip.fadeIn)}${afadeCurve(clip.fadeInCurve)}`);
+          if (clip.fadeOut) chain2.push(`afade=t=out:st=${sec(lead + clip.duration - clip.fadeOut)}:d=${sec(clip.fadeOut)}${afadeCurve(clip.fadeOutCurve)}`);
+          chain2.push(`adelay=${Math.round(t0)}:all=1`);
+          graph.push(`${source2}${chain2.join(",")}[a${ak}]`);
+          sounds.push(`[a${ak++}]`);
+        }
+        if (!shows || compound && !compound.picture) continue;
+        const enable = `enable='between(t,${sec(t0)},${sec(t0 + span)})'`;
+        const next = `v${k++}`;
+        const onTimeline = `(t*1000-${Math.round(clip.start)})`;
+        const onChain = (v) => `(${v}*1000${lead ? `-${Math.round(lead)}` : ""})`;
+        const tf = clip.transform;
+        const moving = VIDEO_TRANSFORM_PROPERTIES.some((p) => isVideoKeyframes(_optionalChain([tf, 'optionalAccess', _45 => _45[p]])));
+        if (clip.type === "text" && options.titleImage) {
+          inputs.push(["-loop", "1", "-framerate", String(fps), "-t", sec(span), "-i", options.titleImage(moving ? { ...clip, transform: void 0 } : clip, { width: project.width, height: project.height })]);
+          index = inputs.length - 1;
+        } else if (clip.type === "text") {
+          usesDrawtext = true;
+          if (scope.within.length) notes.push(`Title "${clip.id}" is inside a compound clip and drawn with drawtext, which leaves the sequence's transparent areas transparent, so it shows only over pictures in the sequence; pass titleImage to draw it anywhere.`);
+          const op = isVideoKeyframes(clip.opacity) ? `clip(${expr(clip.opacity, onTimeline, 1, "opacity")},0,1)` : String(_nullishCoalesce(clip.opacity, () => ( 1)));
+          const alpha = [op, clip.fadeIn ? `min(1,(t-${sec(clip.start)})/${sec(clip.fadeIn)})` : "", clip.fadeOut ? `min(1,(${sec(end)}-t)/${sec(clip.fadeOut)})` : ""].filter(Boolean).join("*");
+          const coord = (axis) => {
+            const v = _optionalChain([tf, 'optionalAccess', _46 => _46[axis]]);
+            const base2 = `(${axis === "x" ? "w-text_w" : "h-text_h"})/2`;
+            return isVideoKeyframes(v) ? `${axis}='${base2}+(${expr(v, onTimeline, 0, "position")})'` : `${axis}=${base2}+${_nullishCoalesce(v, () => ( 0))}`;
+          };
+          const fontSize = _nullishCoalesce(clip.fontSize, () => ( 64));
+          const opts = [
+            `text=${ffmpegFilterValue(clip.text)}`,
+            options.fontFile ? `fontfile=${ffmpegFilterValue(options.fontFile)}` : `font=${ffmpegFilterValue(_nullishCoalesce(clip.fontFamily, () => ( "sans-serif")))}`,
+            isVideoKeyframes(_optionalChain([tf, 'optionalAccess', _47 => _47.scale])) ? `fontsize='${fontSize}*(${expr(tf.scale, onTimeline, 1, "scale")})'` : `fontsize=${Math.round(fontSize * (_nullishCoalesce(_optionalChain([tf, 'optionalAccess', _48 => _48.scale]), () => ( 1))))}`,
+            `fontcolor=${color(_nullishCoalesce(clip.color, () => ( "#ffffff")))}`,
+            coord("x"),
+            coord("y"),
+            `alpha='${alpha}'`,
+            ...clip.background ? ["box=1", `boxcolor=${color(clip.background)}`, `boxborderw=${Math.round((_nullishCoalesce(clip.fontSize, () => ( 64))) / 2)}`] : [],
+            `enable='between(t,${sec(clip.start)},${sec(end)})'`
+          ];
+          if (_optionalChain([tf, 'optionalAccess', _49 => _49.rotation])) notes.push(`Title "${clip.id}" is drawn without its rotation (drawtext cannot rotate).`);
+          if (videoGradeFfmpegFilters(clip.grade).length || normalizeVideoGradeLut(_optionalChain([clip, 'access', _50 => _50.grade, 'optionalAccess', _51 => _51.lut]))) notes.push(`Title "${clip.id}" is drawn without its grade (drawtext draws straight onto the picture); pass titleImage to grade titles.`);
+          if (clip.blend && clip.blend !== "normal") notes.push(`Title "${clip.id}" is drawn without its blend mode (drawtext draws straight onto the picture); pass titleImage to blend titles.`);
+          graph.push(`[${cur2}]drawtext=${opts.join(":")}[${next}]`);
+          cur2 = next;
+          continue;
+        }
+        const size = asset ? { width: _nullishCoalesce(asset.width, () => ( project.width)), height: _nullishCoalesce(asset.height, () => ( project.height)) } : { width: project.width, height: project.height };
+        const placed = clip.type === "text" && !moving ? void 0 : tf;
+        const still = Object.fromEntries(Object.entries(_nullishCoalesce(placed, () => ( {}))).filter(([, v]) => !isVideoKeyframes(v)));
+        const rect = placeVideoRect(project, size, clip.type === "text" ? "fill" : _nullishCoalesce(clip.fit, () => ( (clip.type === "media" || clip.type === "sequence" ? "contain" : "fill"))), still);
+        const chain = [];
+        let source;
+        if (clip.type === "color") source = `color=c=${color(clip.color)}:s=${even(rect.width)}x${even(rect.height)}:r=${fps}:d=${sec(span)}`;
+        else if (_optionalChain([compound, 'optionalAccess', _52 => _52.picture])) {
+          source = compound.picture;
+          chain.push(`scale=${even(rect.width)}:${even(rect.height)}`);
+        } else {
+          source = `[${index}:v]`;
+          if (clip.type === "media" && clip.timeRemap) chain.push(...rampedPicture(clip.timeRemap, lead, clip.duration + tail), `scale=${even(rect.width)}:${even(rect.height)}`);
+          else chain.push(`setpts=${videoClipSpeed(clip) !== 1 ? `(PTS-STARTPTS)/${videoClipSpeed(clip)}` : "PTS-STARTPTS"}`, `fps=${fps}`, `scale=${even(rect.width)}:${even(rect.height)}`);
+        }
+        const grade = videoGradeFfmpegFilters(clip.grade);
+        if (grade.length) chain.push("format=rgba", ...grade);
+        const lut = normalizeVideoGradeLut(_optionalChain([clip, 'access', _53 => _53.grade, 'optionalAccess', _54 => _54.lut]));
+        if (lut) {
+          chain.push("format=gbrap");
+          const path = options.resolveLut ? options.resolveLut(lut.src) : lut.src;
+          if (/^(blob|data|https?):/i.test(path)) notes.push(`ffmpeg's lut3d reads only local files, and clip "${clip.id}"'s LUT is "${path.slice(0, 80)}"; save it and pass resolveLut to give its path.`);
+          const file = ffmpegFilterValue(path);
+          const into2 = `q${next}`;
+          graph.push(`${source.startsWith("[") ? source : `${source},`}${chain.join(",")}[${into2}]`);
+          const lut3d = `lut3d=file=${file}:interp=tetrahedral`;
+          if ((_nullishCoalesce(lut.strength, () => ( 1))) >= 1) graph.push(`[${into2}]${lut3d}[r${next}]`);
+          else graph.push(`[${into2}]split[o${next}][p${next}]`, `[p${next}]${lut3d}[s${next}]`, `[s${next}][o${next}]blend=all_mode=normal:all_opacity=${lut.strength}[r${next}]`);
+          source = `[r${next}]`;
+          chain.length = 0;
+        }
+        chain.push("format=yuva420p");
+        if (isVideoKeyframes(clip.opacity)) chain.push(`geq=lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)':a='alpha(X,Y)*clip(${expr(clip.opacity, onChain("T"), 1, "opacity")},0,1)'`);
+        else if (clip.opacity !== void 0 && clip.opacity < 1) chain.push(`colorchannelmixer=aa=${clip.opacity}`);
+        if (clip.fadeIn) chain.push(`fade=t=in:st=${sec(lead)}:d=${sec(clip.fadeIn)}:alpha=1`);
+        if (clip.fadeOut) chain.push(`fade=t=out:st=${sec(lead + clip.duration - clip.fadeOut)}:d=${sec(clip.fadeOut)}:alpha=1`);
+        if (lead && clip.transition.type === "crossfade") chain.push(`fade=t=in:st=0:d=${sec(2 * lead)}:alpha=1`);
+        if (lead && clip.transition.type === "wipe") {
+          const d = sec(2 * lead);
+          const p = `min(1,T/${d})`;
+          const dir = _nullishCoalesce(clip.transition.direction, () => ( "right"));
+          const test = dir === "right" ? `lt(X,W*${p})` : dir === "left" ? `gt(X,W*(1-${p}))` : dir === "down" ? `lt(Y,H*${p})` : `gt(Y,H*(1-${p}))`;
+          chain.push(`geq=lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)':a='if(${test},alpha(X,Y),0)'`);
+        }
+        if (lead && clip.transition.type === "iris") {
+          const r = videoIrisRadius({ width: W, height: H }, 1);
+          chain.push(`geq=lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)':a='if(lte(hypot(X+${Math.round(rect.x)}-${W / 2},Y+${Math.round(rect.y)}-${H / 2}),${Math.round(r)}*min(1,T/${sec(2 * lead)})),alpha(X,Y),0)'`);
+        }
+        const rotation = _optionalChain([placed, 'optionalAccess', _55 => _55.rotation]);
+        if (isVideoKeyframes(rotation)) chain.push(`rotate=a='(${expr(rotation, onChain("t"), 0, "rotation")})*PI/180':c=black@0:ow='hypot(iw,ih)':oh=ow`);
+        else if (rotation) chain.push(`rotate=${rotation}*PI/180:c=black@0:ow=rotw(${rotation}*PI/180):oh=roth(${rotation}*PI/180)`);
+        if (isVideoKeyframes(_optionalChain([placed, 'optionalAccess', _56 => _56.scale]))) {
+          const s = expr(placed.scale, onChain("t"), 1, "scale");
+          chain.push(`scale=w='max(2,trunc(iw*(${s})/2)*2)':h='max(2,trunc(ih*(${s})/2)*2)':eval=frame`);
+        }
+        chain.push(`setpts=PTS+${sec(t0)}/TB`);
+        const cx = rect.x + rect.width / 2;
+        const cy = rect.y + rect.height / 2;
+        const shifts = { x: [], y: [] };
+        const shiftBy = (direction, from, d, entering) => {
+          const dir = _nullishCoalesce(direction, () => ( "right"));
+          const axis = dir === "left" || dir === "right" ? "x" : "y";
+          const size2 = axis === "x" ? W : H;
+          const sign = dir === "left" || dir === "up" ? -1 : 1;
+          const ease = `(1-cos(PI*clip((t-${sec(from)})/${sec(d)},0,1)))/2`;
+          shifts[axis].push(`${sign * size2}*(${ease}${entering ? "-1" : ""})`);
+        };
+        const into = lead ? clip.transition.type : void 0;
+        if (into === "push" || into === "slide") shiftBy(clip.transition.direction, clip.start - lead, 2 * lead, true);
+        const after = tail ? sortedVideoClips(track).find((c) => c !== clip && Math.abs(c.start - end) < 0.5 && c.transition) : void 0;
+        if (_optionalChain([after, 'optionalAccess', _57 => _57.transition, 'access', _58 => _58.type]) === "push") shiftBy(after.transition.direction, end - tail, 2 * tail, false);
+        const at = (axis, c) => {
+          const v = _optionalChain([placed, 'optionalAccess', _59 => _59[axis]]);
+          const extra = shifts[axis].map((s) => `+${s}`).join("");
+          return isVideoKeyframes(v) ? `${axis}='${Math.round(axis === "x" ? project.width / 2 : project.height / 2)}+(${expr(v, onTimeline, 0, "position")})-${axis === "x" ? "w" : "h"}/2${extra}'` : `${axis}='${Math.round(c)}-${axis === "x" ? "w" : "h"}/2${extra}'`;
+        };
+        graph.push(`${source.startsWith("[") ? source : `${source},`}${chain.join(",")}[l${next}]`);
+        if (clip.blend && clip.blend !== "normal") {
+          graph.push(`color=c=black@0:s=${W}x${H}:r=${fps}:d=${sec(length)},format=yuva420p[t${next}]`);
+          const clear = scope.within.length > 0;
+          graph.push(`[t${next}][l${next}]overlay=${at("x", cx)}:${at("y", cy)}:eof_action=pass:${enable},format=gbrap,split${clear ? `=3` : ""}[f${next}][g${next}]${clear ? `[h${next}]` : ""}`);
+          graph.push(`[${cur2}]format=gbrap,split${clear ? `=3` : ""}[c${next}][d${next}]${clear ? `[e${next}]` : ""}`);
+          const layerFirst = clip.blend === "color-dodge" || clip.blend === "color-burn";
+          graph.push(`${layerFirst ? `[f${next}][c${next}]` : `[c${next}][f${next}]`}blend=all_mode=${FFMPEG_BLEND[clip.blend]}[b${next}]`);
+          graph.push(`[g${next}]alphaextract[m${next}]`);
+          if (clear) {
+            graph.push(`[e${next}]alphaextract[ea${next}]`);
+            graph.push(`[b${next}][ea${next}]alphamerge[bb${next}]`);
+            graph.push(`[h${next}]format=gbrp[ho${next}]`);
+            graph.push(`[ho${next}][bb${next}]overlay=format=gbrp[bm${next}]`);
+            graph.push(`[bm${next}][m${next}]alphamerge[x${next}]`);
+          } else graph.push(`[b${next}][m${next}]alphamerge[x${next}]`);
+          graph.push(`[d${next}][x${next}]overlay=format=gbrp,format=yuva420p[${next}]`);
+          blended.add(clip.blend);
+        } else graph.push(`[${cur2}][l${next}]overlay=${at("x", cx)}:${at("y", cy)}:eof_action=pass:${enable}[${next}]`);
+        cur2 = next;
+        const before = clip.transition ? videoClipBefore(track, clip) : null;
+        if (before && clip.transition.type === "dip") {
+          const d = clip.transition.duration;
+          const dip = `d${k}`;
+          graph.push(`color=c=${color(_nullishCoalesce(clip.transition.color, () => ( "#000000")))}:s=${W}x${H}:r=${fps}:d=${sec(d)},format=yuva420p,fade=t=in:st=0:d=${sec(d / 2)}:alpha=1,fade=t=out:st=${sec(d / 2)}:d=${sec(d / 2)}:alpha=1,setpts=PTS+${sec(clip.start - d / 2)}/TB[l${dip}]`);
+          graph.push(`[${cur2}][l${dip}]overlay=eof_action=pass:enable='between(t,${sec(clip.start - d / 2)},${sec(clip.start + d / 2)})'[${dip}]`);
+          cur2 = dip;
+        }
+      }
+    }
+    return { video: cur2, audio: sounds };
+  };
+  const top = compose(project.tracks, measure ? null : "base", D, { within: [], picture: !measure, sound: true });
+  const audio = top.audio;
+  const cur = top.video;
+  if (!measure) graph.push(`[${cur}]format=yuv420p[vout]`);
+  if (measure && !audio.length) throw new Error("Nothing on the timeline makes a sound, so there is no loudness to measure.");
+  const loudness = options.loudness || measure ? `,${loudnormFilter(options.loudness, measure)}` : "";
+  if (audio.length) graph.push(`${audio.join("")}amix=inputs=${audio.length}:normalize=0:duration=longest,apad,atrim=0:${sec(D)}${loudness}[aout]`);
+  if (options.loudness && !audio.length) notes.push("Nothing makes a sound, so there was no loudness to normalise.");
+  else if (options.loudness && !options.loudness.measured)
+    notes.push("Loudness is normalised in one pass, which adjusts the level as it goes; for a fixed gain that keeps the dynamics, run toVideoLoudnessMeasure first and pass its result as loudness.measured.");
+  if (allVideoTracks(project).some(({ track: t }) => t.clips.some((c) => c.type === "media" && _optionalChain([assets, 'access', _60 => _60.get, 'call', _61 => _61(c.asset), 'optionalAccess', _62 => _62.kind]) === "video" && _optionalChain([assets, 'access', _63 => _63.get, 'call', _64 => _64(c.asset), 'optionalAccess', _65 => _65.hasAudio]) === void 0)))
+    notes.push('Video assets are assumed to have sound; set "hasAudio": false on any that do not, or ffmpeg will stop at a missing audio stream.');
+  if (animated.size)
+    notes.push(`Keyframed ${[...animated].sort().join(", ")} ${animated.size > 1 ? "are" : "is"} rendered as straight lines between keys, with eased segments sampled every two frames${animated.has("scale") ? "; animated scale needs ffmpeg 5 or later (scale with eval=frame)" : ""}.`);
+  if (blended.has("soft-light")) notes.push("ffmpeg's soft-light blend uses a slightly different formula from the browser's, so the render can differ a little from the preview.");
+  if (ramped.has("sound")) notes.push("Sound through a speed ramp plays each stretch at its own speed, so a gliding change is heard in small steps (about every 80 ms), and freezes are silent.");
+  if (usesDrawtext) notes.push("Titles use drawtext, which needs an ffmpeg built with libfreetype (Homebrew's is not: check `ffmpeg -filters | grep drawtext`); pass titleImage to render them as images instead.");
+  const filterComplex = graph.join(";");
+  if (measure) {
+    const args2 = ["-hide_banner", "-nostats", ...inputs.flat(), "-filter_complex", filterComplex, "-map", "[aout]", "-f", "null", "-"];
+    return { args: args2, command: ["ffmpeg", ...args2].map(videoShellQuote).join(" "), filterComplex, duration: D, notes };
+  }
+  const args = [
+    "-y",
+    ...inputs.flat(),
+    "-filter_complex",
+    filterComplex,
+    "-map",
+    "[vout]",
+    ...audio.length ? ["-map", "[aout]", "-c:a", _nullishCoalesce(options.audioCodec, () => ( "aac"))] : ["-an"],
+    "-c:v",
+    _nullishCoalesce(options.videoCodec, () => ( "libx264")),
+    ...(_nullishCoalesce(options.videoCodec, () => ( "libx264"))) === "libx264" ? ["-crf", String(_nullishCoalesce(options.crf, () => ( 18))), "-preset", "medium"] : [],
+    "-pix_fmt",
+    "yuv420p",
+    "-r",
+    String(fps),
+    "-t",
+    sec(D),
+    _nullishCoalesce(options.output, () => ( "output.mp4"))
+  ];
+  return { args, command: ["ffmpeg", ...args].map(videoShellQuote).join(" "), filterComplex, duration: D, notes };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.VIDEO_FITS = VIDEO_FITS; exports.VIDEO_TRANSITION_TYPES = VIDEO_TRANSITION_TYPES; exports.VIDEO_WIPE_DIRECTIONS = VIDEO_WIPE_DIRECTIONS; exports.videoTransitionAudioCurve = videoTransitionAudioCurve; exports.VIDEO_BLEND_MODES = VIDEO_BLEND_MODES; exports.VIDEO_CLIP_ANIMATION_EFFECTS = VIDEO_CLIP_ANIMATION_EFFECTS; exports.VIDEO_FADE_CURVES = VIDEO_FADE_CURVES; exports.VIDEO_PLACEMENT_MODES = VIDEO_PLACEMENT_MODES; exports.VIDEO_CLIP_TYPES = VIDEO_CLIP_TYPES; exports.VIDEO_EASE_NAMES = VIDEO_EASE_NAMES; exports.VIDEO_KEYFRAME_PROPERTIES = VIDEO_KEYFRAME_PROPERTIES; exports.VIDEO_TRANSFORM_PROPERTIES = VIDEO_TRANSFORM_PROPERTIES; exports.VIDEO_KEYFRAME_LIMITS = VIDEO_KEYFRAME_LIMITS; exports.isVideoKeyframes = isVideoKeyframes; exports.videoEaseBezier = videoEaseBezier; exports.videoEaseProgress = videoEaseProgress; exports.videoValueAt = videoValueAt; exports.videoKeysOf = videoKeysOf; exports.retimeVideoAnimatable = retimeVideoAnimatable; exports.splitVideoAnimatable = splitVideoAnimatable; exports.sortVideoKeys = sortVideoKeys; exports.setVideoKey = setVideoKey; exports.removeVideoKey = removeVideoKey; exports.videoKeyframeBreakpoints = videoKeyframeBreakpoints; exports.videoKeyframeFfmpegExpr = videoKeyframeFfmpegExpr; exports.VIDEO_LUT_MAX_SIZE = VIDEO_LUT_MAX_SIZE; exports.parseVideoCubeLut = parseVideoCubeLut; exports.videoLutFromFunction = videoLutFromFunction; exports.videoLutToCube = videoLutToCube; exports.applyVideoLut = applyVideoLut; exports.applyVideoLutToPixels = applyVideoLutToPixels; exports.videoLutSvgApproximation = videoLutSvgApproximation; exports.VideoLutCache = VideoLutCache; exports.VIDEO_GRADE_CONTROLS = VIDEO_GRADE_CONTROLS; exports.VIDEO_GRADE_PRESETS = VIDEO_GRADE_PRESETS; exports.VIDEO_GRADE_PRESET_NAMES = VIDEO_GRADE_PRESET_NAMES; exports.normalizeVideoGradeLut = normalizeVideoGradeLut; exports.normalizeVideoGrade = normalizeVideoGrade; exports.videoGradePreset = videoGradePreset; exports.videoGradeLook = videoGradeLook; exports.videoGradeSteps = videoGradeSteps; exports.videoGradeStepMatrix = videoGradeStepMatrix; exports.applyVideoGrade = applyVideoGrade; exports.videoGradeStepSvgValues = videoGradeStepSvgValues; exports.videoLutSvgPrimitives = videoLutSvgPrimitives; exports.videoGradeSvgFilter = videoGradeSvgFilter; exports.videoGradeGainsFilterId = videoGradeGainsFilterId; exports.videoGradeCssFilter = videoGradeCssFilter; exports.videoGradeSvgDefs = videoGradeSvgDefs; exports.videoGradeFfmpegFilters = videoGradeFfmpegFilters; exports.videoClipSourceTime = videoClipSourceTime; exports.videoClipSpeedAt = videoClipSpeedAt; exports.videoSpeedRampKeys = videoSpeedRampKeys; exports.checkVideoTimeRemap = checkVideoTimeRemap; exports.videoTimeRemapSpan = videoTimeRemapSpan; exports.videoTimeRemapBreakpoints = videoTimeRemapBreakpoints; exports.videoSpeedRampEdit = videoSpeedRampEdit; exports.videoFreezeFrameEdit = videoFreezeFrameEdit; exports.videoSlowMotionRamp = videoSlowMotionRamp; exports.VIDEO_TIME_EPSILON = VIDEO_TIME_EPSILON; exports.videoClipEnd = videoClipEnd; exports.videoTrackSyncLocked = videoTrackSyncLocked; exports.videoClipSpeed = videoClipSpeed; exports.videoClipSourceRange = videoClipSourceRange; exports.videoFrameDuration = videoFrameDuration; exports.snapToVideoFrame = snapToVideoFrame; exports.videoFrames = videoFrames; exports.isVideoDropFrameRate = isVideoDropFrameRate; exports.videoTimecodeFrames = videoTimecodeFrames; exports.formatVideoTimecode = formatVideoTimecode; exports.formatVideoTimecodeFrames = formatVideoTimecodeFrames; exports.videoHourFrames = videoHourFrames; exports.formatVideoSeconds = formatVideoSeconds; exports.videoAssetHasSound = videoAssetHasSound; exports.videoAssetMap = videoAssetMap; exports.videoSequenceMap = videoSequenceMap; exports.videoSequenceDuration = videoSequenceDuration; exports.videoSequenceChildren = videoSequenceChildren; exports.findVideoSequenceCycle = findVideoSequenceCycle; exports.allVideoTracks = allVideoTracks; exports.sortedVideoClips = sortedVideoClips; exports.findVideoClip = findVideoClip; exports.allVideoClipIds = allVideoClipIds; exports.findVideoSequenceClip = findVideoSequenceClip; exports.videoProjectDuration = videoProjectDuration; exports.videoClipBefore = videoClipBefore; exports.videoClipAfter = videoClipAfter; exports.videoClipHandles = videoClipHandles; exports.videoClipOverhang = videoClipOverhang; exports.videoSnapPoints = videoSnapPoints; exports.snapVideoTime = snapVideoTime; exports.findVideoGaps = findVideoGaps; exports.videoOverlap = videoOverlap; exports.nextFreeVideoSlot = nextFreeVideoSlot; exports.videoClipsAt = videoClipsAt; exports.VIDEO_CLIP_ANIMATION_DURATION = VIDEO_CLIP_ANIMATION_DURATION; exports.videoClipAnimationProperties = videoClipAnimationProperties; exports.videoClipAnimationSpans = videoClipAnimationSpans; exports.videoClipAnimated = videoClipAnimated; exports.videoTransformAt = videoTransformAt; exports.placeVideoRect = placeVideoRect; exports.videoTextStyle = videoTextStyle; exports.videoTitleFrame = videoTitleFrame; exports.videoTransitionEase = videoTransitionEase; exports.videoFadeCurveGain = videoFadeCurveGain; exports.videoClipSoundGain = videoClipSoundGain; exports.videoFrameAt = videoFrameAt; exports.videoFrameLeafLayers = videoFrameLeafLayers; exports.videoIrisRadius = videoIrisRadius; exports.videoWipeRect = videoWipeRect; exports.videoFrameToSvg = videoFrameToSvg; exports.videoProjectSvg = videoProjectSvg; exports.videoContactSheetSvg = videoContactSheetSvg; exports.drawVideoFrame = drawVideoFrame; exports.toVideoEdl = toVideoEdl; exports.parseVideoLoudnessMeasurement = parseVideoLoudnessMeasurement; exports.ffmpegFilterValue = ffmpegFilterValue; exports.videoShellQuote = videoShellQuote; exports.toVideoFfmpeg = toVideoFfmpeg; exports.toVideoLoudnessMeasure = toVideoLoudnessMeasure;
+//# sourceMappingURL=chunk-SMJGE7HM.cjs.map