@pixerate/flair 0.24.0 → 0.26.0

package/dist/chunk-UCZ43ARE.js

@@ -0,0 +1,902 @@
+import {
+  ShaderFrames,
+  ShaderRenderer
+} from "./chunk-H6VDFBIO.js";
+import {
+  seekVideo
+} from "./chunk-RDU63CDO.js";
+import {
+  effectDefaults,
+  effectInputs,
+  getEffect,
+  renderVectorEffect,
+  textImage
+} from "./chunk-HVXWNGTW.js";
+import {
+  parseColor
+} from "./chunk-VYOMXE6I.js";
+import {
+  SvgPlayer,
+  svgDuration,
+  svgView
+} from "./chunk-PFGGPIMT.js";
+
+// src/export/mp4mux.ts
+var MOVIE_TIMESCALE = 1e3;
+var UINT32 = 4294967296;
+var ascii = (s) => Uint8Array.from(s, (c) => c.charCodeAt(0));
+var Writer = class {
+  parts = [];
+  size = 0;
+  bytes(b) {
+    this.parts.push(b);
+    this.size += b.length;
+    return this;
+  }
+  u8(n) {
+    return this.bytes(Uint8Array.of(n & 255));
+  }
+  u16(n) {
+    return this.bytes(Uint8Array.of(n >>> 8 & 255, n & 255));
+  }
+  u32(n) {
+    const b = new Uint8Array(4);
+    new DataView(b.buffer).setUint32(0, n >>> 0);
+    return this.bytes(b);
+  }
+  u64(n) {
+    return this.u32(Math.floor(n / UINT32)).u32(n % UINT32);
+  }
+  zeros(n) {
+    return this.bytes(new Uint8Array(n));
+  }
+  done() {
+    const out = new Uint8Array(this.size);
+    let at = 0;
+    for (const p of this.parts) {
+      out.set(p, at);
+      at += p.length;
+    }
+    return out;
+  }
+};
+function box(type, ...content) {
+  const w = new Writer();
+  const size = 8 + content.reduce((n, c) => n + c.length, 0);
+  w.u32(size).bytes(ascii(type));
+  for (const c of content) w.bytes(c);
+  return w.done();
+}
+function fullBox(type, version, flags, ...content) {
+  return box(type, Uint8Array.of(version, flags >> 16 & 255, flags >> 8 & 255, flags & 255), ...content);
+}
+var fields = (fill) => {
+  const w = new Writer();
+  fill(w);
+  return w.done();
+};
+var MATRIX = fields((w) => [65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824].forEach((n) => w.u32(n)));
+function sampleTicks(samples, timescale) {
+  const tick = (us) => Math.round(us * timescale / 1e6);
+  return samples.map((s, i) => {
+    const next = samples[i + 1];
+    if (next) return Math.max(1, tick(next.timestamp) - tick(s.timestamp));
+    if (s.duration) return Math.max(1, tick(s.duration));
+    const prev = samples[i - 1];
+    return prev ? Math.max(1, tick(s.timestamp) - tick(prev.timestamp)) : Math.max(1, tick(1e6 / 30));
+  });
+}
+function stts(ticks) {
+  const runs = [];
+  for (const t of ticks) {
+    const last = runs[runs.length - 1];
+    if (last && last[1] === t) last[0]++;
+    else runs.push([1, t]);
+  }
+  return fullBox("stts", 0, 0, fields((w) => {
+    w.u32(runs.length);
+    for (const [count, delta] of runs) w.u32(count).u32(delta);
+  }));
+}
+function moov(options, ticks, dataOffset, wide) {
+  const { width, height, avcC, samples } = options;
+  const timescale = options.timescale ?? 9e4;
+  const trackTicks = ticks.reduce((a, b) => a + b, 0);
+  const movieTicks = Math.round(trackTicks * MOVIE_TIMESCALE / timescale);
+  const mvhd = fullBox("mvhd", 0, 0, fields(
+    (w) => w.u32(0).u32(0).u32(MOVIE_TIMESCALE).u32(movieTicks).u32(65536).u16(256).zeros(10).bytes(MATRIX).zeros(24).u32(2)
+    // pre_defined, next track id
+  ));
+  const tkhd = fullBox("tkhd", 0, 3, fields(
+    (w) => (
+      // enabled, in the movie
+      w.u32(0).u32(0).u32(1).u32(0).u32(movieTicks).zeros(8).u16(0).u16(0).u16(0).u16(0).bytes(MATRIX).u32(width * 65536).u32(height * 65536)
+    )
+  ));
+  const mdhd = fullBox("mdhd", 0, 0, fields((w) => w.u32(0).u32(0).u32(timescale).u32(trackTicks).u16(21956).u16(0)));
+  const hdlr = fullBox("hdlr", 0, 0, fields((w) => w.u32(0).bytes(ascii("vide")).zeros(12).bytes(ascii("VideoHandler\0"))));
+  const vmhd = fullBox("vmhd", 0, 1, new Uint8Array(8));
+  const dinf = box("dinf", fullBox("dref", 0, 0, fields((w) => w.u32(1)), fullBox("url ", 0, 1)));
+  const avc1 = box(
+    "avc1",
+    fields(
+      (w) => w.zeros(6).u16(1).zeros(16).u16(width).u16(height).u32(4718592).u32(4718592).u32(0).u16(1).zeros(32).u16(24).u16(65535)
+      // compressor name, depth, pre_defined
+    ),
+    box("avcC", avcC)
+  );
+  const stsd = fullBox("stsd", 0, 0, fields((w) => w.u32(1)), avc1);
+  const keys = samples.flatMap((s, i) => s.key ? [i + 1] : []);
+  const stss = keys.length === samples.length ? [] : [fullBox("stss", 0, 0, fields((w) => {
+    w.u32(keys.length);
+    for (const k of keys) w.u32(k);
+  }))];
+  const stsz = fullBox("stsz", 0, 0, fields((w) => {
+    w.u32(0).u32(samples.length);
+    for (const s of samples) w.u32(s.data.length);
+  }));
+  const stsc = fullBox("stsc", 0, 0, fields((w) => samples.length ? w.u32(1).u32(1).u32(samples.length).u32(1) : w.u32(0)));
+  const stco = wide ? fullBox("co64", 0, 0, fields((w) => w.u32(1).u64(dataOffset))) : fullBox("stco", 0, 0, fields((w) => w.u32(1).u32(dataOffset)));
+  const stbl = box("stbl", stsd, stts(ticks), ...stss, stsz, stsc, stco);
+  const minf = box("minf", vmhd, dinf, stbl);
+  const trak = box("trak", tkhd, box("mdia", mdhd, hdlr, minf));
+  return box("moov", mvhd, trak);
+}
+function muxMp4(options) {
+  const { samples } = options;
+  if (!samples.length) throw new Error("An MP4 needs at least one frame.");
+  if (!samples[0].key) throw new Error("An MP4's first frame must be a keyframe.");
+  const ftyp = box("ftyp", ascii("isom"), fields((w) => w.u32(512)), ascii("isomiso2avc1mp41"));
+  const ticks = sampleTicks(samples, options.timescale ?? 9e4);
+  const payload = samples.reduce((n, s) => n + s.data.length, 0);
+  const large = payload + 8 >= UINT32;
+  const mdatHeader = large ? 16 : 8;
+  const wide = ftyp.length + moov(options, ticks, 0, large).length + mdatHeader + payload >= UINT32;
+  const index = moov(options, ticks, 0, wide);
+  const dataOffset = ftyp.length + index.length + mdatHeader;
+  const head = fields((w) => {
+    w.bytes(ftyp).bytes(moov(options, ticks, dataOffset, wide));
+    if (large) w.u32(1).bytes(ascii("mdat")).u64(payload + 16);
+    else w.u32(payload + 8).bytes(ascii("mdat"));
+  });
+  const out = new Uint8Array(head.length + payload);
+  out.set(head);
+  let at = head.length;
+  for (const s of samples) {
+    out.set(s.data, at);
+    at += s.data.length;
+  }
+  return out;
+}
+
+// src/export/webmmux.ts
+var ID = {
+  EBML: 440786851,
+  EBMLVersion: 17030,
+  EBMLReadVersion: 17143,
+  EBMLMaxIDLength: 17138,
+  EBMLMaxSizeLength: 17139,
+  DocType: 17026,
+  DocTypeVersion: 17031,
+  DocTypeReadVersion: 17029,
+  Segment: 408125543,
+  Info: 357149030,
+  TimestampScale: 2807729,
+  Duration: 17545,
+  MuxingApp: 19840,
+  WritingApp: 22337,
+  Tracks: 374648427,
+  TrackEntry: 174,
+  TrackNumber: 215,
+  TrackUID: 29637,
+  TrackType: 131,
+  FlagLacing: 156,
+  CodecID: 134,
+  DefaultDuration: 2352003,
+  MaxBlockAdditionID: 21998,
+  Video: 224,
+  PixelWidth: 176,
+  PixelHeight: 186,
+  AlphaMode: 21440,
+  Cluster: 524531317,
+  Timestamp: 231,
+  SimpleBlock: 163,
+  BlockGroup: 160,
+  Block: 161,
+  ReferenceBlock: 251,
+  BlockAdditions: 30113,
+  BlockMore: 166,
+  BlockAddID: 238,
+  BlockAdditional: 165
+};
+var SCALE_NS = 1e6;
+var MAX_OFFSET = 32767;
+var concat = (parts) => {
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let at = 0;
+  for (const p of parts) {
+    out.set(p, at);
+    at += p.length;
+  }
+  return out;
+};
+function idBytes(id) {
+  const out = [];
+  for (let n = id; n > 0; n = Math.floor(n / 256)) out.unshift(n & 255);
+  return Uint8Array.from(out);
+}
+function vint(n) {
+  for (let len = 1; len <= 8; len++) {
+    if (n < 2 ** (7 * len) - 1) {
+      const out = new Uint8Array(len);
+      let v = n;
+      for (let i = len - 1; i >= 0; i--) {
+        out[i] = v % 256;
+        v = Math.floor(v / 256);
+      }
+      out[0] |= 1 << 8 - len;
+      return out;
+    }
+  }
+  throw new RangeError(`An EBML size cannot be ${n}.`);
+}
+var el = (id, ...content) => {
+  const body = concat(content);
+  return concat([idBytes(id), vint(body.length), body]);
+};
+var uint = (id, n) => {
+  const out = [];
+  for (let v = n; v > 0 || out.length === 0; v = Math.floor(v / 256)) out.unshift(v % 256);
+  return el(id, Uint8Array.from(out));
+};
+var float = (id, n) => {
+  const b = new Uint8Array(8);
+  new DataView(b.buffer).setFloat64(0, n);
+  return el(id, b);
+};
+var str = (id, s) => el(id, new TextEncoder().encode(s));
+function blockHeader(offset, flags) {
+  const b = new Uint8Array(4);
+  b[0] = 129;
+  new DataView(b.buffer).setInt16(1, offset);
+  b[3] = flags;
+  return b;
+}
+function muxWebm(options) {
+  const { codec, width, height, frames, fps } = options;
+  if (!frames.length) throw new Error("A WebM needs at least one frame.");
+  if (!frames[0].key) throw new Error("A WebM's first frame must be a keyframe.");
+  const alpha = frames.some((f) => f.alpha);
+  const ms = (us) => Math.round(us / 1e3);
+  const last = frames[frames.length - 1];
+  const frameUs = fps ? 1e6 / fps : frames.length > 1 ? (last.timestamp - frames[0].timestamp) / (frames.length - 1) : 1e6 / 30;
+  const durationUs = options.duration ?? last.timestamp + frameUs;
+  const header = el(
+    ID.EBML,
+    uint(ID.EBMLVersion, 1),
+    uint(ID.EBMLReadVersion, 1),
+    uint(ID.EBMLMaxIDLength, 4),
+    uint(ID.EBMLMaxSizeLength, 8),
+    str(ID.DocType, "webm"),
+    // BlockAdditions came in version 4.
+    uint(ID.DocTypeVersion, alpha ? 4 : 2),
+    uint(ID.DocTypeReadVersion, 2)
+  );
+  const info = el(
+    ID.Info,
+    uint(ID.TimestampScale, SCALE_NS),
+    float(ID.Duration, durationUs / 1e3),
+    str(ID.MuxingApp, "flair"),
+    str(ID.WritingApp, options.app ?? "flair")
+  );
+  const tracks = el(
+    ID.Tracks,
+    el(
+      ID.TrackEntry,
+      uint(ID.TrackNumber, 1),
+      uint(ID.TrackUID, 1),
+      uint(ID.TrackType, 1),
+      // video
+      uint(ID.FlagLacing, 0),
+      str(ID.CodecID, codec === "vp9" ? "V_VP9" : "V_VP8"),
+      ...fps ? [uint(ID.DefaultDuration, Math.round(1e9 / fps))] : [],
+      ...alpha ? [uint(ID.MaxBlockAdditionID, 1)] : [],
+      el(ID.Video, uint(ID.PixelWidth, width), uint(ID.PixelHeight, height), ...alpha ? [uint(ID.AlphaMode, 1)] : [])
+    )
+  );
+  const clusters = [];
+  let blocks = [];
+  let clusterMs = 0;
+  let previousMs = 0;
+  const close = () => {
+    if (blocks.length) clusters.push(el(ID.Cluster, uint(ID.Timestamp, clusterMs), ...blocks));
+    blocks = [];
+  };
+  frames.forEach((frame, i) => {
+    const at = ms(frame.timestamp);
+    if (i === 0 || frame.key || at - clusterMs > MAX_OFFSET) {
+      close();
+      clusterMs = at;
+    }
+    const offset = at - clusterMs;
+    if (frame.alpha) {
+      blocks.push(
+        el(
+          ID.BlockGroup,
+          el(ID.Block, blockHeader(offset, 0), frame.data),
+          el(ID.BlockAdditions, el(ID.BlockMore, uint(ID.BlockAddID, 1), el(ID.BlockAdditional, frame.alpha))),
+          ...frame.key ? [] : [el(ID.ReferenceBlock, signed(previousMs - at))]
+        )
+      );
+    } else {
+      blocks.push(el(ID.SimpleBlock, blockHeader(offset, frame.key ? 128 : 0), frame.data));
+    }
+    previousMs = at;
+  });
+  close();
+  const segment = el(ID.Segment, info, tracks, ...clusters);
+  return concat([header, segment]);
+}
+function signed(n) {
+  for (let len = 1; len <= 8; len++) {
+    if (n >= -(2 ** (8 * len - 1)) && n < 2 ** (8 * len - 1)) {
+      const out = new Uint8Array(len);
+      let v = n < 0 ? 2 ** (8 * len) + n : n;
+      for (let i = len - 1; i >= 0; i--) {
+        out[i] = v % 256;
+        v = Math.floor(v / 256);
+      }
+      return out;
+    }
+  }
+  throw new RangeError(`${n} is out of range.`);
+}
+
+// src/export/zip.ts
+var table;
+function crc32(data) {
+  table ??= Uint32Array.from({ length: 256 }, (_, n) => {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    return c >>> 0;
+  });
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i++) crc = table[(crc ^ data[i]) & 255] ^ crc >>> 8;
+  return (crc ^ 4294967295) >>> 0;
+}
+var DOS_DATE = 0 << 9 | 1 << 5 | 1;
+function zipStore(entries) {
+  const encoder = new TextEncoder();
+  const locals = [];
+  const centrals = [];
+  let offset = 0;
+  for (const { name, data } of entries) {
+    const nameBytes = encoder.encode(name);
+    const crc = crc32(data);
+    const local = new Uint8Array(30 + nameBytes.length);
+    const l = new DataView(local.buffer);
+    l.setUint32(0, 67324752, true);
+    l.setUint16(4, 20, true);
+    l.setUint16(6, 2048, true);
+    l.setUint16(8, 0, true);
+    l.setUint16(10, 0, true);
+    l.setUint16(12, DOS_DATE, true);
+    l.setUint32(14, crc, true);
+    l.setUint32(18, data.length, true);
+    l.setUint32(22, data.length, true);
+    l.setUint16(26, nameBytes.length, true);
+    local.set(nameBytes, 30);
+    const central = new Uint8Array(46 + nameBytes.length);
+    const c = new DataView(central.buffer);
+    c.setUint32(0, 33639248, true);
+    c.setUint16(4, 20, true);
+    c.setUint16(6, 20, true);
+    c.setUint16(8, 2048, true);
+    c.setUint16(10, 0, true);
+    c.setUint16(12, 0, true);
+    c.setUint16(14, DOS_DATE, true);
+    c.setUint32(16, crc, true);
+    c.setUint32(20, data.length, true);
+    c.setUint32(24, data.length, true);
+    c.setUint16(28, nameBytes.length, true);
+    c.setUint32(42, offset, true);
+    central.set(nameBytes, 46);
+    locals.push(local, data);
+    centrals.push(central);
+    offset += local.length + data.length;
+  }
+  const centralSize = centrals.reduce((n, c) => n + c.length, 0);
+  const end = new Uint8Array(22);
+  const e = new DataView(end.buffer);
+  e.setUint32(0, 101010256, true);
+  e.setUint16(8, entries.length, true);
+  e.setUint16(10, entries.length, true);
+  e.setUint32(12, centralSize, true);
+  e.setUint32(16, offset, true);
+  const out = new Uint8Array(offset + centralSize + 22);
+  let at = 0;
+  for (const part of [...locals, ...centrals, end]) {
+    out.set(part, at);
+    at += part.length;
+  }
+  return out;
+}
+
+// src/embed/record.ts
+var DEFAULT_SECONDS = 4;
+var yieldToBrowser = () => new Promise((resolve) => setTimeout(resolve, 0));
+var formats = (list) => list.map((f) => `"${f}"`).join(", ").replace(/, ([^,]*)$/, " or $1");
+var AVC_LEVELS = [
+  [31, 3600, 108e3],
+  // 3.1
+  [40, 8192, 245760],
+  // 4.0
+  [42, 8704, 522240],
+  // 4.2
+  [50, 22080, 589824],
+  // 5.0
+  [51, 36864, 983040],
+  // 5.1
+  [52, 36864, 2073600],
+  // 5.2
+  [60, 139264, 4177920]
+  // 6.0
+];
+function avcCodecs(width, height, fps) {
+  const mbs = Math.ceil(width / 16) * Math.ceil(height / 16);
+  const level = (AVC_LEVELS.find(([, f, s]) => mbs <= f && mbs * fps <= s) ?? AVC_LEVELS[AVC_LEVELS.length - 1])[0];
+  const hex = level.toString(16).toUpperCase().padStart(2, "0");
+  return ["avc1.6400", "avc1.4D00", "avc1.42E0"].map((p) => p + hex);
+}
+async function supported(codecs, base) {
+  for (const codec of codecs) {
+    const config = { ...base, codec };
+    try {
+      const answer = await VideoEncoder.isConfigSupported(config);
+      if (answer.supported) return config;
+    } catch {
+    }
+  }
+  return void 0;
+}
+var hasWebCodecs = () => typeof VideoEncoder !== "undefined" && typeof VideoFrame !== "undefined";
+async function videoConfig(format, width, height, fps, bitrate) {
+  const base = {
+    width,
+    height,
+    bitrate,
+    framerate: fps,
+    latencyMode: "quality",
+    ...format === "mp4" ? { avc: { format: "avc" } } : {}
+  };
+  return supported(format === "mp4" ? avcCodecs(width, height, fps) : ["vp09.00.10.08", "vp8"], base);
+}
+var resolveEffect = (effect) => {
+  const def = typeof effect === "string" ? getEffect(effect) : effect;
+  if (!def) throw new Error(`There is no effect "${String(effect)}" in the catalog; findEffects() lists them.`);
+  return def;
+};
+function positive(name, value, fallback) {
+  const n = value ?? fallback;
+  if (!Number.isFinite(n) || n <= 0) throw new Error(`${name} must be a number above 0 (it was ${String(value)}).`);
+  return n;
+}
+var even = (n) => Math.max(2, Math.ceil(n / 2) * 2);
+async function recordingPlan(effect, options = {}) {
+  const def = resolveEffect(effect);
+  if (options.preset && !def.presets?.some((p) => p.name === options.preset)) {
+    const names = def.presets?.map((p) => `"${p.name}"`).join(", ");
+    throw new Error(`"${def.id}" has no preset "${options.preset}"${names ? `; it has ${names}` : ""}.`);
+  }
+  const fps = positive("fps", options.fps, 30);
+  const start = options.start ?? 0;
+  if (!Number.isFinite(start) || start < 0) throw new Error(`start must be 0 or more seconds (it was ${String(options.start)}).`);
+  const duration = positive("duration", options.duration, defaultDuration(def, options));
+  let width = Math.round(positive("width", options.width, 1280));
+  let height = Math.round(positive("height", options.height, 720));
+  const explicitAlpha = options.alpha === true;
+  let alpha = options.alpha ?? (def.kind === "shader" && Boolean(def.transparent));
+  let format = options.format;
+  if (format && !["mp4", "webm", "gif", "png"].includes(format)) throw new Error(`format is one of "mp4", "webm", "gif" or "png" (it was "${format}").`);
+  if (format === "mp4" && alpha) {
+    if (explicitAlpha) throw new Error(`An mp4 (H.264) cannot keep transparency; record ${formats(["webm", "png", "gif"])} to keep it, or pass alpha: false.`);
+    alpha = false;
+  }
+  let encoder;
+  if (format !== "gif" && format !== "png") {
+    if (!hasWebCodecs())
+      throw new Error(`This browser cannot encode video (it has no WebCodecs VideoEncoder), so it cannot record ${format ?? "a video"}; record ${formats(["gif", "png"])} instead.`);
+    const w = even(width);
+    const h = even(height);
+    const bitrate = Math.round(positive("bitrate", options.bitrate, w * h * fps * 0.15));
+    const tryFormat = (f) => videoConfig(f, w, h, fps, bitrate);
+    const choices = format ? [format] : alpha ? ["webm"] : ["mp4", "webm"];
+    for (const f of choices) {
+      encoder = await tryFormat(f);
+      if (encoder) {
+        format = f;
+        break;
+      }
+    }
+    if (!encoder && !format && alpha && !explicitAlpha) {
+      encoder = await tryFormat("mp4");
+      if (encoder) {
+        format = "mp4";
+        alpha = false;
+      }
+    }
+    if (!encoder) {
+      const asked = format ?? (alpha ? "webm" : "mp4");
+      const other = asked === "mp4" ? "webm" : "mp4";
+      if (alpha && asked === "webm") throw new Error(`This browser cannot encode VP8 or VP9, so it cannot record a webm with transparency; record ${formats(["png", "gif"])} to keep it, or pass alpha: false.`);
+      const otherWorks = format && await tryFormat(other);
+      const codec = asked === "mp4" ? "H.264" : "VP8 or VP9";
+      throw new Error(
+        format ? `This browser cannot encode ${codec} at ${w} \xD7 ${h}, so it cannot record ${asked}; record ${formats(otherWorks ? [other, "gif", "png"] : ["gif", "png"])} instead.` : `This browser cannot encode H.264, VP8 or VP9 at ${w} \xD7 ${h}; record ${formats(["gif", "png"])} instead.`
+      );
+    }
+    width = w;
+    height = h;
+  }
+  return { effect: def, format, width, height, fps, duration, start, frames: Math.max(1, Math.round(duration * fps)), alpha, ...encoder ? { encoder } : {} };
+}
+function defaultDuration(def, options) {
+  if (def.kind === "shader") return def.loop ?? DEFAULT_SECONDS;
+  const motion = renderVectorEffect(def, effectValues(def, options).values);
+  return (svgDuration(motion, options.steps ?? []) + (def.hold ?? 600)) / 1e3;
+}
+function effectValues(def, options) {
+  const values = effectDefaults(def, { ...options.preset ? { preset: options.preset } : {}, ...options.values ? { values: options.values } : {} });
+  if (!options.subject) return { values, live: {} };
+  const s = subjectValues(def, options.subject);
+  return { values: { ...values, ...s.values }, live: s.live };
+}
+function shaderSource(plan, values, live, options) {
+  const def = plan.effect;
+  const frames = new ShaderFrames({ source: def.source, values, width: plan.width, height: plan.height, alpha: plan.alpha || Boolean(def.transparent) });
+  const videos = [];
+  for (const [name, source] of Object.entries(live)) {
+    frames.setLiveSource(name, source);
+    if (typeof HTMLVideoElement !== "undefined" && source instanceof HTMLVideoElement) {
+      videos.push({ video: source, time: source.currentTime, paused: source.paused });
+      source.pause();
+    }
+  }
+  const script = options.pointer;
+  return {
+    async frame(time, index, out) {
+      for (const { video } of videos) await seekVideo(video, time);
+      await options.beforeFrame?.(time, index);
+      await frames.ready();
+      const pointer = typeof script === "function" ? script(time) : script;
+      frames.render(time, { frame: index, delta: 1 / plan.fps, ...pointer });
+      frames.readPixels(out);
+    },
+    dispose() {
+      frames.dispose();
+      for (const { video, time, paused } of videos) {
+        video.currentTime = time;
+        if (!paused) void video.play().catch(() => void 0);
+      }
+    }
+  };
+}
+function vectorSource(plan, values, options) {
+  const def = plan.effect;
+  const view = svgView(renderVectorEffect(def, values));
+  const host = document.createElement("div");
+  host.setAttribute("aria-hidden", "true");
+  host.style.cssText = `position:fixed;left:-100000px;top:0;width:${plan.width}px;height:${plan.height}px;pointer-events:none;`;
+  host.appendChild(view.element);
+  document.body.appendChild(host);
+  const steps = options.steps ?? [];
+  return {
+    async frame(time, index, out) {
+      await options.beforeFrame?.(time, index);
+      view.draw(time * 1e3, steps);
+      const canvas = await view.capture({ width: plan.width, height: plan.height });
+      if (!canvas) throw new Error(`"${def.id}" has no picture to record: its SVG does not parse.`);
+      out.set(canvas.getContext("2d").getImageData(0, 0, plan.width, plan.height).data);
+    },
+    dispose: () => host.remove()
+  };
+}
+function flatten(rgba, background) {
+  const [br, bg, bb] = background;
+  for (let i = 0; i < rgba.length; i += 4) {
+    const a = rgba[i + 3];
+    if (a === 255) continue;
+    const k = a / 255;
+    rgba[i] = rgba[i] * k + br * (1 - k);
+    rgba[i + 1] = rgba[i + 1] * k + bg * (1 - k);
+    rgba[i + 2] = rgba[i + 2] * k + bb * (1 - k);
+    rgba[i + 3] = 255;
+  }
+}
+async function gifEncoder(plan) {
+  const { GIFEncoder, quantize, applyPalette } = await import("gifenc");
+  const gif = GIFEncoder();
+  const delay = 1e3 / plan.fps;
+  return {
+    async add(rgba, i) {
+      const repeat = i === 0 ? { repeat: 0 } : {};
+      if (!plan.alpha) {
+        const palette2 = quantize(rgba, 256);
+        gif.writeFrame(applyPalette(rgba, palette2), plan.width, plan.height, { palette: palette2, delay, ...repeat });
+        return;
+      }
+      const palette = quantize(rgba, 256, { format: "rgba4444", oneBitAlpha: true });
+      const transparentIndex = palette.findIndex((c) => c[3] === 0);
+      gif.writeFrame(applyPalette(rgba, palette, "rgba4444"), plan.width, plan.height, {
+        palette,
+        delay,
+        dispose: 2,
+        ...transparentIndex >= 0 ? { transparent: true, transparentIndex } : {},
+        ...repeat
+      });
+    },
+    async finish() {
+      gif.finish();
+      return new Blob([gif.bytes()], { type: "image/gif" });
+    },
+    close() {
+    }
+  };
+}
+function pngEncoder(plan) {
+  const canvas = document.createElement("canvas");
+  canvas.width = plan.width;
+  canvas.height = plan.height;
+  const context = canvas.getContext("2d");
+  if (!context) throw new Error("This browser cannot draw on a canvas, so it cannot make PNG frames.");
+  const entries = [];
+  const digits = Math.max(4, String(plan.frames).length);
+  return {
+    async add(rgba, i) {
+      context.putImageData(new ImageData(rgba, plan.width, plan.height), 0, 0);
+      const blob = await new Promise((resolve) => canvas.toBlob(resolve, "image/png"));
+      if (!blob) throw new Error("The browser could not encode a PNG frame.");
+      entries.push({ name: `frame-${String(i + 1).padStart(digits, "0")}.png`, data: new Uint8Array(await blob.arrayBuffer()) });
+    },
+    async finish() {
+      return new Blob([zipStore(entries)], { type: "application/zip" });
+    },
+    close() {
+    }
+  };
+}
+var bytesOf = (source) => source instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && source instanceof SharedArrayBuffer ? new Uint8Array(source.slice(0)) : new Uint8Array(source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength));
+function collector(config, fail) {
+  const chunks = [];
+  const out = { chunks, description: void 0, encoder: void 0 };
+  out.encoder = new VideoEncoder({
+    output(chunk, metadata) {
+      const data = new Uint8Array(chunk.byteLength);
+      chunk.copyTo(data);
+      const desc = metadata?.decoderConfig?.description;
+      if (desc && !out.description) out.description = bytesOf(desc);
+      chunks.push({ data, timestamp: chunk.timestamp, ...chunk.duration ? { duration: chunk.duration } : {}, key: chunk.type === "key" });
+    },
+    error: (e) => fail(new Error(`The video encoder failed: ${e.message}`, { cause: e }))
+  });
+  out.encoder.configure(config);
+  return out;
+}
+function videoEncoder(plan) {
+  const config = plan.encoder;
+  let failure;
+  const fail = (e) => failure ??= e;
+  const color = collector(config, fail);
+  const alpha = plan.alpha ? collector(config, fail) : void 0;
+  const encoders = [color.encoder, ...alpha ? [alpha.encoder] : []];
+  const frameUs = 1e6 / plan.fps;
+  const keyEvery = Math.max(1, Math.round(plan.fps * 2));
+  const { width, height } = plan;
+  const plane = alpha ? new Uint8Array(width * height * 1.5).fill(128) : void 0;
+  const check = () => {
+    if (failure) throw failure;
+  };
+  const encode = (encoder, frame, key) => {
+    try {
+      encoder.encode(frame, { keyFrame: key });
+    } finally {
+      frame.close();
+    }
+  };
+  return {
+    async add(rgba, i) {
+      check();
+      const timing = { codedWidth: width, codedHeight: height, timestamp: Math.round(i * frameUs), duration: Math.round(frameUs) };
+      const key = i % keyEvery === 0;
+      encode(color.encoder, new VideoFrame(rgba, { format: "RGBX", ...timing }), key);
+      if (alpha && plane) {
+        for (let p = 0, q = 3; p < width * height; p++, q += 4) plane[p] = rgba[q];
+        encode(alpha.encoder, new VideoFrame(plane, { format: "I420", ...timing }), key);
+      }
+      while (encoders.some((e) => e.encodeQueueSize > 4) && !failure) await new Promise((resolve) => setTimeout(resolve, 1));
+    },
+    async finish() {
+      await Promise.all(encoders.map((e) => e.flush()));
+      check();
+      for (const e of encoders) e.close();
+      const byTime = (a, b) => a.timestamp - b.timestamp;
+      const chunks = color.chunks.sort(byTime);
+      if (plan.format === "mp4") {
+        if (!color.description) throw new Error("The H.264 encoder gave no decoder configuration (avcC), so the mp4 cannot be written.");
+        const file2 = muxMp4({ width, height, avcC: color.description, samples: chunks });
+        return new Blob([file2], { type: "video/mp4" });
+      }
+      const alphas = new Map(alpha?.chunks.map((c) => [c.timestamp, c.data]));
+      const frames = chunks.map((c) => {
+        const a = alphas.get(c.timestamp);
+        if (alpha && !a) throw new Error(`The alpha encoder dropped the frame at ${c.timestamp / 1e6} s, so the webm cannot keep transparency; record "png" or "gif" instead.`);
+        return { ...c, ...a ? { alpha: a } : {} };
+      });
+      const codec = config.codec.startsWith("vp8") ? "vp8" : "vp9";
+      const file = muxWebm({ codec, width, height, frames, duration: plan.frames * frameUs, fps: plan.fps });
+      return new Blob([file], { type: "video/webm" });
+    },
+    close() {
+      for (const e of encoders) if (e.state !== "closed") e.close();
+    }
+  };
+}
+async function recordEffect(effect, options = {}) {
+  const plan = await recordingPlan(effect, options);
+  const { signal, onProgress } = options;
+  const { values, live } = effectValues(plan.effect, options);
+  const background = (parseColor(options.background ?? (plan.effect.kind === "shader" ? "#000000" : "#ffffff")) ?? [0, 0, 0]).map((c) => Math.round(c * 255));
+  const source = plan.effect.kind === "shader" ? shaderSource(plan, values, live, options) : vectorSource(plan, values, options);
+  let encoder;
+  try {
+    encoder = plan.format === "gif" ? await gifEncoder(plan) : plan.format === "png" ? pngEncoder(plan) : videoEncoder(plan);
+    const rgba = new Uint8ClampedArray(plan.width * plan.height * 4);
+    for (let i = 0; i < plan.frames; i++) {
+      if (signal?.aborted) throw new DOMException("Cancelled", "AbortError");
+      await source.frame(plan.start + i / plan.fps, i, rgba);
+      if (!plan.alpha) flatten(rgba, background);
+      await encoder.add(rgba, i);
+      onProgress?.((i + 1) / plan.frames);
+      if (i % 2 === 1) await yieldToBrowser();
+    }
+    if (signal?.aborted) throw new DOMException("Cancelled", "AbortError");
+    return await encoder.finish();
+  } finally {
+    encoder?.close();
+    source.dispose();
+  }
+}
+
+// src/embed/index.ts
+var kindOf = (subject) => Object.keys(subject).find((k) => k !== "font" && k !== "weight");
+function svgUrl(svg) {
+  const markup = svg.trim();
+  if (!markup.startsWith("<")) return svg;
+  const withNs = /\sxmlns\s*=/.test(markup.slice(0, markup.indexOf(">") + 1)) ? markup : markup.replace(/^<svg/i, '<svg xmlns="http://www.w3.org/2000/svg"');
+  return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(withNs)}`;
+}
+function pick(slots, wanted, name, effect, what) {
+  const slot = name ? slots.find((s) => s.name === name) : slots.find(wanted);
+  if (!slot) {
+    const names = slots.map((s) => s.name).join(", ");
+    throw new Error(
+      name ? `"${effect.id}" has no control "${name}" for ${what}${names ? `; it has ${names}` : ""}.` : `"${effect.id}" takes no ${what}; see effectInputs(effect).accepts, or findEffects({ accepts: [...] }) for effects that do.`
+    );
+  }
+  return slot;
+}
+function subjectValues(effect, subject, slot) {
+  const out = { values: {}, live: {} };
+  const inputs = effectInputs(effect);
+  const used = /* @__PURE__ */ new Set();
+  for (const s of Array.isArray(subject) ? subject : [subject]) {
+    const kind = kindOf(s);
+    const free = (slots) => slots.filter((x) => !used.has(x.name));
+    if (kind === "path" || kind === "text" && effect.kind === "vector") {
+      const holds = kind === "path" ? "path" : "copy";
+      const text = pick(free(inputs.texts), (t) => t.holds === holds, slot, effect, kind === "path" ? "path data" : "text");
+      out.values[text.name] = kind === "path" ? s.path : s.text;
+      used.add(text.name);
+      continue;
+    }
+    if (effect.kind === "vector")
+      throw new Error(`"${effect.id}" is a vector effect: it draws its own picture and takes words or path data (${inputs.accepts.join(", ") || "nothing"}), not ${{ svg: "an SVG", image: "an image", video: "a video" }[kind]}.`);
+    const wanted = (x) => kind === "text" ? x.wants !== "picture" : kind === "video" ? x.wants === "picture" : true;
+    const image = pick(free(inputs.images), wanted, slot, effect, kind === "text" ? "text" : `${kind === "svg" ? "SVG" : kind}`);
+    used.add(image.name);
+    if (kind === "video") {
+      if (!inputs.accepts.includes("video")) throw new Error(`"${effect.id}" is not made for video (video: "${inputs.video}"); give it a picture.`);
+      out.live[image.name] = s.video;
+    } else if (kind === "text") {
+      const t = s;
+      out.values[image.name] = textImage(t.text, { ...t.font ? { font: t.font } : {}, ...t.weight !== void 0 ? { weight: t.weight } : {} });
+    } else out.values[image.name] = kind === "svg" ? svgUrl(s.svg) : s.image;
+  }
+  return out;
+}
+function mountEffect(host, effect, options = {}) {
+  const def = typeof effect === "string" ? getEffect(effect) : effect;
+  if (!def) throw new Error(`There is no effect "${String(effect)}" in the catalog; findEffects() lists them.`);
+  let values = { ...effectDefaults(def, { ...options.preset ? { preset: options.preset } : {}, ...options.values ? { values: options.values } : {} }) };
+  let live = {};
+  const apply = (subject) => {
+    if (!subject) return;
+    const s = subjectValues(def, subject);
+    values = { ...values, ...s.values };
+    live = s.live;
+  };
+  apply(options.subject);
+  if (def.kind === "shader") {
+    const renderer = new ShaderRenderer(host, {
+      alpha: Boolean(def.transparent),
+      autoplay: options.autoplay ?? true,
+      pauseWhenHidden: options.pauseWhenHidden ?? true,
+      ...options.className ? { className: options.className } : {}
+    });
+    renderer.setSource(def.source);
+    renderer.setValues(values);
+    const setLive = (previous) => {
+      for (const name of Object.keys(previous)) if (!(name in live)) renderer.setLiveSource(name, null);
+      for (const [name, source] of Object.entries(live)) renderer.setLiveSource(name, source);
+    };
+    setLive({});
+    return {
+      effect: def,
+      element: renderer.canvas,
+      renderer,
+      setSubject(subject) {
+        const before = live;
+        apply(subject);
+        renderer.setValues(values);
+        setLive(before);
+      },
+      setValues(next) {
+        values = { ...values, ...next };
+        renderer.setValues(values);
+      },
+      play: () => renderer.play(),
+      pause: () => renderer.pause(),
+      dispose: () => renderer.dispose()
+    };
+  }
+  let player;
+  const build = () => {
+    player?.dispose();
+    player = new SvgPlayer(host, renderVectorEffect(def, values), {
+      hold: def.hold,
+      ...def.trigger ? { trigger: def.trigger } : {},
+      autoplay: options.autoplay ?? true,
+      pauseWhenHidden: options.pauseWhenHidden ?? true
+    });
+    if (options.className) player.view.element.className = options.className;
+  };
+  build();
+  return {
+    effect: def,
+    get element() {
+      return player.view.element;
+    },
+    get player() {
+      return player;
+    },
+    setSubject(subject) {
+      apply(subject);
+      build();
+    },
+    setValues(next) {
+      values = { ...values, ...next };
+      build();
+    },
+    play: () => player.play(),
+    pause: () => player.pause(),
+    dispose: () => player.dispose()
+  };
+}
+
+export {
+  recordingPlan,
+  recordEffect,
+  subjectValues,
+  mountEffect
+};
+//# sourceMappingURL=chunk-UCZ43ARE.js.map