@cueframe/kernel 0.0.1

package/dist/primitives/captions.js

@@ -0,0 +1,629 @@
+import {
+  fillStyle
+} from "../chunk-XLIPPLG3.js";
+import {
+  Marker
+} from "../chunk-D2EG7J7X.js";
+import {
+  wordPop
+} from "../chunk-ZFEXATWN.js";
+import {
+  fillTextBox
+} from "../chunk-YA3OR2KK.js";
+import {
+  TEXT_HI,
+  VIOLET
+} from "../chunk-CX2IIQ4R.js";
+import {
+  __commonJS,
+  __toESM
+} from "../chunk-2ESYSVXG.js";
+
+// ../../node_modules/.pnpm/@remotion+captions@4.0.429/node_modules/@remotion/captions/dist/ensure-max-characters-per-line.js
+var require_ensure_max_characters_per_line = __commonJS({
+  "../../node_modules/.pnpm/@remotion+captions@4.0.429/node_modules/@remotion/captions/dist/ensure-max-characters-per-line.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ensureMaxCharactersPerLine = void 0;
+    var splitWords = (inputCaptions) => {
+      const captions = [];
+      for (let i = 0; i < inputCaptions.length; i++) {
+        const w = inputCaptions[i];
+        const words = w.text.split(" ");
+        for (let j = 0; j < words.length; j++) {
+          const word = words[j];
+          captions.push({
+            text: j === 0 ? ` ${word}` : word,
+            startMs: w.startMs,
+            endMs: w.endMs,
+            confidence: w.confidence,
+            timestampMs: w.timestampMs
+          });
+        }
+      }
+      return captions;
+    };
+    var ensureMaxCharactersPerLine = ({ captions, maxCharsPerLine }) => {
+      const splitted = splitWords(captions);
+      const segments = [];
+      let currentSegment = [];
+      for (let i = 0; i < splitted.length; i++) {
+        const w = splitted[i];
+        const remainingWords = splitted.slice(i + 1);
+        const filledCharactersInLine = currentSegment.map((s) => s.text.length).reduce((a, b) => a + b, 0);
+        const preventOrphanWord = remainingWords.length < 4 && remainingWords.length > 1 && filledCharactersInLine > maxCharsPerLine / 2;
+        if (filledCharactersInLine + w.text.length > maxCharsPerLine || preventOrphanWord) {
+          segments.push(currentSegment);
+          currentSegment = [];
+        }
+        currentSegment.push(w);
+      }
+      segments.push(currentSegment);
+      return { segments };
+    };
+    exports.ensureMaxCharactersPerLine = ensureMaxCharactersPerLine;
+  }
+});
+
+// ../../node_modules/.pnpm/@remotion+captions@4.0.429/node_modules/@remotion/captions/dist/create-tiktok-style-captions.js
+var require_create_tiktok_style_captions = __commonJS({
+  "../../node_modules/.pnpm/@remotion+captions@4.0.429/node_modules/@remotion/captions/dist/create-tiktok-style-captions.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createTikTokStyleCaptions = void 0;
+    var createTikTokStyleCaptions2 = ({ captions, combineTokensWithinMilliseconds }) => {
+      const tikTokStyleCaptions = [];
+      let currentText = "";
+      let currentTokens = [];
+      let currentFrom = 0;
+      let currentTo = 0;
+      const add = () => {
+        tikTokStyleCaptions.push({
+          text: currentText.trimStart(),
+          startMs: currentFrom,
+          tokens: currentTokens,
+          durationMs: Infinity
+        });
+        if (tikTokStyleCaptions.length > 1) {
+          tikTokStyleCaptions[tikTokStyleCaptions.length - 2].durationMs = currentFrom - tikTokStyleCaptions[tikTokStyleCaptions.length - 2].startMs;
+        }
+      };
+      captions.forEach((item, index) => {
+        const { text } = item;
+        if (text.startsWith(" ") && currentTo - currentFrom > combineTokensWithinMilliseconds) {
+          if (currentText !== "") {
+            add();
+          }
+          currentText = text.trimStart();
+          currentTokens = [
+            { text: currentText, fromMs: item.startMs, toMs: item.endMs }
+          ].filter((t) => t.text !== "");
+          currentFrom = item.startMs;
+          currentTo = item.endMs;
+        } else {
+          if (currentText === "") {
+            currentFrom = item.startMs;
+          }
+          currentText += text;
+          currentText = currentText.trimStart();
+          if (text.trim() !== "") {
+            currentTokens.push({
+              text: currentTokens.length === 0 ? currentText.trimStart() : text,
+              fromMs: item.startMs,
+              toMs: item.endMs
+            });
+          }
+          currentTo = item.endMs;
+        }
+        if (index === captions.length - 1 && currentText !== "") {
+          add();
+          tikTokStyleCaptions[tikTokStyleCaptions.length - 1].durationMs = currentTo - tikTokStyleCaptions[tikTokStyleCaptions.length - 1].startMs;
+        }
+      });
+      return { pages: tikTokStyleCaptions };
+    };
+    exports.createTikTokStyleCaptions = createTikTokStyleCaptions2;
+  }
+});
+
+// ../../node_modules/.pnpm/@remotion+captions@4.0.429/node_modules/@remotion/captions/dist/parse-srt.js
+var require_parse_srt = __commonJS({
+  "../../node_modules/.pnpm/@remotion+captions@4.0.429/node_modules/@remotion/captions/dist/parse-srt.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.parseSrt = void 0;
+    function toSeconds(time) {
+      const [first, second, third] = time.split(":");
+      if (!first) {
+        throw new Error(`Invalid timestamp:${time}`);
+      }
+      if (!second) {
+        throw new Error(`Invalid timestamp:${time}`);
+      }
+      if (!third) {
+        throw new Error(`Invalid timestamp:${time}`);
+      }
+      const [seconds, millis] = third.split(",");
+      if (!seconds) {
+        throw new Error(`Invalid timestamp:${time}`);
+      }
+      if (!millis) {
+        throw new Error(`Invalid timestamp:${time}`);
+      }
+      return parseInt(first, 10) * 3600 + parseInt(second, 10) * 60 + parseInt(seconds, 10) + parseInt(millis, 10) / 1e3;
+    }
+    var parseSrt = ({ input }) => {
+      const inputLines = input.split("\n");
+      const captions = [];
+      for (let i = 0; i < inputLines.length; i++) {
+        const line = inputLines[i];
+        const nextLine = inputLines[i + 1];
+        if ((line === null || line === void 0 ? void 0 : line.match(/([0-9]+)/)) && (nextLine === null || nextLine === void 0 ? void 0 : nextLine.includes(" --> "))) {
+          const nextLineSplit = nextLine.split(" --> ");
+          const start = toSeconds(nextLineSplit[0]);
+          const end = toSeconds(nextLineSplit[1]);
+          captions.push({
+            text: "",
+            startMs: start * 1e3,
+            endMs: end * 1e3,
+            confidence: 1,
+            timestampMs: (start + end) / 2 * 1e3
+          });
+        } else if (line === null || line === void 0 ? void 0 : line.includes(" --> ")) {
+          continue;
+        } else if ((line === null || line === void 0 ? void 0 : line.trim()) === "") {
+          captions[captions.length - 1].text = captions[captions.length - 1].text.trim();
+        } else {
+          captions[captions.length - 1].text += line + "\n";
+        }
+      }
+      return {
+        captions: captions.map((l) => {
+          return {
+            ...l,
+            text: l.text.trimEnd()
+          };
+        })
+      };
+    };
+    exports.parseSrt = parseSrt;
+  }
+});
+
+// ../../node_modules/.pnpm/@remotion+captions@4.0.429/node_modules/@remotion/captions/dist/serialize-srt.js
+var require_serialize_srt = __commonJS({
+  "../../node_modules/.pnpm/@remotion+captions@4.0.429/node_modules/@remotion/captions/dist/serialize-srt.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.serializeSrt = void 0;
+    var formatSingleSrtTimestamp = (timestamp) => {
+      const hours = Math.floor(timestamp / 36e5);
+      const minutes = Math.floor(timestamp % 36e5 / 6e4);
+      const seconds = Math.floor(timestamp % 6e4 / 1e3);
+      const milliseconds = Math.floor(timestamp % 1e3);
+      return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")},${String(milliseconds).padStart(3, "0")}`;
+    };
+    var formatSrtTimestamp = (startMs, endMs) => {
+      return `${formatSingleSrtTimestamp(startMs)} --> ${formatSingleSrtTimestamp(endMs)}`;
+    };
+    var serializeSrt = ({ lines }) => {
+      let currentIndex = 0;
+      return lines.map((s) => {
+        currentIndex++;
+        if (s.length === 0) {
+          return null;
+        }
+        const firstTimestamp = s[0].startMs;
+        const lastTimestamp = s[s.length - 1].endMs;
+        return [
+          // Index
+          currentIndex,
+          formatSrtTimestamp(firstTimestamp, lastTimestamp),
+          // Text
+          s.map((caption) => caption.text).join("")
+        ].join("\n");
+      }).filter(Boolean).join("\n\n");
+    };
+    exports.serializeSrt = serializeSrt;
+  }
+});
+
+// ../../node_modules/.pnpm/@remotion+captions@4.0.429/node_modules/@remotion/captions/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/.pnpm/@remotion+captions@4.0.429/node_modules/@remotion/captions/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CaptionsInternals = exports.serializeSrt = exports.parseSrt = exports.createTikTokStyleCaptions = void 0;
+    var ensure_max_characters_per_line_1 = require_ensure_max_characters_per_line();
+    var create_tiktok_style_captions_1 = require_create_tiktok_style_captions();
+    Object.defineProperty(exports, "createTikTokStyleCaptions", { enumerable: true, get: function() {
+      return create_tiktok_style_captions_1.createTikTokStyleCaptions;
+    } });
+    var parse_srt_1 = require_parse_srt();
+    Object.defineProperty(exports, "parseSrt", { enumerable: true, get: function() {
+      return parse_srt_1.parseSrt;
+    } });
+    var serialize_srt_1 = require_serialize_srt();
+    Object.defineProperty(exports, "serializeSrt", { enumerable: true, get: function() {
+      return serialize_srt_1.serializeSrt;
+    } });
+    exports.CaptionsInternals = {
+      ensureMaxCharactersPerLine: ensure_max_characters_per_line_1.ensureMaxCharactersPerLine
+    };
+  }
+});
+
+// ../execution/primitives/src/captions/Captions.tsx
+import { useMemo } from "react";
+import { AbsoluteFill, useCurrentFrame, useVideoConfig, interpolate, Easing } from "remotion";
+
+// ../execution/primitives/src/captions/paginate.ts
+var import_captions = __toESM(require_dist(), 1);
+function paginateCaptionSegments(segments, opts) {
+  const raw = [];
+  for (const words of segments) {
+    if (words.length === 0) continue;
+    const rc = words.map((word, i) => ({
+      text: i === 0 ? word.text : ` ${word.text}`,
+      startMs: word.startMs,
+      endMs: word.endMs,
+      timestampMs: null,
+      confidence: null
+    }));
+    const { pages } = (0, import_captions.createTikTokStyleCaptions)({
+      captions: rc,
+      combineTokensWithinMilliseconds: opts.combineMs
+    });
+    for (const page of pages) raw.push(...splitPageToFit(page, opts.makeBox));
+  }
+  return assignTimeline(raw, opts.lingerMs);
+}
+function splitPageToFit(page, makeBox) {
+  const probe = makeBox();
+  if (page.tokens.every((t) => probe.add(t))) {
+    return [{ startMs: page.startMs, tokens: page.tokens }];
+  }
+  const groups = [];
+  let box = makeBox();
+  let cur = [];
+  for (const token of page.tokens) {
+    if (cur.length === 0) {
+      cur.push(token);
+      box.add(token);
+    } else if (box.add(token)) {
+      cur.push(token);
+    } else {
+      groups.push(cur);
+      box = makeBox();
+      cur = [token];
+      box.add(token);
+    }
+  }
+  if (cur.length > 0) groups.push(cur);
+  return groups.map((tokens, i) => ({
+    startMs: i === 0 ? page.startMs : tokens[0].fromMs,
+    tokens
+  }));
+}
+function assignTimeline(raw, lingerMs) {
+  const merged = [];
+  for (const p of raw) {
+    const prev = merged[merged.length - 1];
+    if (prev && p.startMs <= prev.startMs) {
+      prev.tokens.push(...p.tokens);
+    } else {
+      merged.push({ startMs: p.startMs, tokens: [...p.tokens] });
+    }
+  }
+  return merged.map((p, i) => {
+    const lastWordEnd = Math.max(...p.tokens.map((t) => t.toMs));
+    const cleared = lastWordEnd + lingerMs;
+    const endMs = i < merged.length - 1 ? Math.min(merged[i + 1].startMs, cleared) : cleared;
+    return {
+      text: p.tokens.map((t) => t.text).join(""),
+      startMs: p.startMs,
+      durationMs: Math.max(1, endMs - p.startMs),
+      tokens: p.tokens
+    };
+  });
+}
+
+// ../execution/primitives/src/captions/placement.ts
+function resolveCaptionPlacement(position, region) {
+  const vertical = region ? { bottom: `${Math.max(0, (1 - (region.y + region.h)) * 100)}%` } : position === "top" ? { top: "8%" } : position === "center" ? { top: "50%", transform: "translateY(-50%)" } : { bottom: "10%" };
+  return {
+    position: "absolute",
+    left: 0,
+    right: 0,
+    display: "flex",
+    justifyContent: "center",
+    ...vertical
+  };
+}
+
+// ../execution/primitives/src/captions/Captions.tsx
+var DEFAULT_HIGHLIGHT_COLOR = TEXT_HI;
+var DEFAULT_STYLE = {
+  // Fallback STACK, not a bare family: when the vendored Inter face fails to
+  // register (the loader swallows failures by design), the browser default is
+  // a SERIF — captions must never degrade past a system grotesk.
+  fontFamily: "Inter, 'Helvetica Neue', Helvetica, Arial, sans-serif",
+  fontSize: 5,
+  fontWeight: 600,
+  color: TEXT_HI,
+  highlightColor: DEFAULT_HIGHLIGHT_COLOR,
+  backgroundColor: "transparent",
+  position: "bottom",
+  textTransform: "none",
+  plate: "none",
+  entrance: "fade",
+  entranceMs: 220,
+  exitMs: 180
+};
+function plateStyleFor(kind, backgroundColor) {
+  if (kind === "glass") {
+    const glass = "blur(28px) saturate(135%)";
+    return {
+      backgroundColor: "rgba(20,23,31,0.13)",
+      backdropFilter: glass,
+      WebkitBackdropFilter: glass,
+      border: "1px solid rgba(255,255,255,0.32)"
+    };
+  }
+  if (kind === "solid") {
+    return {
+      // warm espresso scrim (palette.BG = #14100c → rgb 20,16,12) at plate alpha,
+      // not a cold pure-black — keeps the legibility opacity, drops the cold cast.
+      backgroundColor: backgroundColor && backgroundColor !== "transparent" ? backgroundColor : "rgba(20,16,12,0.62)"
+    };
+  }
+  return { backgroundColor: backgroundColor ?? "transparent" };
+}
+var COMBINE_TOKENS_MS = 1500;
+var CAPTION_LINGER_MS = 600;
+function addTokenToBox(box, token, fontFamily, fontSize, fontWeight, emphasis) {
+  const isEmp = emphasis?.emphasisSet.has(token.fromMs) ?? false;
+  const tokenSize = isEmp ? Math.round(fontSize * (emphasis?.emphasisScale ?? 1.2)) : fontSize;
+  const tokenWeight = isEmp ? emphasis?.emphasisFontWeight ?? 900 : fontWeight;
+  const tokenFamily = isEmp ? emphasis?.emphasisFontFamily ?? fontFamily : fontFamily;
+  return box.add({
+    text: token.text,
+    fontFamily: tokenFamily,
+    fontSize: tokenSize,
+    fontWeight: String(tokenWeight)
+  });
+}
+function makeBoxFactory(maxWidth, fontFamily, fontSize, fontWeight, emphasis) {
+  return () => {
+    const box = fillTextBox({ maxBoxWidth: maxWidth, maxLines: 3 });
+    return {
+      add: (token) => !addTokenToBox(box, token, fontFamily, fontSize, fontWeight, emphasis).exceedsBox
+    };
+  };
+}
+function layoutTokensIntoLines(tokens, maxWidth, fontFamily, fontSize, fontWeight, emphasis) {
+  const box = fillTextBox({ maxBoxWidth: maxWidth, maxLines: 3 });
+  const lines = [[]];
+  for (const token of tokens) {
+    const result = addTokenToBox(box, token, fontFamily, fontSize, fontWeight, emphasis);
+    if (result.newLine) {
+      lines.push([token]);
+    } else {
+      lines[lines.length - 1].push(token);
+    }
+  }
+  return lines.filter((line) => line.length > 0);
+}
+function Captions({
+  segments,
+  style: userStyle,
+  region
+}) {
+  const frame = useCurrentFrame();
+  const { fps, width, height } = useVideoConfig();
+  const style = { ...DEFAULT_STYLE, ...userStyle };
+  const emphasisScale = style.emphasisScale ?? 1.08;
+  const emphasisColor = style.emphasisColor ?? style.highlightColor;
+  const emphasisFontFamily = style.emphasisFontFamily;
+  const emphasisFontWeight = style.emphasisFontWeight ?? 800;
+  const emphasisTextTransform = style.emphasisTextTransform ?? style.textTransform;
+  const emphasisLetterSpacing = style.emphasisLetterSpacing ?? 0;
+  const emphasisFontStyle = style.emphasisFontStyle ?? "normal";
+  const entrance = style.entrance ?? "none";
+  const entranceFrames = Math.max(1, Math.round((style.entranceMs ?? 160) / 1e3 * fps));
+  const staggerFrames = Math.max(0, Math.round((style.entranceStaggerMs ?? 90) / 1e3 * fps));
+  const exitMs = style.exitMs ?? 0;
+  const emphasisPlate = style.emphasisPlate ?? false;
+  const plateColor = style.emphasisPlateColor ?? emphasisColor;
+  const plateTextColor = style.emphasisPlateTextColor ?? TEXT_HI;
+  const plateAltColor = style.emphasisPlateAltColor ?? plateColor;
+  const plateAltTextColor = style.emphasisPlateAltTextColor ?? plateTextColor;
+  const plateRadius = style.emphasisPlateRadius ?? 6;
+  const platePadX = style.emphasisPlatePadX ?? 0.16;
+  const platePadY = style.emphasisPlatePadY ?? 0.04;
+  const annotationColor = style.annotationColor ?? VIOLET;
+  const maxWidthPercent = style.maxWidthPercent ?? 80;
+  const plateStyle = plateStyleFor(style.plate ?? "glass", style.backgroundColor);
+  const fontSize = Math.round(height * (style.fontSize / 100));
+  const maxTextWidth = width * (maxWidthPercent / 100);
+  const { emphasisStartMs, annotateKind } = useMemo(() => {
+    const emph = /* @__PURE__ */ new Set();
+    const ann = /* @__PURE__ */ new Map();
+    for (const w of segments.flat()) {
+      if (w.emphasis) emph.add(w.startMs);
+      if (w.annotate) ann.set(w.startMs, w.annotate);
+    }
+    return { emphasisStartMs: emph, annotateKind: ann };
+  }, [segments]);
+  const emphasisLayout = useMemo(
+    () => emphasisStartMs.size > 0 ? { emphasisSet: emphasisStartMs, emphasisScale, emphasisFontFamily, emphasisFontWeight } : void 0,
+    [emphasisStartMs, emphasisScale, emphasisFontFamily, emphasisFontWeight]
+  );
+  const pages = useMemo(
+    () => paginateCaptionSegments(segments, {
+      combineMs: COMBINE_TOKENS_MS,
+      makeBox: makeBoxFactory(maxTextWidth, style.fontFamily, fontSize, style.fontWeight, emphasisLayout),
+      lingerMs: CAPTION_LINGER_MS
+    }),
+    [segments, maxTextWidth, fontSize, style.fontFamily, style.fontWeight, emphasisLayout]
+  );
+  if (pages.length === 0) return null;
+  const currentTimeMs = frame / fps * 1e3;
+  const currentPage = pages.find(
+    (p) => currentTimeMs >= p.startMs && currentTimeMs < p.startMs + p.durationMs
+  );
+  if (!currentPage) return null;
+  const activeToken = currentPage.tokens.find(
+    (t) => currentTimeMs >= t.fromMs && currentTimeMs < t.toMs
+  );
+  const tokenStartFrame = /* @__PURE__ */ new Map();
+  if (entrance !== "none") {
+    let minNext = -Infinity;
+    for (const t of currentPage.tokens) {
+      const s = Math.max(Math.round(t.fromMs / 1e3 * fps), minNext);
+      tokenStartFrame.set(t, s);
+      minNext = s + staggerFrames;
+    }
+  }
+  const pageEnd = currentPage.startMs + currentPage.durationMs;
+  const groupOpacity = exitMs > 0 ? interpolate(currentTimeMs, [pageEnd - exitMs, pageEnd], [1, 0], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  }) : 1;
+  const lines = layoutTokensIntoLines(
+    currentPage.tokens,
+    maxTextWidth,
+    style.fontFamily,
+    fontSize,
+    style.fontWeight,
+    emphasisLayout
+  );
+  const wrapperStyle = resolveCaptionPlacement(style.position, region);
+  return /* @__PURE__ */ React.createElement(AbsoluteFill, { style: { pointerEvents: "none" } }, /* @__PURE__ */ React.createElement("div", { style: wrapperStyle }, /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      style: {
+        opacity: groupOpacity,
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        gap: `${fontSize * 0.25}px`,
+        padding: `${fontSize * 0.4}px ${fontSize * 0.8}px`,
+        borderRadius: fontSize * 0.5,
+        ...plateStyle,
+        maxWidth: `${maxWidthPercent}%`,
+        boxSizing: "border-box"
+      }
+    },
+    (() => {
+      let plateIdx = 0;
+      const RISE_PX = fontSize * 0.4;
+      const easeOpacity = (start) => interpolate(frame, [start, start + entranceFrames], [0, 1], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp",
+        easing: Easing.out(Easing.cubic)
+      });
+      const entranceOf = (first, isEmph) => {
+        if (entrance === "none") return { opacity: 1, scale: 1, y: 0 };
+        const start = tokenStartFrame.get(first) ?? 0;
+        if (entrance === "word-pop") {
+          const { opacity, scale } = wordPop(frame, fps, start, entranceFrames, isEmph ? 0.86 : 0.92);
+          return { opacity, scale, y: 0 };
+        }
+        if (entrance === "stagger-up") {
+          const y = interpolate(frame, [start, start + entranceFrames], [RISE_PX, 0], {
+            extrapolateLeft: "clamp",
+            extrapolateRight: "clamp",
+            easing: Easing.out(Easing.cubic)
+          });
+          return { opacity: easeOpacity(start), scale: 1, y };
+        }
+        if (entrance === "fade") {
+          return { opacity: easeOpacity(start), scale: 1, y: 0 };
+        }
+        return { opacity: 1, scale: 1, y: 0 };
+      };
+      return lines.map((line, lineIdx) => {
+        const segs = [];
+        for (const t of line) {
+          const e = emphasisStartMs.has(t.fromMs);
+          const last = segs[segs.length - 1];
+          if (emphasisPlate && e && last && last.emph) last.tokens.push(t);
+          else segs.push({ tokens: [t], emph: e });
+        }
+        return /* @__PURE__ */ React.createElement("div", { key: lineIdx, style: { display: "flex", justifyContent: "center", alignItems: "baseline", gap: `${fontSize * 0.35}px` } }, segs.map((seg, si) => {
+          const first = seg.tokens[0];
+          const { opacity, scale, y } = entranceOf(first, seg.emph);
+          const entranceTransform = `translateY(${y}px) scale(${scale})`;
+          const annKind = seg.tokens.map((t) => annotateKind.get(t.fromMs)).find(Boolean);
+          let markerP = 1;
+          if (annKind && entrance !== "none") {
+            const ms = (tokenStartFrame.get(first) ?? 0) + Math.round(fps * 0.14);
+            markerP = interpolate(frame, [ms, ms + Math.round(fps * 0.32)], [0, 1], { extrapolateLeft: "clamp", extrapolateRight: "clamp" });
+          }
+          if (seg.emph && emphasisPlate) {
+            const idx = plateIdx++;
+            const bg = idx % 2 === 0 ? plateColor : plateAltColor;
+            const fg = idx % 2 === 0 ? plateTextColor : plateAltTextColor;
+            const efs = Math.round(fontSize * emphasisScale);
+            return /* @__PURE__ */ React.createElement("span", { key: si, style: { position: "relative", display: "inline-block", opacity, transform: entranceTransform, transformOrigin: "center" } }, /* @__PURE__ */ React.createElement(
+              "span",
+              {
+                style: {
+                  display: "inline-block",
+                  background: bg,
+                  color: fg,
+                  borderRadius: plateRadius,
+                  padding: `${Math.round(efs * platePadY)}px ${Math.round(efs * platePadX)}px`,
+                  fontFamily: emphasisFontFamily ?? style.fontFamily,
+                  fontSize: efs,
+                  fontWeight: emphasisFontWeight,
+                  fontStyle: emphasisFontStyle,
+                  textTransform: emphasisTextTransform,
+                  letterSpacing: emphasisLetterSpacing ? `${emphasisLetterSpacing}px` : void 0,
+                  lineHeight: 1,
+                  whiteSpace: "nowrap"
+                }
+              },
+              seg.tokens.map((t) => t.text.trim()).join(" ")
+            ), annKind ? /* @__PURE__ */ React.createElement(Marker, { spec: { kind: annKind, color: annotationColor }, progress: markerP }) : null);
+          }
+          const token = first;
+          const isActive = token === activeToken;
+          const isEmphasis = seg.emph;
+          const tokenFontSize = isEmphasis ? Math.round(fontSize * emphasisScale) : fontSize;
+          const tokenWeight = isEmphasis ? emphasisFontWeight : style.fontWeight;
+          const tokenFamily = isEmphasis ? emphasisFontFamily ?? style.fontFamily : style.fontFamily;
+          const tokenTransform = isEmphasis ? emphasisTextTransform : style.textTransform;
+          const tokenLetterSpacing = isEmphasis && emphasisLetterSpacing ? `${emphasisLetterSpacing}px` : void 0;
+          const tokenFontStyle = isEmphasis ? emphasisFontStyle : "normal";
+          let tokenColor = style.color;
+          if (isActive && !emphasisPlate) tokenColor = style.highlightColor;
+          else if (isEmphasis) tokenColor = emphasisColor;
+          const gradientFill = isEmphasis && style.emphasisGradient ? fillStyle({ kind: "gradient", value: style.emphasisGradient }) : {};
+          const inner = /* @__PURE__ */ React.createElement(
+            "span",
+            {
+              style: {
+                fontFamily: tokenFamily,
+                fontSize: tokenFontSize,
+                fontWeight: tokenWeight,
+                fontStyle: tokenFontStyle,
+                color: tokenColor,
+                textTransform: tokenTransform,
+                letterSpacing: tokenLetterSpacing,
+                display: "inline-block",
+                ...gradientFill
+              }
+            },
+            emphasisPlate ? token.text.trim() : token.text
+          );
+          return /* @__PURE__ */ React.createElement("span", { key: si, style: { position: "relative", display: "inline-block", opacity, transform: entranceTransform, transformOrigin: "center" } }, inner, annKind ? /* @__PURE__ */ React.createElement(Marker, { spec: { kind: annKind, color: annotationColor }, progress: markerP }) : null);
+        }));
+      });
+    })()
+  )));
+}
+export {
+  Captions
+};

