subcraft 0.0.0-stage → 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,180 @@
+/**
+ * Core normalized representation of a single subtitle cue.
+ * Timestamps are strictly stored in integer milliseconds.
+ */
+interface SubtitleCue {
+    /** Unique sequential identifier (e.g. "1", "2") */
+    id: string;
+    /** Start time in integer milliseconds */
+    start: number;
+    /** End time in integer milliseconds */
+    end: number;
+    /** Raw subtitle text content (may contain newlines) */
+    text: string;
+}
+/**
+ * Calculates the duration of a cue in milliseconds.
+ * Derived helper function to keep the core data model minimal and immutable.
+ */
+declare const getCueDuration: (cue: SubtitleCue) => number;
+/** Supported subtitle file formats */
+type TimecodeFormat = 'srt' | 'vtt';
+/**
+ * Detailed error reported when a cue block fails parsing syntax rules.
+ */
+interface ParseError {
+    index?: number;
+    rawBlock: string;
+    message: string;
+}
+/**
+ * Resilient parser result returning successfully parsed cues
+ * alongside any syntax errors encountered without throwing.
+ */
+interface ParseResult {
+    cues: SubtitleCue[];
+    errors: ParseError[];
+}
+/** Severity levels for lint diagnostics */
+type LintSeverity = 'error' | 'warning';
+/** Quality rules enforced by the linter */
+type LintRule = 'out-of-order' | 'overlap' | 'zero-or-negative-duration' | 'min-duration' | 'max-duration' | 'max-cpl' | 'max-cps';
+/**
+ * Diagnostic report produced when a cue violates a quality rule.
+ */
+interface LintDiagnostic {
+    cueId: string;
+    rule: LintRule;
+    severity: LintSeverity;
+    message: string;
+    expected?: number | string;
+    actual?: number | string;
+}
+/**
+ * Configuration options for locale-aware subtitle validation.
+ */
+interface LintProfile {
+    name: string;
+    locale?: string;
+    maxCps: number;
+    maxCpl: number;
+    minDurationMs: number;
+    maxDurationMs: number;
+    includeSpaces?: boolean;
+}
+
+/**
+ * Converts a formatted timecode string into integer milliseconds.
+ *
+ * Supported formats:
+ * - "01:23:45,678" (SRT standard)
+ * - "01:23:45.678" (WebVTT standard)
+ * - "23:45.678"    (WebVTT short form without hours)
+ *
+ * @throws {Error} if timecode format is invalid
+ */
+declare function timecodeToMs(timecode: string): number;
+/**
+ * Converts integer milliseconds into a standard formatted timecode string.
+ *
+ * @param ms - Non-negative integer milliseconds (negative values clamped to 0)
+ * @param format - 'srt' (uses comma delimiter) or 'vtt' (uses dot delimiter)
+ *
+ * @example
+ * msToTimecode(83456, 'srt') // "00:01:23,456"
+ * msToTimecode(83456, 'vtt') // "00:01:23.456"
+ */
+declare function msToTimecode(ms: number, format?: TimecodeFormat): string;
+/**
+ * Linearly shifts timecodes by a constant millisecond offset.
+ * Used to correct audio-sync delay or advance.
+ * Clamps negative results to 0.
+ *
+ * @param cues - Array of SubtitleCue objects
+ * @param offsetMs - Offset in milliseconds (positive advances, negative delays)
+ * @returns A new immutable array of shifted cues
+ */
+declare function shiftTimecodes(cues: readonly SubtitleCue[], offsetMs: number): SubtitleCue[];
+/**
+ * Scales all cue timecodes by a multiplicative ratio.
+ * Used for frame-rate drift compensation between video standards.
+ * All results are strictly rounded to integer milliseconds with Math.round.
+ *
+ * Direction definition:
+ * targetTimestamp = Math.round(sourceTimestamp * ratio)
+ *
+ * @example
+ * // 24 fps to 25 fps (PAL speed-up): video is ~4% faster, timecodes compress
+ * const palCues = retime(filmCues, 24 / 25); // ratio = 0.96
+ *
+ * @example
+ * // 25 fps to 24 fps (Slow-down): video is ~4% slower, timecodes stretch
+ * const filmCues = retime(palCues, 25 / 24); // ratio = 1.04167
+ *
+ * @param cues - Array of SubtitleCue objects
+ * @param ratio - Positive scaling multiplier (e.g., 24/25 or 25/24)
+ * @returns A new immutable array of retimed cues
+ */
+declare function retime(cues: readonly SubtitleCue[], ratio: number): SubtitleCue[];
+
+/**
+ * Parses raw SRT subtitle text into structured SubtitleCue objects.
+ * Resilient parser that collects syntax errors without throwing unhandled exceptions.
+ *
+ * Handles:
+ * - UTF-8 Byte Order Marks (BOM `\uFEFF`)
+ * - Windows (CRLF), Unix (LF), and legacy Mac (CR) line endings
+ * - Optional or missing cue numeric index headers
+ * - Multi-line subtitle texts
+ * - Trailing and irregular blank lines
+ *
+ * @param rawText - Raw SRT file content as a string
+ * @returns {ParseResult} Object containing successfully parsed cues and any block errors
+ */
+declare function parseSRT(rawText: string): ParseResult;
+
+/**
+ * Serializes an array of SubtitleCue objects into standard SRT file format.
+ *
+ * Output format:
+ * 1
+ * 00:00:20,000 --> 00:00:24,000
+ * Subtitle text
+ *
+ * @param cues - Array of SubtitleCue objects to format
+ * @returns Standard formatted SRT string
+ */
+declare function stringifySRT(cues: readonly SubtitleCue[]): string;
+
+/** Default quality profiles for subtitle verification */
+declare const DEFAULT_PROFILES: Record<string, LintProfile>;
+/**
+ * Strips HTML formatting tags from subtitle text before measuring character limits.
+ * Handles <i>, <b>, <u>, <font color="...">, etc.
+ */
+declare function stripFormattingTags(text: string): string;
+/**
+ * Counts user-perceived grapheme clusters using native ECMAScript Intl.Segmenter.
+ * Accurately measures multi-byte conjuncts and vowel modifiers in Indic scripts (Kannada, Hindi),
+ * as well as emojis and complex Unicode characters without UTF-16 code unit inflation.
+ */
+declare function countGraphemes(text: string, locale?: string): number;
+/**
+ * Inspects an array of SubtitleCues against timing, structural, and reading speed rules.
+ *
+ * Rules verified:
+ * - out-of-order: Cues not in ascending chronological order
+ * - zero-or-negative-duration: Cues where end <= start
+ * - overlap: Cues overlapping chronologically with preceding cues
+ * - min-duration: Cues flashing too fast for comprehension (< 800ms)
+ * - max-duration: Cues remaining on screen too long (> 7000ms)
+ * - max-cpl: Any line exceeding characters-per-line limit
+ * - max-cps: Reading speed exceeding characters-per-second limit
+ *
+ * @param cues - Array of SubtitleCue objects to inspect
+ * @param customProfile - Optional custom thresholds or language profile
+ * @returns Array of LintDiagnostic reports
+ */
+declare function lintCues(cues: readonly SubtitleCue[], customProfile?: Partial<LintProfile>): LintDiagnostic[];
+
+export { DEFAULT_PROFILES, type LintDiagnostic, type LintProfile, type LintRule, type LintSeverity, type ParseError, type ParseResult, type SubtitleCue, type TimecodeFormat, countGraphemes, getCueDuration, lintCues, msToTimecode, parseSRT, retime, shiftTimecodes, stringifySRT, stripFormattingTags, timecodeToMs };

