@pixerate/editor 0.84.0 → 0.85.0

package/dist/video-editor/index.js

@@ -435,6 +435,18 @@ function parseVideoTransition(v, path) {
     audioCurve: oneOf(v.audioCurve, VIDEO_FADE_CURVES, `${path}.audioCurve`)
   });
 }
+function parseVideoTranscriptWords(v, path) {
+  if (v === void 0) return void 0;
+  if (!Array.isArray(v)) return fail(path, "must be an array of { word, start, end } (ms in the source)");
+  const words = v.map((w, i) => {
+    if (!isObject(w)) return fail(`${path}[${i}]`, "must be an object { word, start, end }");
+    const word = str(w.word, `${path}[${i}].word`);
+    const start = num(w.start, `${path}[${i}].start`, { min: 0 });
+    const end = num(w.end, `${path}[${i}].end`, { min: start });
+    return { word, start, end };
+  });
+  return words.sort((a, b) => a.start - b.start);
+}
 function parseVideoAsset(v, path = "asset") {
   if (!isObject(v)) return fail(path, "must be an object");
   const kind = oneOf(v.kind, ["video", "audio", "image"], `${path}.kind`, false);
@@ -447,8 +459,10 @@ function parseVideoAsset(v, path = "asset") {
     width: num(v.width, `${path}.width`, { optional: true, positive: true }),
     height: num(v.height, `${path}.height`, { optional: true, positive: true }),
     hasAudio: bool(v.hasAudio, `${path}.hasAudio`),
-    poster: str(v.poster, `${path}.poster`, true)
+    poster: str(v.poster, `${path}.poster`, true),
+    transcript: parseVideoTranscriptWords(v.transcript, `${path}.transcript`)
   });
+  if (kind === "image" && asset.transcript) fail(`${path}.transcript`, "is only for video and audio assets");
   if (kind === "image" && asset.duration !== void 0) fail(`${path}.duration`, "is only for video and audio assets");
   return asset;
 }
@@ -1941,6 +1955,171 @@ var VideoAudioPeaksCache = class {
   }
 };
 
