@remotion/captions 4.0.513 → 4.0.515

package/dist/create-tiktok-style-captions.d.ts

@@ -13,8 +13,9 @@ export type TikTokPage = {
 export type CreateTikTokStyleCaptionsInput = {
     captions: Caption[];
     combineTokensWithinMilliseconds: number;
+    breakOnSilenceAfterMilliseconds?: number;
 };
 export type CreateTikTokStyleCaptionsOutput = {
     pages: TikTokPage[];
 };
-export declare const createTikTokStyleCaptions: ({ captions, combineTokensWithinMilliseconds, }: CreateTikTokStyleCaptionsInput) => CreateTikTokStyleCaptionsOutput;
+export declare const createTikTokStyleCaptions: ({ captions, combineTokensWithinMilliseconds, breakOnSilenceAfterMilliseconds, }: CreateTikTokStyleCaptionsInput) => CreateTikTokStyleCaptionsOutput;

package/dist/create-tiktok-style-captions.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTikTokStyleCaptions = void 0;
-const createTikTokStyleCaptions = ({ captions, combineTokensWithinMilliseconds, }) => {
+const createTikTokStyleCaptions = ({ captions, combineTokensWithinMilliseconds, breakOnSilenceAfterMilliseconds, }) => {
     const tikTokStyleCaptions = [];
     let currentText = '';
     let currentTokens = [];
@@ -22,9 +22,13 @@ const createTikTokStyleCaptions = ({ captions, combineTokensWithinMilliseconds,
     };
     captions.forEach((item, index) => {
         const { text } = item;
+        const exceedsDuration = currentTo - currentFrom > combineTokensWithinMilliseconds;
+        // A pause between the previous caption and this one
+        const shouldBreakOnSilence = breakOnSilenceAfterMilliseconds !== undefined &&
+            currentText !== '' &&
+            item.startMs - currentTo >= breakOnSilenceAfterMilliseconds;
         // If text starts with a space, push the currentText (if it exists) and start a new one
-        if (text.startsWith(' ') &&
-            currentTo - currentFrom > combineTokensWithinMilliseconds) {
+        if (text.startsWith(' ') && (exceedsDuration || shouldBreakOnSilence)) {
             if (currentText !== '') {
                 add();
             }
@@ -60,6 +64,10 @@ const createTikTokStyleCaptions = ({ captions, combineTokensWithinMilliseconds,
                 currentTo - tikTokStyleCaptions[tikTokStyleCaptions.length - 1].startMs;
         }
     });
+    const lastPage = tikTokStyleCaptions[tikTokStyleCaptions.length - 1];
+    if (lastPage && lastPage.durationMs === Infinity) {
+        lastPage.durationMs = currentTo - lastPage.startMs;
+    }
     return { pages: tikTokStyleCaptions };
 };
 exports.createTikTokStyleCaptions = createTikTokStyleCaptions;

package/dist/ensure-max-characters-per-line.js

@@ -5,7 +5,7 @@ const splitWords = (inputCaptions) => {
     const captions = [];
     for (let i = 0; i < inputCaptions.length; i++) {
         const w = inputCaptions[i];
-        const words = w.text.split(' ');
+        const words = w.text.split(' ').filter(Boolean);
         for (let j = 0; j < words.length; j++) {
             const word = words[j];
             captions.push({

package/dist/esm/index.mjs

@@ -0,0 +1,200 @@
+// src/ensure-max-characters-per-line.ts
+var splitWords = (inputCaptions) => {
+  const captions = [];
+  for (let i = 0;i < inputCaptions.length; i++) {
+    const w = inputCaptions[i];
+    const words = w.text.split(" ").filter(Boolean);
+    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 };
+};
+// src/create-tiktok-style-captions.ts
+var createTikTokStyleCaptions = ({
+  captions,
+  combineTokensWithinMilliseconds,
+  breakOnSilenceAfterMilliseconds
+}) => {
+  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;
+    const exceedsDuration = currentTo - currentFrom > combineTokensWithinMilliseconds;
+    const shouldBreakOnSilence = breakOnSilenceAfterMilliseconds !== undefined && currentText !== "" && item.startMs - currentTo >= breakOnSilenceAfterMilliseconds;
+    if (text.startsWith(" ") && (exceedsDuration || shouldBreakOnSilence)) {
+      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;
+    }
+  });
+  const lastPage = tikTokStyleCaptions[tikTokStyleCaptions.length - 1];
+  if (lastPage && lastPage.durationMs === Infinity) {
+    lastPage.durationMs = currentTo - lastPage.startMs;
+  }
+  return { pages: tikTokStyleCaptions };
+};
+// src/parse-srt.ts
+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) / 1000;
+}
+var parseSrt = ({ input }) => {
+  const inputLines = input.split(`
+`);
+  const captions = [];
+  for (let i = 0;i < inputLines.length; i++) {
+    const line = inputLines[i];
+    const nextLine = inputLines[i + 1];
+    if (line?.match(/([0-9]+)/) && nextLine?.includes(" --> ")) {
+      const nextLineSplit = nextLine.split(" --> ");
+      const start = toSeconds(nextLineSplit[0]);
+      const end = toSeconds(nextLineSplit[1]);
+      captions.push({
+        text: "",
+        startMs: start * 1000,
+        endMs: end * 1000,
+        confidence: 1,
+        timestampMs: (start + end) / 2 * 1000
+      });
+    } else if (line?.includes(" --> ")) {
+      continue;
+    } else if (line?.trim() === "") {
+      captions[captions.length - 1].text = captions[captions.length - 1].text.trim();
+    } else {
+      captions[captions.length - 1].text += line + `
+`;
+    }
+  }
+  return {
+    captions: captions.map((l) => {
+      return {
+        ...l,
+        text: l.text.trimEnd()
+      };
+    })
+  };
+};
+// src/serialize-srt.ts
+var formatSingleSrtTimestamp = (timestamp) => {
+  const hours = Math.floor(timestamp / 3600000);
+  const minutes = Math.floor(timestamp % 3600000 / 60000);
+  const seconds = Math.floor(timestamp % 60000 / 1000);
+  const milliseconds = Math.floor(timestamp % 1000);
+  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 [
+      currentIndex,
+      formatSrtTimestamp(firstTimestamp, lastTimestamp),
+      s.map((caption) => caption.text).join("")
+    ].join(`
+`);
+  }).filter(Boolean).join(`
+
+`);
+};
+
+// src/index.ts
+var CaptionsInternals = {
+  ensureMaxCharactersPerLine
+};
+export {
+  serializeSrt,
+  parseSrt,
+  createTikTokStyleCaptions,
+  CaptionsInternals
+};

package/package.json

@@ -3,9 +3,11 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/captions"
 	},
 	"name": "@remotion/captions",
-	"version": "4.0.513",
+	"version": "4.0.515",
 	"description": "Primitives for dealing with captions",
 	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"module": "dist/esm/index.mjs",
 	"bugs": {
 		"url": "https://github.com/remotion-dev/remotion/issues"
 	},
@@ -14,20 +16,29 @@
 		"format": "oxfmt src",
 		"lint": "eslint src",
 		"test": "bun test src",
-		"make": "tsgo -d"
+		"make": "tsgo -d && bun --env-file=../.env.bundle bundle.ts"
 	},
 	"author": "Jonny Burger <jonny@remotion.dev>",
 	"license": "MIT",
 	"dependencies": {},
 	"peerDependencies": {},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.513",
+		"@remotion/eslint-config-internal": "4.0.515",
 		"eslint": "9.19.0",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1"
 	},
 	"keywords": [
 		"remotion"
 	],
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"types": "./dist/index.d.ts",
+			"module": "./dist/esm/index.mjs",
+			"import": "./dist/esm/index.mjs",
+			"require": "./dist/index.js"
+		}
+	},
 	"publishConfig": {
 		"access": "public"
 	},