package/dist/index.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Core normalized representation of a single subtitle cue.
+ * Timestamps are strictly stored in integer milliseconds.
+ */
+interface SubtitleCue {
+    /** Unique sequential identifier (e.g. "1", "2") */
+    id: string;
+    /** Start time in integer milliseconds */
+    start: number;
+    /** End time in integer milliseconds */
+    end: number;
+    /** Raw subtitle text content (may contain newlines) */
+    text: string;
+}
+/**
+ * Calculates the duration of a cue in milliseconds.
+ * Derived helper function to keep the core data model minimal and immutable.
+ */
+declare const getCueDuration: (cue: SubtitleCue) => number;
+/** Supported subtitle file formats */
+type TimecodeFormat = 'srt' | 'vtt';
+/**
+ * Detailed error reported when a cue block fails parsing syntax rules.
+ */
+interface ParseError {
+    index?: number;
+    rawBlock: string;
+    message: string;
+}
+/**
+ * Resilient parser result returning successfully parsed cues
+ * alongside any syntax errors encountered without throwing.
+ */
+interface ParseResult {
+    cues: SubtitleCue[];
+    errors: ParseError[];
+}
+/** Severity levels for lint diagnostics */
+type LintSeverity = 'error' | 'warning';
+/** Quality rules enforced by the linter */
+type LintRule = 'out-of-order' | 'overlap' | 'zero-or-negative-duration' | 'min-duration' | 'max-duration' | 'max-cpl' | 'max-cps';
+/**
+ * Diagnostic report produced when a cue violates a quality rule.
+ */
+interface LintDiagnostic {
+    cueId: string;
+    rule: LintRule;
+    severity: LintSeverity;
+    message: string;
+    expected?: number | string;
+    actual?: number | string;
+}
+/**
+ * Configuration options for locale-aware subtitle validation.
+ */
+interface LintProfile {
+    name: string;
+    locale?: string;
+    maxCps: number;
+    maxCpl: number;
+    minDurationMs: number;
+    maxDurationMs: number;
+    includeSpaces?: boolean;
+}
+
+/**
+ * Converts a formatted timecode string into integer milliseconds.
+ *
+ * Supported formats:
+ * - "01:23:45,678" (SRT standard)
+ * - "01:23:45.678" (WebVTT standard)
+ * - "23:45.678"    (WebVTT short form without hours)
+ *
+ * @throws {Error} if timecode format is invalid
+ */
+declare function timecodeToMs(timecode: string): number;
+/**
+ * Converts integer milliseconds into a standard formatted timecode string.
+ *
+ * @param ms - Non-negative integer milliseconds (negative values clamped to 0)
+ * @param format - 'srt' (uses comma delimiter) or 'vtt' (uses dot delimiter)
+ *
+ * @example
+ * msToTimecode(83456, 'srt') // "00:01:23,456"
+ * msToTimecode(83456, 'vtt') // "00:01:23.456"
+ */
+declare function msToTimecode(ms: number, format?: TimecodeFormat): string;
+/**
+ * Linearly shifts timecodes by a constant millisecond offset.
+ * Used to correct audio-sync delay or advance.
+ * Clamps negative results to 0.
+ *
+ * @param cues - Array of SubtitleCue objects
+ * @param offsetMs - Offset in milliseconds (positive advances, negative delays)
+ * @returns A new immutable array of shifted cues
+ */
+declare function shiftTimecodes(cues: readonly SubtitleCue[], offsetMs: number): SubtitleCue[];
+/**
+ * Scales all cue timecodes by a multiplicative ratio.
+ * Used for frame-rate drift compensation between video standards.
+ * All results are strictly rounded to integer milliseconds with Math.round.
+ *
+ * Direction definition:
+ * targetTimestamp = Math.round(sourceTimestamp * ratio)
+ *
+ * @example
+ * // 24 fps to 25 fps (PAL speed-up): video is ~4% faster, timecodes compress
+ * const palCues = retime(filmCues, 24 / 25); // ratio = 0.96
+ *
+ * @example
+ * // 25 fps to 24 fps (Slow-down): video is ~4% slower, timecodes stretch
+ * const filmCues = retime(palCues, 25 / 24); // ratio = 1.04167
+ *
+ * @param cues - Array of SubtitleCue objects
+ * @param ratio - Positive scaling multiplier (e.g., 24/25 or 25/24)
+ * @returns A new immutable array of retimed cues
+ */
+declare function retime(cues: readonly SubtitleCue[], ratio: number): SubtitleCue[];
+
+/**
+ * Parses raw SRT subtitle text into structured SubtitleCue objects.
+ * Resilient parser that collects syntax errors without throwing unhandled exceptions.
+ *
+ * Handles:
+ * - UTF-8 Byte Order Marks (BOM `\uFEFF`)
+ * - Windows (CRLF), Unix (LF), and legacy Mac (CR) line endings
+ * - Optional or missing cue numeric index headers
+ * - Multi-line subtitle texts
+ * - Trailing and irregular blank lines
+ *
+ * @param rawText - Raw SRT file content as a string
+ * @returns {ParseResult} Object containing successfully parsed cues and any block errors
+ */
+declare function parseSRT(rawText: string): ParseResult;
+
+/**
+ * Serializes an array of SubtitleCue objects into standard SRT file format.
+ *
+ * Output format:
+ * 1
+ * 00:00:20,000 --> 00:00:24,000
+ * Subtitle text
+ *
+ * @param cues - Array of SubtitleCue objects to format
+ * @returns Standard formatted SRT string
+ */
+declare function stringifySRT(cues: readonly SubtitleCue[]): string;
+
+/** Default quality profiles for subtitle verification */
+declare const DEFAULT_PROFILES: Record<string, LintProfile>;
+/**
+ * Strips HTML formatting tags from subtitle text before measuring character limits.
+ * Handles <i>, <b>, <u>, <font color="...">, etc.
+ */
+declare function stripFormattingTags(text: string): string;
+/**
+ * Counts user-perceived grapheme clusters using native ECMAScript Intl.Segmenter.
+ * Accurately measures multi-byte conjuncts and vowel modifiers in Indic scripts (Kannada, Hindi),
+ * as well as emojis and complex Unicode characters without UTF-16 code unit inflation.
+ */
+declare function countGraphemes(text: string, locale?: string): number;
+/**
+ * Inspects an array of SubtitleCues against timing, structural, and reading speed rules.
+ *
+ * Rules verified:
+ * - out-of-order: Cues not in ascending chronological order
+ * - zero-or-negative-duration: Cues where end <= start
+ * - overlap: Cues overlapping chronologically with preceding cues
+ * - min-duration: Cues flashing too fast for comprehension (< 800ms)
+ * - max-duration: Cues remaining on screen too long (> 7000ms)
+ * - max-cpl: Any line exceeding characters-per-line limit
+ * - max-cps: Reading speed exceeding characters-per-second limit
+ *
+ * @param cues - Array of SubtitleCue objects to inspect
+ * @param customProfile - Optional custom thresholds or language profile
+ * @returns Array of LintDiagnostic reports
+ */
+declare function lintCues(cues: readonly SubtitleCue[], customProfile?: Partial<LintProfile>): LintDiagnostic[];
+
+export { DEFAULT_PROFILES, type LintDiagnostic, type LintProfile, type LintRule, type LintSeverity, type ParseError, type ParseResult, type SubtitleCue, type TimecodeFormat, countGraphemes, getCueDuration, lintCues, msToTimecode, parseSRT, retime, shiftTimecodes, stringifySRT, stripFormattingTags, timecodeToMs };

