srtsync 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rodrigo Polo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# srtsync
+
+Resync SRT subtitle files — shift timestamps by a fixed offset or linearly rescale them to match a different video duration.
+
+Works as a **CLI tool** and as a **Node.js / browser library**. Zero runtime dependencies.
+
+## Install
+
+```bash
+npm install srtsync
+```
+
+## CLI
+
+### Shift all timestamps by a fixed offset
+
+```bash
+srtsync shift <offset> <file.srt> [-o output.srt]
+```
+
+The offset format is `[+|-]HH:MM:SS.mmm`:
+
+```bash
+# Shift subtitles forward by 1.5 seconds
+srtsync shift +00:00:01.500 movie.srt > movie-fixed.srt
+
+# Shift subtitles back by 3 seconds, write to file
+srtsync shift -00:00:03.000 movie.srt -o movie-fixed.srt
+```
+
+### Linearly rescale timestamps
+
+Use this when the video has been rate-stretched (e.g. PAL speed-up from 24fps to 25fps) and all timestamps need proportional adjustment.
+
+```bash
+srtsync linear <newFirst> <newLast> <file.srt> [-o output.srt]
+```
+
+You provide the correct start time for the **first** and **last** subtitle. Every timestamp in between is linearly interpolated:
+
+```bash
+# The first subtitle should start at 00:00:21.278
+# and the last subtitle should start at 01:18:48.956
+srtsync linear 00:00:21.278 01:18:48.956 movie.srt > movie-fixed.srt
+```
+
+Output goes to **stdout** by default (pipe-friendly), or use `-o` to write directly to a file.
+
+## Library
+
+### `timeShift(srtContent, offset)`
+
+Parse an SRT string, shift all timestamps, and return the resynced SRT string.
+
+```js
+import { timeShift } from "srtsync";
+import { readFileSync } from "fs";
+
+const srt = readFileSync("movie.srt", "utf-8");
+const shifted = timeShift(srt, "+00:00:02.000");
+```
+
+### `linearCorrection(srtContent, newFirst, newLast)`
+
+Parse an SRT string, linearly rescale all timestamps between two reference points, and return the resynced SRT string.
+
+```js
+import { linearCorrection } from "srtsync";
+import { readFileSync } from "fs";
+
+const srt = readFileSync("movie.srt", "utf-8");
+const corrected = linearCorrection(srt, "00:00:21.278", "01:18:48.956");
+```
+
+### Lower-level API
+
+For more control, you can work with parsed subtitle objects directly:
+
+```js
+import {
+  parseSrt,
+  formatSrt,
+  applyShift,
+  applyLinearCorrection,
+  parseTimestamp,
+  formatTimestamp,
+} from "srtsync";
+
+const subs = parseSrt(srtContent);
+// => [{ index: 1, startMs: 20400, endMs: 21680, text: "Hello" }, ...]
+
+// Shift by 5 seconds
+const shifted = applyShift(subs, 5000);
+
+// Or linearly rescale
+const corrected = applyLinearCorrection(subs, 21278, 4728956);
+
+// Serialize back to SRT
+const output = formatSrt(corrected);
+```
+
+The `Subtitle` type is also exported:
+
+```ts
+import type { Subtitle } from "srtsync";
+```
+
+## How linear correction works
+
+Given the start time of the first and last subtitles as reference points, every timestamp is rescaled with a linear mapping:
+
+```
+scale = (newLast - newFirst) / (origLast - origFirst)
+new_t = newFirst + (t - origFirst) * scale
+```
+
+This corrects uniform drift caused by frame-rate conversion, player speed changes, or different video cuts.
+
+## Timestamp format
+
+All timestamp arguments accept both SRT-standard comma separators and dot separators:
+
+- `00:01:30,500` (SRT standard)
+- `00:01:30.500` (also accepted)
+
+Offsets accept an optional `+`/`-` sign prefix. Unsigned offsets are treated as positive.
+
+## License
+
+MIT