+// src/video-editor/transcript.ts
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function cueTime(s) {
+  const m = s.trim().match(/^(?:(\d+):)?(\d{1,2}):(\d{1,2})[.,](\d{1,3})$/);
+  if (!m) throw new Error(`"${s.trim()}" is not a cue time (HH:MM:SS,mmm).`);
+  return ((Number(m[1] ?? 0) * 60 + Number(m[2])) * 60 + Number(m[3])) * 1e3 + Number(m[4].padEnd(3, "0"));
+}
+function cueWords(text, start, end) {
+  const words = text.replace(/<[^>]+>/g, "").split(/\s+/).filter(Boolean);
+  const step = (end - start) / Math.max(1, words.length);
+  return words.map((word, i) => ({ word, start: Math.round(start + i * step), end: Math.round(start + (i + 1) * step) }));
+}
+function parseVideoTranscript(input) {
+  let data = input;
+  if (typeof input === "string") {
+    const text = input.replace(/^/, "").trim();
+    if (text.startsWith("{") || text.startsWith("[")) {
+      try {
+        data = JSON.parse(text);
+      } catch {
+        throw new Error("The transcript looks like JSON but is not valid JSON.");
+      }
+    } else {
+      const words2 = [];
+      for (const block of text.replace(/\r\n?/g, "\n").split(/\n{2,}/)) {
+        const lines = block.split("\n");
+        const at = lines.findIndex((l) => l.includes("-->"));
+        if (at < 0) continue;
+        const [a, b] = lines[at].split("-->");
+        words2.push(...cueWords(lines.slice(at + 1).join(" "), cueTime(a), cueTime(b.trim().split(/\s+/)[0])));
+      }
+      if (!words2.length) throw new Error("No words found: expected Whisper-style JSON with word timings, SubRip (.srt) or WebVTT.");
+      return { words: words2, approximate: true };
+    }
+  }
+  const seconds = (v) => typeof v === "number" && Number.isFinite(v) ? Math.round(v * 1e3) : NaN;
+  const fromList = (list, toMs) => list.map((w, i) => {
+    if (!isRecord(w)) throw new Error(`Word ${i + 1} is not an object { word, start, end }.`);
+    const word = String(w.word ?? w.text ?? "").trim();
+    const start = toMs(w.start);
+    const end = toMs(w.end);
+    if (!word || !Number.isFinite(start) || !Number.isFinite(end)) throw new Error(`Word ${i + 1} needs a word and numeric start and end.`);
+    return { word, start, end: Math.max(start, end) };
+  });
+  let words = [];
+  if (Array.isArray(data)) words = fromList(data, (v) => typeof v === "number" ? v : NaN);
+  else if (isRecord(data) && Array.isArray(data.words)) words = fromList(data.words, seconds);
+  else if (isRecord(data) && Array.isArray(data.segments)) {
+    const segments = data.segments.filter(isRecord);
+    if (segments.some((s) => Array.isArray(s.words))) words = fromList(segments.flatMap((s) => Array.isArray(s.words) ? s.words : []), seconds);
+    else {
+      for (const s of segments) words.push(...cueWords(String(s.text ?? ""), seconds(s.start), seconds(s.end)));
+      if (!words.length) throw new Error("No words found in the segments.");
+      return { words, approximate: true };
+    }
+  }
+  if (!words.length) throw new Error("No words found: expected Whisper-style JSON with word timings, SubRip (.srt) or WebVTT.");
+  return { words: words.sort((a, b) => a.start - b.start), approximate: false };
+}
+function videoTranscriptTrack(project, track) {
+  if (track !== void 0) {
+    if (!project.tracks.some((t) => t.id === track)) throw new Error(`There is no track "${track}"; the tracks are ${project.tracks.map((t) => `"${t.id}"`).join(", ")}.`);
+    return track;
+  }
+  const assets = videoAssetMap(project);
+  const transcribed = (t) => t.clips.some((c) => c.type === "media" && assets.get(c.asset)?.transcript?.length);
+  return (project.tracks.find((t) => t.kind === "audio" && transcribed(t)) ?? project.tracks.find(transcribed))?.id ?? null;
+}
+function videoTimelineTranscript(project, options = {}) {
+  const id = videoTranscriptTrack(project, options.track);
+  if (!id) return [];
+  const track = project.tracks.find((t) => t.id === id);
+  const assets = videoAssetMap(project);
+  const out = [];
+  for (const clip of sortedVideoClips(track)) {
+    if (clip.type !== "media") continue;
+    const words = assets.get(clip.asset)?.transcript;
+    if (!words?.length) continue;
+    const speed = videoClipSpeed(clip);
+    const from = clip.in ?? 0;
+    const to = from + clip.duration * speed;
+    const toTimeline = (s) => Math.min(videoClipEnd(clip), Math.max(clip.start, clip.start + (s - from) / speed));
+    words.forEach((w, index) => {
+      const mid = (w.start + w.end) / 2;
+      if (mid < from || mid >= to) return;
+      out.push({ word: w.word, start: toTimeline(w.start), end: toTimeline(w.end), clip: clip.id, track: track.id, index });
+    });
+  }
+  return out;
+}
+var normalizeVideoWord = (word) => word.toLowerCase().replace(/^[^\p{L}\p{N}']+|[^\p{L}\p{N}']+$/gu, "");
+var rangeOf = (words, i, n2) => ({ from: words[i].start, to: words[i + n2 - 1].end, text: words.slice(i, i + n2).map((w) => w.word).join(" ") });
+function findVideoTranscriptText(words, query) {
+  const q = query.split(/\s+/).map(normalizeVideoWord).filter(Boolean);
+  if (!q.length) throw new Error("Search for at least one word.");
+  const norm = words.map((w) => normalizeVideoWord(w.word));
+  const out = [];
+  for (let i = 0; i + q.length <= norm.length; i++) if (q.every((x, k) => norm[i + k] === x)) out.push(rangeOf(words, i, q.length));
+  return out;
+}
+var VIDEO_DEFAULT_FILLERS = ["um", "umm", "uh", "uhh", "uhm", "erm", "er", "ah", "hmm", "mm", "you know", "i mean"];
+function findVideoFillers(words, fillers = VIDEO_DEFAULT_FILLERS) {
+  const phrases = fillers.map((f) => f.split(/\s+/).map(normalizeVideoWord).filter(Boolean)).filter((p) => p.length).sort((a, b) => b.length - a.length);
+  const norm = words.map((w) => normalizeVideoWord(w.word));
+  const out = [];
+  for (let i = 0; i < norm.length; ) {
+    const hit = phrases.find((p) => i + p.length <= norm.length && p.every((x, k) => norm[i + k] === x));
+    if (hit) {
+      out.push(rangeOf(words, i, hit.length));
+      i += hit.length;
+    } else i++;
+  }
+  return out;
+}
+function findVideoTranscriptPauses(words, options = {}) {
+  const min = options.min ?? 700;
+  const keep = options.keep ?? 150;
+  const out = [];
+  for (let i = 1; i < words.length; i++) {
+    const a = words[i - 1];
+    const b = words[i];
+    if (a.clip !== b.clip || b.start - a.end < min) continue;
+    let from = a.end + keep;
+    let to = b.start - keep;
+    if (options.fps) {
+      const f = 1e3 / options.fps;
+      from = snapToVideoFrame(Math.ceil(from / f - 1e-9) * f, options.fps);
+      to = snapToVideoFrame(Math.floor(to / f + 1e-9) * f, options.fps);
+    }
+    if (to - from > VIDEO_TIME_EPSILON) out.push({ from, to, text: `(pause after "${a.word}")` });
+  }
+  return out;
+}
+function mergeVideoRanges(ranges) {
+  const sorted = ranges.filter((r) => r.to - r.from > VIDEO_TIME_EPSILON).map((r) => ({ from: r.from, to: r.to })).sort((a, b) => a.from - b.from);
+  const out = [];
+  for (const r of sorted) {
+    const last = out[out.length - 1];
+    if (last && r.from <= last.to + VIDEO_TIME_EPSILON) last.to = Math.max(last.to, r.to);
+    else out.push(r);
+  }
+  return out;
+}
+function videoRemoveRangesEdits(ranges, tracks) {
+  return mergeVideoRanges(ranges).reverse().map((r) => ({ op: "extract_range", from: r.from, to: r.to, ...tracks ? { tracks } : {} }));
+}
+function videoWordsRange(words, a, b) {
+  const [i, j] = a <= b ? [a, b] : [b, a];
+  return { from: words[i].start, to: words[j].end };
+}
+function videoTranscriptEdit(assetId, text) {
+  return { op: "update_asset", asset: assetId, set: { transcript: parseVideoTranscript(text).words } };
+}
+function videoWordAt(words, time) {
+  let lo = 0;
+  let hi = words.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    if (words[mid].end <= time) lo = mid + 1;
+    else if (words[mid].start > time) hi = mid - 1;
+    else return mid;
+  }
+  return -1;
+}
+
 // 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);