package/dist/primitives/effects.d.ts

@@ -0,0 +1 @@
+export * from "../_members/primitives/effects/index.js";

package/dist/primitives/effects.js

@@ -0,0 +1,30 @@
+import {
+  Blur,
+  ColorGrade,
+  Grain,
+  Parallax,
+  Particles,
+  PulsingIndicator,
+  SpotlightCard,
+  SpringPopIn,
+  SuccessConfetti,
+  Vignette,
+  catalog
+} from "../chunk-N67PDTKQ.js";
+import "../chunk-DSNG6WLU.js";
+import "../chunk-YA3OR2KK.js";
+import "../chunk-CX2IIQ4R.js";
+import "../chunk-2ESYSVXG.js";
+export {
+  Blur,
+  ColorGrade,
+  Grain,
+  Parallax,
+  Particles,
+  PulsingIndicator,
+  SpotlightCard,
+  SpringPopIn,
+  SuccessConfetti,
+  Vignette,
+  catalog
+};

package/dist/primitives/hero-text.d.ts

@@ -0,0 +1 @@
+export * from "../_members/primitives/hero-text/index.js";

package/dist/primitives/hero-text.js

@@ -0,0 +1,14 @@
+import {
+  HeroText,
+  catalog
+} from "../chunk-P43IE4WB.js";
+import "../chunk-BDMTUEEZ.js";
+import "../chunk-EMGFZ3PR.js";
+import "../chunk-ZFEXATWN.js";
+import "../chunk-DSNG6WLU.js";
+import "../chunk-YA3OR2KK.js";
+import "../chunk-2ESYSVXG.js";
+export {
+  HeroText,
+  catalog
+};

package/dist/primitives/layouts.d.ts

@@ -0,0 +1 @@
+export * from "../_members/primitives/layouts/index.js";