package/dist/cli.mjs

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync, writeFileSync } from "fs";
+
+// src/time.ts
+function parseTimestamp(ts) {
+  const m = ts.trim().match(/^(\d{2}):(\d{2}):(\d{2})[,.](\d{3})$/);
+  if (!m) throw new Error(`Invalid timestamp: "${ts}"`);
+  const [, h, min, sec, ms] = m;
+  return Number(h) * 36e5 + Number(min) * 6e4 + Number(sec) * 1e3 + Number(ms);
+}
+function formatTimestamp(ms) {
+  if (ms < 0) ms = 0;
+  const h = Math.floor(ms / 36e5);
+  ms %= 36e5;
+  const min = Math.floor(ms / 6e4);
+  ms %= 6e4;
+  const sec = Math.floor(ms / 1e3);
+  const millis = ms % 1e3;
+  return String(h).padStart(2, "0") + ":" + String(min).padStart(2, "0") + ":" + String(sec).padStart(2, "0") + "," + String(millis).padStart(3, "0");
+}
+function parseOffset(offset) {
+  const m = offset.trim().match(/^([+-]?)(\d{2}):(\d{2}):(\d{2})[,.](\d{3})$/);
+  if (!m) throw new Error(`Invalid offset: "${offset}"`);
+  const [, sign, h, min, sec, ms] = m;
+  const value = Number(h) * 36e5 + Number(min) * 6e4 + Number(sec) * 1e3 + Number(ms);
+  return sign === "-" ? -value : value;
+}
+
+// src/parser.ts
+function parseSrt(content) {
+  const normalized = content.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const blocks = normalized.trim().split(/\n\n+/);
+  const subtitles = [];
+  for (const block of blocks) {
+    const lines = block.trim().split("\n");
+    if (lines.length < 3) continue;
+    const index = parseInt(lines[0], 10);
+    if (isNaN(index)) continue;
+    const timeLine = lines[1];
+    const timeMatch = timeLine.match(
+      /(\d{2}:\d{2}:\d{2}[,.]\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2}[,.]\d{3})/
+    );
+    if (!timeMatch) continue;
+    const startMs = parseTimestamp(timeMatch[1]);
+    const endMs = parseTimestamp(timeMatch[2]);
+    const text = lines.slice(2).join("\n");
+    subtitles.push({ index, startMs, endMs, text });
+  }
+  return subtitles;
+}
+function formatSrt(subtitles) {
+  return subtitles.map((sub, i) => {
+    const idx = i + 1;
+    const start = formatTimestamp(sub.startMs);
+    const end = formatTimestamp(sub.endMs);
+    return `${idx}
+${start} --> ${end}
+${sub.text}`;
+  }).join("\n\n") + "\n";
+}
+
+// src/shift.ts
+function applyShift(subtitles, offsetMs) {
+  return subtitles.map((sub) => ({
+    ...sub,
+    startMs: Math.max(0, sub.startMs + offsetMs),
+    endMs: Math.max(0, sub.endMs + offsetMs)
+  }));
+}
+
+// src/linear.ts
+function applyLinearCorrection(subtitles, newFirstMs, newLastMs) {
+  if (subtitles.length < 2) {
+    throw new Error("Need at least 2 subtitles for linear correction");
+  }
+  const origFirst = subtitles[0].startMs;
+  const origLast = subtitles[subtitles.length - 1].startMs;
+  const scale = (newLastMs - newFirstMs) / (origLast - origFirst);
+  return subtitles.map((sub) => ({
+    ...sub,
+    startMs: Math.max(0, Math.round(newFirstMs + (sub.startMs - origFirst) * scale)),
+    endMs: Math.max(0, Math.round(newFirstMs + (sub.endMs - origFirst) * scale))
+  }));
+}
+
+// src/index.ts
+function timeShift(srtContent, offset) {
+  const subs = parseSrt(srtContent);
+  const offsetMs = parseOffset(offset);
+  return formatSrt(applyShift(subs, offsetMs));
+}
+function linearCorrection(srtContent, newFirst, newLast) {
+  const subs = parseSrt(srtContent);
+  const newFirstMs = parseTimestamp(newFirst);
+  const newLastMs = parseTimestamp(newLast);
+  return formatSrt(applyLinearCorrection(subs, newFirstMs, newLastMs));
+}
+
+// src/cli.ts
+function usage() {
+  console.error(
+    `Usage:
+  srtsync shift <offset> <file.srt> [-o output.srt]
+  srtsync linear <newFirst> <newLast> <file.srt> [-o output.srt]
+
+Examples:
+  srtsync shift +00:00:01.000 input.srt > output.srt
+  srtsync linear 00:00:21.278 01:18:48.956 input.srt -o output.srt`
+  );
+  process.exit(1);
+}
+function main() {
+  const args = process.argv.slice(2);
+  if (args.length < 1) usage();
+  const command = args[0];
+  let result;
+  if (command === "shift") {
+    if (args.length < 3) usage();
+    const offset = args[1];
+    const file = args[2];
+    const content = readFileSync(file, "utf-8");
+    result = timeShift(content, offset);
+  } else if (command === "linear") {
+    if (args.length < 4) usage();
+    const newFirst = args[1];
+    const newLast = args[2];
+    const file = args[3];
+    const content = readFileSync(file, "utf-8");
+    result = linearCorrection(content, newFirst, newLast);
+  } else {
+    usage();
+  }
+  const oIdx = args.indexOf("-o");
+  if (oIdx !== -1 && args[oIdx + 1]) {
+    writeFileSync(args[oIdx + 1], result, "utf-8");
+  } else {
+    process.stdout.write(result);
+  }
+}
+main();