@@ -2991,6 +3170,10 @@ var issueSummary = (issues) => ({
   notes: issues.filter((i) => i.severity === "note").length,
   lines: issues.map((i) => `${i.severity}: ${i.message}`)
 });
+var videoAssetOut = (a) => {
+  const { transcript, ...rest } = a;
+  return transcript ? { ...rest, transcriptWords: transcript.length } : rest;
+};
 function describeVideoProject(project) {
   return {
     ...project.name ? { name: project.name } : {},
@@ -2999,7 +3182,7 @@ function describeVideoProject(project) {
     fps: project.fps,
     duration: videoProjectDuration(project),
     ...project.background ? { background: project.background } : {},
-    assets: project.assets,
+    assets: project.assets.map(videoAssetOut),
     tracks: project.tracks.map((t, index) => ({
       id: t.id,
       kind: t.kind,
@@ -3221,9 +3404,9 @@ function createVideoEditorToolProvider(controller, options = {}) {
     name: "update_video_asset",
     title: "Change media details",
     description: "Changes an asset's src, name, duration, size, sound or poster (e.g. relinking moved media). Clips that now run past its end are refused. Returns the asset.",
-    inputSchema: object({ asset: ASSET_ID, set: object(ASSET_FIELDS, [], "Fields to replace."), remove: { type: "array", items: { type: "string", enum: ["name", "duration", "width", "height", "hasAudio", "poster"] }, description: "Fields to clear." } }, ["asset"]),
+    inputSchema: object({ asset: ASSET_ID, set: object(ASSET_FIELDS, [], "Fields to replace."), remove: { type: "array", items: { type: "string", enum: ["name", "duration", "width", "height", "hasAudio", "poster", "transcript"] }, description: "Fields to clear (transcript removes its words)." } }, ["asset"]),
     annotations: { title: "Change media details", ...WRITE_IDEMPOTENT },
-    handler: ({ asset, set, remove }) => apply({ op: "update_asset", asset, set, remove }, "Change media", (r) => ({ asset: r.project.assets.find((a) => a.id === asset) }))
+    handler: ({ asset, set, remove }) => apply({ op: "update_asset", asset, set, remove }, "Change media", (r) => ({ asset: videoAssetOut(r.project.assets.find((a) => a.id === asset)) }))
   };
   const removeAsset = {
     name: "remove_video_asset",
@@ -3380,6 +3563,114 @@ function createVideoEditorToolProvider(controller, options = {}) {
       return apply(edits, "Copy grade", () => ({ grade: grade ?? null, clips: to }));
     }
   };
+  const TRANSCRIPT_TRACK = { ...TRACK_ID, description: "Track whose words to read (default: the first audio track with a transcribed clip, else the first video track with one)." };
+  const RANGE_OUT = (r) => ({ from: round(r.from), to: round(r.to), text: r.text });
+  const timelineWords = (track) => {
+    const words = videoTimelineTranscript(project(), { track });
+    if (!words.length) throw new Error(track ? `No clip on track "${track}" plays a transcribed asset; attach one with set_video_transcript.` : "No clip plays a transcribed asset; attach a transcript to the media with set_video_transcript first.");
+    return words;
+  };
+  const setTranscript = {
+    name: "set_video_transcript",
+    title: "Attach a transcript",
+    description: 'Attaches what is said in a video or audio asset, word by word, so the edit can be cut by text (one undo step). Pass "text" (Whisper-style JSON with word timings, SubRip or WebVTT, as the file says it) or "words" ([{ word, start, end }] in ms of the source). Captions have no word timings, so their words are spread across each cue (approximate). Replaces any transcript the asset had. Returns the word count, whether timings are approximate, and the first and last words.',
+    inputSchema: object(
+      {
+        asset: { ...ASSET_ID, description: "A video or audio asset." },
+        text: { type: "string", minLength: 1, description: "The transcript file's contents: Whisper-style JSON (times in seconds), .srt or .vtt. Pass this or words." },
+        words: { type: "array", minItems: 1, items: object({ word: { type: "string", minLength: 1, description: "The word as said." }, start: { type: "number", minimum: 0, description: "Start in ms of the source." }, end: { type: "number", minimum: 0, description: "End in ms of the source." } }, ["word", "start", "end"], "One word."), description: "Words with source times in ms. Pass this or text." }
+      },
+      ["asset"]
+    ),
+    annotations: { title: "Attach a transcript", ...WRITE_IDEMPOTENT },
+    handler: ({ asset, text, words }) => {
+      if (text === void 0 === (words === void 0)) throw new Error(`Pass either "text" (a transcript file's contents) or "words", not both.`);
+      const a = project().assets.find((x) => x.id === asset);
+      if (!a) throw new Error(`There is no asset "${asset}"; the assets are ${project().assets.map((x) => `"${x.id}"`).join(", ") || "none"}.`);
+      if (a.kind === "image") throw new Error(`Asset "${asset}" is an image and has no sound to transcribe.`);
+      const parsed = text !== void 0 ? parseVideoTranscript(text) : { words, approximate: false };
+      const list = parsed.words;
+      return apply({ op: "update_asset", asset, set: { transcript: list } }, "Attach transcript", () => ({
+        asset,
+        words: list.length,
+        approximate: parsed.approximate,
+        first: list[0],
+        last: list[list.length - 1],
+        ...a.duration !== void 0 && list[list.length - 1].end > a.duration + VIDEO_TIME_EPSILON ? { warning: `The transcript runs to ${list[list.length - 1].end} ms, past the asset's ${a.duration} ms: is it for this asset?` } : {}
+      }));
+    }
+  };
+  const getTranscript = {
+    name: "get_video_transcript",
+    title: "Read the transcript",
+    description: "Returns what the timeline says, in order, from the transcripts of the media its clips play on one track: the text, and each word with its timeline start and end (ms) and the clip that plays it, so ranges can go straight to remove_video_ranges or split_video_at. Words cut out of the edit are not included.",
+    inputSchema: object({
+      track: TRANSCRIPT_TRACK,
+      from: MS("Only words from this timeline time (default 0)"),
+      to: MS("Only words up to this timeline time (default the end)"),
+      limit: { type: "integer", minimum: 1, maximum: 5e3, description: 'Most words to return (default 1000); "more" says if there are others.' }
+    }),
+    annotations: { title: "Read the transcript", ...READ },
+    handler: ({ track, from, to, limit }) => {
+      const all = timelineWords(track).filter((w) => w.end > (from ?? 0) && w.start < (to ?? Infinity));
+      const words = all.slice(0, limit ?? 1e3);
+      return { track: words[0]?.track ?? videoTranscriptTrack(project(), track), text: words.map((w) => w.word).join(" "), words: words.map((w) => ({ word: w.word, start: round(w.start), end: round(w.end), clip: w.clip })), more: all.length > words.length };
+    }
+  };
+  const findText = {
+    name: "find_video_transcript_text",
+    title: "Find words in the transcript",
+    description: "Lists every place a word or phrase is said on the timeline (case and punctuation ignored) as { from, to, text } ranges in timeline ms, ready for remove_video_ranges, split_video_at or seek_video.",
+    inputSchema: object({ query: { type: "string", minLength: 1, description: "The word or phrase." }, track: TRANSCRIPT_TRACK }, ["query"]),
+    annotations: { title: "Find words in the transcript", ...READ },
+    handler: ({ query, track }) => ({ matches: findVideoTranscriptText(timelineWords(track), query).map(RANGE_OUT) })
+  };
+  const findFillers = {
+    name: "find_video_fillers",
+    title: "Find filler words",
+    description: `Lists filler words and phrases on the timeline as { from, to, text } ranges in timeline ms, longest phrase first so "you know" is found whole. Default fillers: ${VIDEO_DEFAULT_FILLERS.join(", ")} ("like" and "so" are left out as too often meant). Check them, then pass the ones to cut to remove_video_ranges.`,
+    inputSchema: object({ track: TRANSCRIPT_TRACK, fillers: { type: "array", minItems: 1, items: { type: "string", minLength: 1 }, description: "Words or phrases to treat as fillers instead of the defaults." } }),
+    annotations: { title: "Find filler words", ...READ },
+    handler: ({ track, fillers }) => {
+      const found = findVideoFillers(timelineWords(track), fillers);
+      return { fillers: found.map(RANGE_OUT), total: round(found.reduce((n2, r) => n2 + r.to - r.from, 0)) };
+    }
+  };
+  const findPauses = {
+    name: "find_video_pauses",
+    title: "Find pauses between words",
+    description: 'Lists the gaps between consecutive words on the timeline (within one clip) longer than "min", less "keep" next to each word so speech is not clipped, snapped inward to frames, as { from, to } ranges in timeline ms ready for remove_video_ranges. Uses word timings; find_video_silences measures the sound instead.',
+    inputSchema: object({
+      track: TRANSCRIPT_TRACK,
+      min: { type: "number", exclusiveMinimum: 0, description: "Shortest gap that counts, in ms (default 700)." },
+      keep: { type: "number", minimum: 0, description: "Silence to keep after the word before and before the word after, in ms (default 150)." }
+    }),
+    annotations: { title: "Find pauses between words", ...READ },
+    handler: ({ track, min, keep }) => {
+      const found = findVideoTranscriptPauses(timelineWords(track), { min, keep, fps: project().fps });
+      return { pauses: found.map(RANGE_OUT), total: round(found.reduce((n2, r) => n2 + r.to - r.from, 0)) };
+    }
+  };
+  const removeRanges = {
+    name: "remove_video_ranges",
+    title: "Cut out stretches",
+    description: "Cuts stretches of the timeline out and closes them up, as one undo step: the ranges are merged where they touch and extracted from the last to the first, so the times from find_video_fillers, find_video_pauses, find_video_transcript_text or find_video_silences can be passed as they are. Like extract_video_range, every sync-locked track moves with the cut. Returns how many stretches and how much time were removed and the new length.",
+    inputSchema: object(
+      {
+        ranges: { type: "array", minItems: 1, maxItems: 500, items: object({ from: MS("Start, on the timeline"), to: MS("End, on the timeline"), text: { type: "string", description: "Ignored: the words in the stretch, as the find tools return them." } }, ["from", "to"], "A stretch to remove."), description: "The stretches, in any order (timeline ms)." },
+        tracks: { type: "array", items: TRACK_ID, minItems: 1, description: "Tracks to cut (default every unlocked track)." }
+      },
+      ["ranges"]
+    ),
+    annotations: { title: "Cut out stretches", ...DESTRUCTIVE },
+    handler: ({ ranges, tracks }) => {
+      const bad = ranges.findIndex((r) => !(r.to > r.from));
+      if (bad >= 0) throw new Error(`Range ${bad + 1} is empty or backwards (${ranges[bad].from}\u2013${ranges[bad].to} ms); "to" must be after "from".`);
+      const merged = mergeVideoRanges(ranges);
+      const before = videoProjectDuration(project());
+      return apply(videoRemoveRangesEdits(merged, tracks), merged.length > 1 ? `Cut ${merged.length} stretches` : "Cut stretch", (r) => ({ removed: merged.length, time: round(before - videoProjectDuration(r.project)), duration: videoProjectDuration(r.project) }));
+    }
+  };
   const setTransition = {
     name: "set_video_transition",
     title: "Set a transition",
@@ -3597,8 +3888,8 @@ function createVideoEditorToolProvider(controller, options = {}) {
       return { asset: r.asset.id, from: r.from, to: r.to, silences, total: round(silences.reduce((n2, x) => n2 + x.end - x.start, 0)) };
     }
   };
-  const reads = [getProject, getFrame, findGaps, checkProject, renderFrame, exportFfmpeg, exportLoudnessMeasure, exportEdl, audioLevels, findSilences, seek];
-  const writes = [setSettings, addAsset, updateAsset, removeAsset, addTrack, updateTrack, removeTrack, moveTrack, addClip, moveClip, trimClip, splitClip, deleteClips, updateClip, setTransition, applyGradePreset, copyGrade, setKeyframes, removeKeyframes, slipClip, rollEdit, slideClip, liftRange, extractRange, splitAt, closeGaps, addMarker, removeMarker, editVideo, undo, redo];
+  const reads = [getProject, getFrame, getTranscript, findText, findFillers, findPauses, findGaps, checkProject, renderFrame, exportFfmpeg, exportLoudnessMeasure, exportEdl, audioLevels, findSilences, seek];
+  const writes = [setSettings, addAsset, updateAsset, removeAsset, addTrack, updateTrack, removeTrack, moveTrack, addClip, moveClip, trimClip, splitClip, deleteClips, updateClip, setTransition, setTranscript, removeRanges, applyGradePreset, copyGrade, setKeyframes, removeKeyframes, slipClip, rollEdit, slideClip, liftRange, extractRange, splitAt, closeGaps, addMarker, removeMarker, editVideo, undo, redo];
   return {
     id: options.id ?? "video",
     namespace: options.namespace,
@@ -3843,6 +4134,7 @@ export {
   VIDEO_CLIP_ANIMATION_EFFECTS,
   VIDEO_CLIP_ANIMATION_LABELS,
   VIDEO_CLIP_TYPES,
+  VIDEO_DEFAULT_FILLERS,
   VIDEO_DEFAULT_STILL_DURATION,
   VIDEO_DEFAULT_TITLE_DURATION,
   VIDEO_EASE_NAMES,
@@ -3879,14 +4171,19 @@ export {
   ffmpegFilterValue,
   findVideoAudioSilences,
   findVideoClip,
+  findVideoFillers,
   findVideoGaps,
+  findVideoTranscriptPauses,
+  findVideoTranscriptText,
   formatVideoSeconds,
   formatVideoTimecode,
   formatVideoTimecodeFrames,
   isVideoDropFrameRate,
   isVideoKeyframes,
+  mergeVideoRanges,
   nextFreeVideoSlot,
   normalizeVideoGrade,
+  normalizeVideoWord,
   parseVideoAnimatable,
   parseVideoAsset,
   parseVideoClip,
@@ -3897,6 +4194,8 @@ export {
   parseVideoMarker,
   parseVideoProject,
   parseVideoTrack,
+  parseVideoTranscript,
+  parseVideoTranscriptWords,
   parseVideoTransform,
   parseVideoTransition,
   placeVideoRect,
@@ -3971,18 +4270,24 @@ export {
   videoPeakDb,
   videoProjectDuration,
   videoProjectSvg,
+  videoRemoveRangesEdits,
   videoRulerTicks,
   videoSnapPoints,
   videoTextStyle,
   videoTimecodeFrames,
+  videoTimelineTranscript,
   videoTitleFrame,
   videoTrackSyncLocked,
+  videoTranscriptEdit,
+  videoTranscriptTrack,
   videoTransformAt,
   videoTransitionAudioCurve,
   videoTransitionEase,
   videoTransitionHasDirection,
   videoValueAt,
   videoWaveformPath,
-  videoWipeRect
+  videoWipeRect,
+  videoWordAt,
+  videoWordsRange
 };
 //# sourceMappingURL=index.js.map