package/dist/index.js

@@ -0,0 +1,280 @@
+// src/types.ts
+var getCueDuration = (cue) => cue.end - cue.start;
+
+// src/timecode.ts
+var TIMECODE_REGEX = /^(?:(?:(\d{1,2}):)?(\d{2}):)?(\d{2})[,.](\d{3})$/;
+function timecodeToMs(timecode) {
+  const trimmed = timecode.trim();
+  const match = trimmed.match(TIMECODE_REGEX);
+  if (!match) {
+    throw new Error(
+      `Invalid timecode format: "${timecode}". Expected "HH:MM:SS,mmm" or "HH:MM:SS.mmm".`
+    );
+  }
+  const hours = match[1] ? parseInt(match[1], 10) : 0;
+  const minutes = match[2] ? parseInt(match[2], 10) : 0;
+  const seconds = parseInt(match[3] ?? "0", 10);
+  const milliseconds = parseInt(match[4] ?? "0", 10);
+  return hours * 36e5 + minutes * 6e4 + seconds * 1e3 + milliseconds;
+}
+function msToTimecode(ms, format = "srt") {
+  const safeMs = Math.max(0, Math.floor(ms));
+  const hours = Math.floor(safeMs / 36e5);
+  const minutes = Math.floor(safeMs % 36e5 / 6e4);
+  const seconds = Math.floor(safeMs % 6e4 / 1e3);
+  const remainderMs = safeMs % 1e3;
+  const hh = String(hours).padStart(2, "0");
+  const mm = String(minutes).padStart(2, "0");
+  const ss = String(seconds).padStart(2, "0");
+  const mmm = String(remainderMs).padStart(3, "0");
+  const delimiter = format === "vtt" ? "." : ",";
+  return `${hh}:${mm}:${ss}${delimiter}${mmm}`;
+}
+function shiftTimecodes(cues, offsetMs) {
+  return cues.map((cue) => ({
+    ...cue,
+    start: Math.max(0, cue.start + offsetMs),
+    end: Math.max(0, cue.end + offsetMs)
+  }));
+}
+function retime(cues, ratio) {
+  if (ratio <= 0) {
+    throw new Error(`Retime ratio must be greater than 0. Received: ${ratio}`);
+  }
+  return cues.map((cue) => ({
+    ...cue,
+    start: Math.round(cue.start * ratio),
+    end: Math.round(cue.end * ratio)
+  }));
+}
+
+// src/parser.ts
+var ARROW_REGEX = /((?:\d{1,2}:)?\d{2}:\d{2}[,.]\d{3})\s*-->\s*((?:\d{1,2}:)?\d{2}:\d{2}[,.]\d{3})/;
+function parseSRT(rawText) {
+  const cues = [];
+  const errors = [];
+  if (!rawText || !rawText.trim()) {
+    return { cues, errors };
+  }
+  const cleanText = rawText.replace(/^\uFEFF/, "");
+  const normalized = cleanText.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const rawBlocks = normalized.trim().split(/\n\s*\n+/);
+  let fallbackIndex = 1;
+  for (let bIndex = 0; bIndex < rawBlocks.length; bIndex++) {
+    const rawBlock = rawBlocks[bIndex]?.trim();
+    if (!rawBlock) continue;
+    const lines = rawBlock.split("\n");
+    let id;
+    let timecodeLine;
+    let textLines;
+    if (lines[0] && ARROW_REGEX.test(lines[0])) {
+      id = String(fallbackIndex);
+      timecodeLine = lines[0];
+      textLines = lines.slice(1);
+    } else if (lines[1] && ARROW_REGEX.test(lines[1])) {
+      id = lines[0]?.trim() || String(fallbackIndex);
+      timecodeLine = lines[1];
+      textLines = lines.slice(2);
+    } else {
+      errors.push({
+        index: fallbackIndex,
+        rawBlock,
+        message: 'Invalid block format. Expected timecode arrow "-->" on line 1 or 2.'
+      });
+      continue;
+    }
+    const match = timecodeLine.match(ARROW_REGEX);
+    if (!match || !match[1] || !match[2]) {
+      errors.push({
+        index: fallbackIndex,
+        rawBlock,
+        message: `Failed to extract start and end timestamps from: "${timecodeLine}".`
+      });
+      continue;
+    }
+    try {
+      const start = timecodeToMs(match[1]);
+      const end = timecodeToMs(match[2]);
+      const text = textLines.join("\n").trim();
+      cues.push({
+        id,
+        start,
+        end,
+        text
+      });
+      fallbackIndex++;
+    } catch (err) {
+      errors.push({
+        index: fallbackIndex,
+        rawBlock,
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return { cues, errors };
+}
+
+// src/serializer.ts
+function stringifySRT(cues) {
+  if (!cues || cues.length === 0) {
+    return "";
+  }
+  const blocks = cues.map((cue, idx) => {
+    const id = cue.id ? String(cue.id) : String(idx + 1);
+    const startStr = msToTimecode(cue.start, "srt");
+    const endStr = msToTimecode(cue.end, "srt");
+    const text = cue.text ?? "";
+    return `${id}
+${startStr} --> ${endStr}
+${text}`;
+  });
+  return blocks.join("\n\n") + "\n";
+}
+
+// src/linter.ts
+var DEFAULT_PROFILES = {
+  standardLatin: {
+    name: "Standard Latin (Netflix/BBC Style Guide)",
+    locale: "en",
+    maxCps: 20,
+    maxCpl: 42,
+    minDurationMs: 800,
+    maxDurationMs: 7e3,
+    includeSpaces: true
+  },
+  indicKannada: {
+    name: "Indic - Kannada Locale",
+    locale: "kn",
+    maxCps: 15,
+    maxCpl: 35,
+    minDurationMs: 800,
+    maxDurationMs: 7e3,
+    includeSpaces: true
+  }
+};
+function stripFormattingTags(text) {
+  return text.replace(/<[^>]*>/g, "");
+}
+function countGraphemes(text, locale = "en") {
+  if (!text) return 0;
+  if (typeof Intl !== "undefined" && "Segmenter" in Intl) {
+    const segmenter = new Intl.Segmenter(locale, { granularity: "grapheme" });
+    let count = 0;
+    for (const _ of segmenter.segment(text)) {
+      count++;
+    }
+    return count;
+  }
+  return [...text].length;
+}
+function lintCues(cues, customProfile) {
+  const diagnostics = [];
+  if (!cues || cues.length === 0) return diagnostics;
+  const profile = {
+    ...DEFAULT_PROFILES["standardLatin"],
+    ...customProfile
+  };
+  const {
+    locale = "en",
+    maxCps,
+    maxCpl,
+    minDurationMs,
+    maxDurationMs,
+    includeSpaces = true
+  } = profile;
+  for (let i = 0; i < cues.length; i++) {
+    const cue = cues[i];
+    if (!cue) continue;
+    const prevCue = i > 0 ? cues[i - 1] : void 0;
+    const duration = cue.end - cue.start;
+    if (prevCue && cue.start < prevCue.start) {
+      diagnostics.push({
+        cueId: cue.id,
+        rule: "out-of-order",
+        severity: "error",
+        message: `Cue starts at ${cue.start}ms before previous cue start of ${prevCue.start}ms.`,
+        expected: `start >= ${prevCue.start}`,
+        actual: `start = ${cue.start}`
+      });
+    }
+    if (cue.end <= cue.start) {
+      diagnostics.push({
+        cueId: cue.id,
+        rule: "zero-or-negative-duration",
+        severity: "error",
+        message: `Cue has invalid duration (${duration}ms). End timestamp must be greater than start timestamp.`,
+        expected: `end > ${cue.start}`,
+        actual: `end = ${cue.end}`
+      });
+    }
+    if (prevCue && cue.start < prevCue.end && cue.start >= prevCue.start) {
+      const overlapMs = prevCue.end - cue.start;
+      diagnostics.push({
+        cueId: cue.id,
+        rule: "overlap",
+        severity: "error",
+        message: `Cue overlaps with previous cue by ${overlapMs}ms.`,
+        expected: `start >= ${prevCue.end}`,
+        actual: `start = ${cue.start}`
+      });
+    }
+    if (duration > 0 && duration < minDurationMs) {
+      diagnostics.push({
+        cueId: cue.id,
+        rule: "min-duration",
+        severity: "warning",
+        message: `Cue duration of ${duration}ms is below the minimum threshold of ${minDurationMs}ms.`,
+        expected: minDurationMs,
+        actual: duration
+      });
+    }
+    if (duration > maxDurationMs) {
+      diagnostics.push({
+        cueId: cue.id,
+        rule: "max-duration",
+        severity: "warning",
+        message: `Cue duration of ${duration}ms exceeds the maximum threshold of ${maxDurationMs}ms.`,
+        expected: maxDurationMs,
+        actual: duration
+      });
+    }
+    const rawText = cue.text || "";
+    const cleanText = stripFormattingTags(rawText);
+    const lines = cleanText.split("\n");
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+      const line = lines[lineIndex];
+      if (!line) continue;
+      const cpl = countGraphemes(line, locale);
+      if (cpl > maxCpl) {
+        diagnostics.push({
+          cueId: cue.id,
+          rule: "max-cpl",
+          severity: "warning",
+          message: `Line ${lineIndex + 1} has ${cpl} characters, exceeding the maximum limit of ${maxCpl} CPL.`,
+          expected: maxCpl,
+          actual: cpl
+        });
+      }
+    }
+    if (duration > 0) {
+      const textToMeasure = includeSpaces ? cleanText : cleanText.replace(/\s+/g, "");
+      const totalGraphemes = countGraphemes(textToMeasure, locale);
+      const cps = Number((totalGraphemes / duration * 1e3).toFixed(1));
+      if (cps > maxCps) {
+        diagnostics.push({
+          cueId: cue.id,
+          rule: "max-cps",
+          severity: "warning",
+          message: `Reading speed of ${cps} CPS exceeds maximum limit of ${maxCps} CPS.`,
+          expected: maxCps,
+          actual: cps
+        });
+      }
+    }
+  }
+  return diagnostics;
+}
+
+export { DEFAULT_PROFILES, countGraphemes, getCueDuration, lintCues, msToTimecode, parseSRT, retime, shiftTimecodes, stringifySRT, stripFormattingTags, timecodeToMs };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map