package/dist/index.cjs

@@ -0,0 +1,138 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  applyLinearCorrection: () => applyLinearCorrection,
+  applyShift: () => applyShift,
+  formatSrt: () => formatSrt,
+  formatTimestamp: () => formatTimestamp,
+  linearCorrection: () => linearCorrection,
+  parseSrt: () => parseSrt,
+  parseTimestamp: () => parseTimestamp,
+  timeShift: () => timeShift
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/time.ts
+function parseTimestamp(ts) {
+  const m = ts.trim().match(/^(\d{2}):(\d{2}):(\d{2})[,.](\d{3})$/);
+  if (!m) throw new Error(`Invalid timestamp: "${ts}"`);
+  const [, h, min, sec, ms] = m;
+  return Number(h) * 36e5 + Number(min) * 6e4 + Number(sec) * 1e3 + Number(ms);
+}
+function formatTimestamp(ms) {
+  if (ms < 0) ms = 0;
+  const h = Math.floor(ms / 36e5);
+  ms %= 36e5;
+  const min = Math.floor(ms / 6e4);
+  ms %= 6e4;
+  const sec = Math.floor(ms / 1e3);
+  const millis = ms % 1e3;
+  return String(h).padStart(2, "0") + ":" + String(min).padStart(2, "0") + ":" + String(sec).padStart(2, "0") + "," + String(millis).padStart(3, "0");
+}
+function parseOffset(offset) {
+  const m = offset.trim().match(/^([+-]?)(\d{2}):(\d{2}):(\d{2})[,.](\d{3})$/);
+  if (!m) throw new Error(`Invalid offset: "${offset}"`);
+  const [, sign, h, min, sec, ms] = m;
+  const value = Number(h) * 36e5 + Number(min) * 6e4 + Number(sec) * 1e3 + Number(ms);
+  return sign === "-" ? -value : value;
+}
+
+// src/parser.ts
+function parseSrt(content) {
+  const normalized = content.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const blocks = normalized.trim().split(/\n\n+/);
+  const subtitles = [];
+  for (const block of blocks) {
+    const lines = block.trim().split("\n");
+    if (lines.length < 3) continue;
+    const index = parseInt(lines[0], 10);
+    if (isNaN(index)) continue;
+    const timeLine = lines[1];
+    const timeMatch = timeLine.match(
+      /(\d{2}:\d{2}:\d{2}[,.]\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2}[,.]\d{3})/
+    );
+    if (!timeMatch) continue;
+    const startMs = parseTimestamp(timeMatch[1]);
+    const endMs = parseTimestamp(timeMatch[2]);
+    const text = lines.slice(2).join("\n");
+    subtitles.push({ index, startMs, endMs, text });
+  }
+  return subtitles;
+}
+function formatSrt(subtitles) {
+  return subtitles.map((sub, i) => {
+    const idx = i + 1;
+    const start = formatTimestamp(sub.startMs);
+    const end = formatTimestamp(sub.endMs);
+    return `${idx}
+${start} --> ${end}
+${sub.text}`;
+  }).join("\n\n") + "\n";
+}
+
+// src/shift.ts
+function applyShift(subtitles, offsetMs) {
+  return subtitles.map((sub) => ({
+    ...sub,
+    startMs: Math.max(0, sub.startMs + offsetMs),
+    endMs: Math.max(0, sub.endMs + offsetMs)
+  }));
+}
+
+// src/linear.ts
+function applyLinearCorrection(subtitles, newFirstMs, newLastMs) {
+  if (subtitles.length < 2) {
+    throw new Error("Need at least 2 subtitles for linear correction");
+  }
+  const origFirst = subtitles[0].startMs;
+  const origLast = subtitles[subtitles.length - 1].startMs;
+  const scale = (newLastMs - newFirstMs) / (origLast - origFirst);
+  return subtitles.map((sub) => ({
+    ...sub,
+    startMs: Math.max(0, Math.round(newFirstMs + (sub.startMs - origFirst) * scale)),
+    endMs: Math.max(0, Math.round(newFirstMs + (sub.endMs - origFirst) * scale))
+  }));
+}
+
+// src/index.ts
+function timeShift(srtContent, offset) {
+  const subs = parseSrt(srtContent);
+  const offsetMs = parseOffset(offset);
+  return formatSrt(applyShift(subs, offsetMs));
+}
+function linearCorrection(srtContent, newFirst, newLast) {
+  const subs = parseSrt(srtContent);
+  const newFirstMs = parseTimestamp(newFirst);
+  const newLastMs = parseTimestamp(newLast);
+  return formatSrt(applyLinearCorrection(subs, newFirstMs, newLastMs));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyLinearCorrection,
+  applyShift,
+  formatSrt,
+  formatTimestamp,
+  linearCorrection,
+  parseSrt,
+  parseTimestamp,
+  timeShift
+});

package/dist/index.d.cts

@@ -0,0 +1,58 @@
+interface Subtitle {
+    index: number;
+    startMs: number;
+    endMs: number;
+    text: string;
+}
+/**
+ * Parse an SRT file into an array of Subtitle objects.
+ */
+declare function parseSrt(content: string): Subtitle[];
+/**
+ * Serialize an array of Subtitle objects back to SRT format.
+ * Re-indexes subtitles starting from 1.
+ */
+declare function formatSrt(subtitles: Subtitle[]): string;
+
+/**
+ * Parse an SRT timestamp (HH:MM:SS,mmm or HH:MM:SS.mmm) into milliseconds.
+ */
+declare function parseTimestamp(ts: string): number;
+/**
+ * Format milliseconds into SRT timestamp format (HH:MM:SS,mmm).
+ * Clamps negative values to 0.
+ */
+declare function formatTimestamp(ms: number): string;
+
+/**
+ * Add a fixed offset (in milliseconds) to every subtitle timestamp.
+ * Clamps results to 0.
+ */
+declare function applyShift(subtitles: Subtitle[], offsetMs: number): Subtitle[];
+
+/**
+ * Linearly rescale all timestamps so that the first subtitle's start time
+ * maps to `newFirstMs` and the last subtitle's start time maps to `newLastMs`.
+ */
+declare function applyLinearCorrection(subtitles: Subtitle[], newFirstMs: number, newLastMs: number): Subtitle[];
+
+/**
+ * Parse an SRT string, shift all timestamps by the given offset, and return
+ * the resynced SRT string.
+ *
+ * @param srtContent - Raw SRT file content
+ * @param offset - Signed offset like "+00:00:01.000" or "-00:00:02.500"
+ */
+declare function timeShift(srtContent: string, offset: string): string;
+/**
+ * Parse an SRT string, linearly rescale timestamps so that the first subtitle
+ * starts at `newFirst` and the last subtitle starts at `newLast`, and return
+ * the resynced SRT string.
+ *
+ * @param srtContent - Raw SRT file content
+ * @param newFirst - New start time for the first subtitle (e.g. "00:00:21.278")
+ * @param newLast  - New start time for the last subtitle (e.g. "01:18:48.956")
+ */
+declare function linearCorrection(srtContent: string, newFirst: string, newLast: string): string;
+
+export { type Subtitle, applyLinearCorrection, applyShift, formatSrt, formatTimestamp, linearCorrection, parseSrt, parseTimestamp, timeShift };

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+interface Subtitle {
+    index: number;
+    startMs: number;
+    endMs: number;
+    text: string;
+}
+/**
+ * Parse an SRT file into an array of Subtitle objects.
+ */
+declare function parseSrt(content: string): Subtitle[];
+/**
+ * Serialize an array of Subtitle objects back to SRT format.
+ * Re-indexes subtitles starting from 1.
+ */
+declare function formatSrt(subtitles: Subtitle[]): string;
+
+/**
+ * Parse an SRT timestamp (HH:MM:SS,mmm or HH:MM:SS.mmm) into milliseconds.
+ */
+declare function parseTimestamp(ts: string): number;
+/**
+ * Format milliseconds into SRT timestamp format (HH:MM:SS,mmm).
+ * Clamps negative values to 0.
+ */
+declare function formatTimestamp(ms: number): string;
+
+/**
+ * Add a fixed offset (in milliseconds) to every subtitle timestamp.
+ * Clamps results to 0.
+ */
+declare function applyShift(subtitles: Subtitle[], offsetMs: number): Subtitle[];
+
+/**
+ * Linearly rescale all timestamps so that the first subtitle's start time
+ * maps to `newFirstMs` and the last subtitle's start time maps to `newLastMs`.
+ */
+declare function applyLinearCorrection(subtitles: Subtitle[], newFirstMs: number, newLastMs: number): Subtitle[];
+
+/**
+ * Parse an SRT string, shift all timestamps by the given offset, and return
+ * the resynced SRT string.
+ *
+ * @param srtContent - Raw SRT file content
+ * @param offset - Signed offset like "+00:00:01.000" or "-00:00:02.500"
+ */
+declare function timeShift(srtContent: string, offset: string): string;
+/**
+ * Parse an SRT string, linearly rescale timestamps so that the first subtitle
+ * starts at `newFirst` and the last subtitle starts at `newLast`, and return
+ * the resynced SRT string.
+ *
+ * @param srtContent - Raw SRT file content
+ * @param newFirst - New start time for the first subtitle (e.g. "00:00:21.278")
+ * @param newLast  - New start time for the last subtitle (e.g. "01:18:48.956")
+ */
+declare function linearCorrection(srtContent: string, newFirst: string, newLast: string): string;
+
+export { type Subtitle, applyLinearCorrection, applyShift, formatSrt, formatTimestamp, linearCorrection, parseSrt, parseTimestamp, timeShift };

package/dist/index.js

@@ -0,0 +1,104 @@
+// src/time.ts
+function parseTimestamp(ts) {
+  const m = ts.trim().match(/^(\d{2}):(\d{2}):(\d{2})[,.](\d{3})$/);
+  if (!m) throw new Error(`Invalid timestamp: "${ts}"`);
+  const [, h, min, sec, ms] = m;
+  return Number(h) * 36e5 + Number(min) * 6e4 + Number(sec) * 1e3 + Number(ms);
+}
+function formatTimestamp(ms) {
+  if (ms < 0) ms = 0;
+  const h = Math.floor(ms / 36e5);
+  ms %= 36e5;
+  const min = Math.floor(ms / 6e4);
+  ms %= 6e4;
+  const sec = Math.floor(ms / 1e3);
+  const millis = ms % 1e3;
+  return String(h).padStart(2, "0") + ":" + String(min).padStart(2, "0") + ":" + String(sec).padStart(2, "0") + "," + String(millis).padStart(3, "0");
+}
+function parseOffset(offset) {
+  const m = offset.trim().match(/^([+-]?)(\d{2}):(\d{2}):(\d{2})[,.](\d{3})$/);
+  if (!m) throw new Error(`Invalid offset: "${offset}"`);
+  const [, sign, h, min, sec, ms] = m;
+  const value = Number(h) * 36e5 + Number(min) * 6e4 + Number(sec) * 1e3 + Number(ms);
+  return sign === "-" ? -value : value;
+}
+
+// src/parser.ts
+function parseSrt(content) {
+  const normalized = content.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const blocks = normalized.trim().split(/\n\n+/);
+  const subtitles = [];
+  for (const block of blocks) {
+    const lines = block.trim().split("\n");
+    if (lines.length < 3) continue;
+    const index = parseInt(lines[0], 10);
+    if (isNaN(index)) continue;
+    const timeLine = lines[1];
+    const timeMatch = timeLine.match(
+      /(\d{2}:\d{2}:\d{2}[,.]\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2}[,.]\d{3})/
+    );
+    if (!timeMatch) continue;
+    const startMs = parseTimestamp(timeMatch[1]);
+    const endMs = parseTimestamp(timeMatch[2]);
+    const text = lines.slice(2).join("\n");
+    subtitles.push({ index, startMs, endMs, text });
+  }
+  return subtitles;
+}
+function formatSrt(subtitles) {
+  return subtitles.map((sub, i) => {
+    const idx = i + 1;
+    const start = formatTimestamp(sub.startMs);
+    const end = formatTimestamp(sub.endMs);
+    return `${idx}
+${start} --> ${end}
+${sub.text}`;
+  }).join("\n\n") + "\n";
+}
+
+// src/shift.ts
+function applyShift(subtitles, offsetMs) {
+  return subtitles.map((sub) => ({
+    ...sub,
+    startMs: Math.max(0, sub.startMs + offsetMs),
+    endMs: Math.max(0, sub.endMs + offsetMs)
+  }));
+}
+
+// src/linear.ts
+function applyLinearCorrection(subtitles, newFirstMs, newLastMs) {
+  if (subtitles.length < 2) {
+    throw new Error("Need at least 2 subtitles for linear correction");
+  }
+  const origFirst = subtitles[0].startMs;
+  const origLast = subtitles[subtitles.length - 1].startMs;
+  const scale = (newLastMs - newFirstMs) / (origLast - origFirst);
+  return subtitles.map((sub) => ({
+    ...sub,
+    startMs: Math.max(0, Math.round(newFirstMs + (sub.startMs - origFirst) * scale)),
+    endMs: Math.max(0, Math.round(newFirstMs + (sub.endMs - origFirst) * scale))
+  }));
+}
+
+// src/index.ts
+function timeShift(srtContent, offset) {
+  const subs = parseSrt(srtContent);
+  const offsetMs = parseOffset(offset);
+  return formatSrt(applyShift(subs, offsetMs));
+}
+function linearCorrection(srtContent, newFirst, newLast) {
+  const subs = parseSrt(srtContent);
+  const newFirstMs = parseTimestamp(newFirst);
+  const newLastMs = parseTimestamp(newLast);
+  return formatSrt(applyLinearCorrection(subs, newFirstMs, newLastMs));
+}
+export {
+  applyLinearCorrection,
+  applyShift,
+  formatSrt,
+  formatTimestamp,
+  linearCorrection,
+  parseSrt,
+  parseTimestamp,
+  timeShift
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "srtsync",
+  "version": "1.0.0",
+  "description": "Resync SRT subtitle files — shift timestamps or linearly rescale them",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "bin": {
+    "srtsync": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}