@tscaps/engine 0.2.1 → 0.3.1

package/dist/modules/transcription/CacheStorageModelFileCache.js

@@ -0,0 +1,86 @@
+import { ModelFileCacheUnavailableError } from '../transcription/ModelFileCacheUnavailableError';
+/**
+ * Keeps model files in the browser's Cache Storage.
+ *
+ * Browsers refuse this write far more often than one would expect —
+ * an origin over its quota, a private window, a page outside a secure
+ * context — and every refusal costs the next run a full re-download of
+ * hundreds of megabytes with nothing on screen to explain it. The
+ * refusal is therefore handed to `onKeepFailure` instead of being
+ * swallowed, while the run in flight carries on regardless: the files
+ * are already in memory and the transcription does not need them kept.
+ *
+ * Only the first refusal of an instance's lifetime is announced. A
+ * model is several files and the condition behind a refusal applies to
+ * all of them, so the rest would say the same thing again.
+ */
+export class CacheStorageModelFileCache {
+    onKeepFailure;
+    // The name transformers.js opens by default. Matching it keeps the
+    // files downloaded by earlier versions, which used the library's own
+    // caching, readable by this one.
+    static CACHE_NAME = 'transformers-cache';
+    opening = null;
+    failureAnnounced = false;
+    /**
+     * @param onKeepFailure Called at most once per instance, with the
+     * refusal that stopped a file from being kept.
+     */
+    constructor(onKeepFailure) {
+        this.onKeepFailure = onKeepFailure;
+    }
+    async match(key) {
+        const cache = await this.open();
+        if (!cache)
+            return undefined;
+        try {
+            return await cache.match(key);
+        }
+        catch {
+            // A cache that cannot be read is indistinguishable from one that
+            // never held the file: both mean it has to be downloaded.
+            return undefined;
+        }
+    }
+    async put(key, response) {
+        const cache = await this.open();
+        if (!cache) {
+            this.announce(new ModelFileCacheUnavailableError('Cache Storage is not exposed in this context'));
+            return;
+        }
+        try {
+            await cache.put(key, response);
+        }
+        catch (error) {
+            this.announce(error);
+        }
+    }
+    announce(error) {
+        if (this.failureAnnounced)
+            return;
+        this.failureAnnounced = true;
+        this.onKeepFailure(error);
+    }
+    /**
+     * Resolves to `null` when this runtime has no Cache Storage at all,
+     * which is a standing condition rather than a transient one — hence
+     * the single attempt, reused by every later call.
+     */
+    open() {
+        this.opening ??= this.openOnce();
+        return this.opening;
+    }
+    async openOnce() {
+        if (typeof caches === 'undefined')
+            return null;
+        try {
+            return await caches.open(CacheStorageModelFileCache.CACHE_NAME);
+        }
+        catch {
+            // Opening is refused outright in some privacy modes. There is
+            // nothing to fall back to, and `put` reports the consequence.
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=CacheStorageModelFileCache.js.map

package/dist/modules/transcription/CacheStorageModelFileCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheStorageModelFileCache.js","sourceRoot":"","sources":["../../../src/modules/transcription/CacheStorageModelFileCache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,8BAA8B,EAAE,MAAM,uDAAuD,CAAC;AAEvG;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,0BAA0B;IAcR;IAZ7B,mEAAmE;IACnE,qEAAqE;IACrE,iCAAiC;IACzB,MAAM,CAAU,UAAU,GAAG,oBAAoB,CAAC;IAElD,OAAO,GAAiC,IAAI,CAAC;IAC7C,gBAAgB,GAAG,KAAK,CAAC;IAEjC;;;OAGG;IACH,YAA6B,aAAuC;QAAvC,kBAAa,GAAb,aAAa,CAA0B;IAAG,CAAC;IAExE,KAAK,CAAC,KAAK,CAAC,GAAW;QACrB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;QAChC,IAAI,CAAC,KAAK;YAAE,OAAO,SAAS,CAAC;QAC7B,IAAI,CAAC;YACH,OAAO,MAAM,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAChC,CAAC;QAAC,MAAM,CAAC;YACP,iEAAiE;YACjE,0DAA0D;YAC1D,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,GAAW,EAAE,QAAkB;QACvC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;QAChC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,IAAI,CAAC,QAAQ,CAAC,IAAI,8BAA8B,CAAC,8CAA8C,CAAC,CAAC,CAAC;YAClG,OAAO;QACT,CAAC;QACD,IAAI,CAAC;YACH,MAAM,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACjC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IAEO,QAAQ,CAAC,KAAc;QAC7B,IAAI,IAAI,CAAC,gBAAgB;YAAE,OAAO;QAClC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAED;;;;OAIG;IACK,IAAI;QACV,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC,QAAQ,EAAE,CAAC;QACjC,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAEO,KAAK,CAAC,QAAQ;QACpB,IAAI,OAAO,MAAM,KAAK,WAAW;YAAE,OAAO,IAAI,CAAC;QAC/C,IAAI,CAAC;YACH,OAAO,MAAM,MAAM,CAAC,IAAI,CAAC,0BAA0B,CAAC,UAAU,CAAC,CAAC;QAClE,CAAC;QAAC,MAAM,CAAC;YACP,8DAA8D;YAC9D,8DAA8D;YAC9D,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC"}

package/dist/modules/transcription/CueDocumentBuilder.d.ts

@@ -0,0 +1,40 @@
+import type { CueParseResult } from '../transcription/CueParseResult';
+import type { CueTimecodeReader } from '../transcription/CueTimecodeReader';
+import type { CueWordReader } from '../transcription/CueWordReader';
+/**
+ * Builds a Document from the cue blocks of a caption file: blank lines
+ * separate cues, a `-->` line states the range, and everything below it
+ * is the text. Each cue becomes one Segment holding one Line.
+ *
+ * A counter or identifier above the range line is ignored, since
+ * neither says anything the Document keeps. A cue whose text is empty
+ * is dropped. How the text becomes timed words is the reader's business
+ * and the only thing that differs between formats.
+ *
+ * A block carrying no range line is skipped and handed back in the
+ * result rather than ending the read. This is what the WebVTT parser
+ * algorithm prescribes, and it is the only behaviour that serves
+ * someone holding a file they did not write: one stray blank line
+ * inside a cue, or one paragraph of prose at the end, would otherwise
+ * cost them every cue in the file. Deciding whether the remainder is
+ * worth using belongs to the caller, which is why the count of what
+ * was lost travels with it.
+ *
+ * A file where every block was skipped is refused outright: what is
+ * left is not a thin transcript, it is no transcript, and returning
+ * one would say the file was silent rather than unreadable. A file
+ * with no blocks at all is not refused — there is nothing in it to
+ * misread.
+ *
+ * A malformed *timecode* still throws. That block announced its
+ * intent to state a time and got it wrong, so placing its text
+ * anywhere would be a guess.
+ */
+export declare class CueDocumentBuilder {
+    private readonly timecodeReader;
+    constructor(timecodeReader: CueTimecodeReader);
+    build(source: string, wordReader: CueWordReader): CueParseResult;
+    private splitIntoBlocks;
+    private buildSegment;
+}
+//# sourceMappingURL=CueDocumentBuilder.d.ts.map

package/dist/modules/transcription/CueDocumentBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CueDocumentBuilder.d.ts","sourceRoot":"","sources":["../../../src/modules/transcription/CueDocumentBuilder.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAC;AAClF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAK1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,kBAAkB;IACjB,OAAO,CAAC,QAAQ,CAAC,cAAc;gBAAd,cAAc,EAAE,iBAAiB;IAE9D,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,GAAG,cAAc;IAgBhE,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,YAAY;CAkBrB"}

package/dist/modules/transcription/CueDocumentBuilder.js

@@ -0,0 +1,77 @@
+import { Document } from '../document/Document';
+import { Line } from '../document/Line';
+import { Section } from '../document/Section';
+import { Segment } from '../document/Segment';
+import { SubtitleFileUnreadableError } from '../transcription/SubtitleFileUnreadableError';
+const BOM_RE = /^\uFEFF/;
+/**
+ * Builds a Document from the cue blocks of a caption file: blank lines
+ * separate cues, a `-->` line states the range, and everything below it
+ * is the text. Each cue becomes one Segment holding one Line.
+ *
+ * A counter or identifier above the range line is ignored, since
+ * neither says anything the Document keeps. A cue whose text is empty
+ * is dropped. How the text becomes timed words is the reader's business
+ * and the only thing that differs between formats.
+ *
+ * A block carrying no range line is skipped and handed back in the
+ * result rather than ending the read. This is what the WebVTT parser
+ * algorithm prescribes, and it is the only behaviour that serves
+ * someone holding a file they did not write: one stray blank line
+ * inside a cue, or one paragraph of prose at the end, would otherwise
+ * cost them every cue in the file. Deciding whether the remainder is
+ * worth using belongs to the caller, which is why the count of what
+ * was lost travels with it.
+ *
+ * A file where every block was skipped is refused outright: what is
+ * left is not a thin transcript, it is no transcript, and returning
+ * one would say the file was silent rather than unreadable. A file
+ * with no blocks at all is not refused — there is nothing in it to
+ * misread.
+ *
+ * A malformed *timecode* still throws. That block announced its
+ * intent to state a time and got it wrong, so placing its text
+ * anywhere would be a guess.
+ */
+export class CueDocumentBuilder {
+    timecodeReader;
+    constructor(timecodeReader) {
+        this.timecodeReader = timecodeReader;
+    }
+    build(source, wordReader) {
+        const skippedBlocks = [];
+        const segments = this.splitIntoBlocks(source)
+            .map((block) => this.buildSegment(block, wordReader, skippedBlocks))
+            .filter((segment) => segment !== null);
+        if (segments.length === 0 && skippedBlocks.length > 0) {
+            throw new SubtitleFileUnreadableError(`None of the ${skippedBlocks.length} block(s) in the file carried a timecode line`);
+        }
+        return {
+            document: new Document({ sections: [new Section({ segments, kind: '' })] }),
+            skippedBlocks,
+        };
+    }
+    splitIntoBlocks(source) {
+        const normalized = source.replace(BOM_RE, '').replace(/\r\n?/g, '\n').trim();
+        if (normalized.length === 0)
+            return [];
+        return normalized.split(/\n{2,}/);
+    }
+    buildSegment(block, wordReader, skippedBlocks) {
+        const lines = block.split('\n').map((line) => line.trim()).filter((line) => line.length > 0);
+        if (lines.length === 0)
+            return null;
+        const rangeAt = lines.findIndex((line) => this.timecodeReader.isRangeLine(line));
+        if (rangeAt === -1) {
+            skippedBlocks.push(block);
+            return null;
+        }
+        const range = this.timecodeReader.readRange(lines[rangeAt]);
+        const text = lines.slice(rangeAt + 1).join(' ');
+        const words = wordReader.read(text, range.startSeconds, range.endSeconds);
+        if (words.length === 0)
+            return null;
+        return new Segment({ lines: [new Line({ words })] });
+    }
+}
+//# sourceMappingURL=CueDocumentBuilder.js.map

package/dist/modules/transcription/CueDocumentBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CueDocumentBuilder.js","sourceRoot":"","sources":["../../../src/modules/transcription/CueDocumentBuilder.ts"],"names":[],"mappings":"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"}

package/dist/modules/transcription/CueParseResult.d.ts

@@ -0,0 +1,16 @@
+import type { Document } from '../document/Document';
+/**
+ * What reading a caption file produced: the cues that could be read,
+ * and the blocks that could not.
+ *
+ * The two travel together because a caption file is rarely all right
+ * or all wrong. A reader that returned only the document would leave
+ * its caller unable to tell a file that was fully understood from one
+ * that was mostly understood.
+ */
+export interface CueParseResult {
+    readonly document: Document;
+    /** Verbatim text of every block that carried no timecode. */
+    readonly skippedBlocks: readonly string[];
+}
+//# sourceMappingURL=CueParseResult.d.ts.map

package/dist/modules/transcription/CueParseResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CueParseResult.d.ts","sourceRoot":"","sources":["../../../src/modules/transcription/CueParseResult.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAE3D;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAE5B,6DAA6D;IAC7D,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3C"}

package/dist/modules/transcription/CueParseResult.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=CueParseResult.js.map

package/dist/modules/transcription/CueParseResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CueParseResult.js","sourceRoot":"","sources":["../../../src/modules/transcription/CueParseResult.ts"],"names":[],"mappings":""}

package/dist/modules/transcription/CueTextTokenizer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Reduces the text of one cue to the words it says.
+ *
+ * Markup is dropped, runs of whitespace collapse, and a cue that turns
+ * out to hold nothing but markup yields no words at all.
+ */
+export declare class CueTextTokenizer {
+    tokenize(text: string): ReadonlyArray<string>;
+}
+//# sourceMappingURL=CueTextTokenizer.d.ts.map

package/dist/modules/transcription/CueTextTokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CueTextTokenizer.d.ts","sourceRoot":"","sources":["../../../src/modules/transcription/CueTextTokenizer.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,qBAAa,gBAAgB;IAE3B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC,MAAM,CAAC;CAM9C"}

package/dist/modules/transcription/CueTextTokenizer.js

@@ -0,0 +1,21 @@
+/**
+ * Markup a caption file may wrap its text in: WebVTT's angle-bracket
+ * tags and the brace-delimited overrides SubRip files sometimes carry
+ * from SubStation. None of it survives into a word.
+ */
+const MARKUP = /<[^>]+>|\{[^}]+\}/g;
+/**
+ * Reduces the text of one cue to the words it says.
+ *
+ * Markup is dropped, runs of whitespace collapse, and a cue that turns
+ * out to hold nothing but markup yields no words at all.
+ */
+export class CueTextTokenizer {
+    tokenize(text) {
+        return text
+            .replace(MARKUP, '')
+            .split(/\s+/)
+            .filter((token) => token.length > 0);
+    }
+}
+//# sourceMappingURL=CueTextTokenizer.js.map

package/dist/modules/transcription/CueTextTokenizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CueTextTokenizer.js","sourceRoot":"","sources":["../../../src/modules/transcription/CueTextTokenizer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,GAAG,oBAAoB,CAAC;AAEpC;;;;;GAKG;AACH,MAAM,OAAO,gBAAgB;IAE3B,QAAQ,CAAC,IAAY;QACnB,OAAO,IAAI;aACR,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;aACnB,KAAK,CAAC,KAAK,CAAC;aACZ,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACzC,CAAC;CACF"}

package/dist/modules/transcription/CueTimecodeReader.d.ts

@@ -0,0 +1,19 @@
+/** Half-open range a cue occupies, in seconds. */
+export interface CueTimeRange {
+    readonly startSeconds: number;
+    readonly endSeconds: number;
+}
+/**
+ * Reads the timecodes a caption file states its timings with.
+ *
+ * Positions are returned in seconds. A malformed timecode throws rather
+ * than resolving to zero, so a file that cannot be trusted is refused
+ * instead of silently landing every caption at the start.
+ */
+export declare class CueTimecodeReader {
+    isRangeLine(line: string): boolean;
+    readRange(line: string): CueTimeRange;
+    readPosition(timecode: string): number;
+    private toSeconds;
+}
+//# sourceMappingURL=CueTimecodeReader.d.ts.map

package/dist/modules/transcription/CueTimecodeReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CueTimecodeReader.d.ts","sourceRoot":"","sources":["../../../src/modules/transcription/CueTimecodeReader.ts"],"names":[],"mappings":"AAAA,kDAAkD;AAClD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAYD;;;;;;GAMG;AACH,qBAAa,iBAAiB;IAE5B,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIlC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY;IAWrC,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAMtC,OAAO,CAAC,SAAS;CAalB"}

package/dist/modules/transcription/CueTimecodeReader.js

@@ -0,0 +1,45 @@
+/**
+ * A position written `HH:MM:SS,mmm` or `HH:MM:SS.mmm`. SubRip settled
+ * on the comma and WebVTT on the dot, and both are accepted either way
+ * because files in the wild mix them. WebVTT also allows the hour to be
+ * left out, so it is optional.
+ */
+const POSITION = String.raw `(?:(\d{1,3}):)?(\d{2}):(\d{2})[,.](\d{1,3})`;
+const RANGE_LINE = new RegExp(`^${POSITION}\\s*-->\\s*${POSITION}`);
+const POSITION_ONLY = new RegExp(`^${POSITION}$`);
+/**
+ * Reads the timecodes a caption file states its timings with.
+ *
+ * Positions are returned in seconds. A malformed timecode throws rather
+ * than resolving to zero, so a file that cannot be trusted is refused
+ * instead of silently landing every caption at the start.
+ */
+export class CueTimecodeReader {
+    isRangeLine(line) {
+        return RANGE_LINE.test(line);
+    }
+    readRange(line) {
+        const match = RANGE_LINE.exec(line);
+        if (match === null)
+            throw new Error(`Malformed cue timecode: ${JSON.stringify(line)}`);
+        const startSeconds = this.toSeconds(match[1], match[2], match[3], match[4]);
+        const endSeconds = this.toSeconds(match[5], match[6], match[7], match[8]);
+        if (endSeconds < startSeconds) {
+            throw new Error(`Cue timecode ends before it starts: ${JSON.stringify(line)}`);
+        }
+        return { startSeconds, endSeconds };
+    }
+    readPosition(timecode) {
+        const match = POSITION_ONLY.exec(timecode);
+        if (match === null)
+            throw new Error(`Malformed timecode: ${JSON.stringify(timecode)}`);
+        return this.toSeconds(match[1], match[2], match[3], match[4]);
+    }
+    toSeconds(hours, minutes, seconds, milliseconds) {
+        return (Number(hours ?? 0) * 3600 +
+            Number(minutes) * 60 +
+            Number(seconds) +
+            Number(milliseconds.padEnd(3, '0')) / 1000);
+    }
+}
+//# sourceMappingURL=CueTimecodeReader.js.map

package/dist/modules/transcription/CueTimecodeReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CueTimecodeReader.js","sourceRoot":"","sources":["../../../src/modules/transcription/CueTimecodeReader.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAA,6CAA6C,CAAC;AACzE,MAAM,UAAU,GAAG,IAAI,MAAM,CAAC,IAAI,QAAQ,cAAc,QAAQ,EAAE,CAAC,CAAC;AACpE,MAAM,aAAa,GAAG,IAAI,MAAM,CAAC,IAAI,QAAQ,GAAG,CAAC,CAAC;AAElD;;;;;;GAMG;AACH,MAAM,OAAO,iBAAiB;IAE5B,WAAW,CAAC,IAAY;QACtB,OAAO,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED,SAAS,CAAC,IAAY;QACpB,MAAM,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,KAAK,KAAK,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,2BAA2B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACvF,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC,CAAE,CAAC,CAAC;QAC/E,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC,CAAE,CAAC,CAAC;QAC7E,IAAI,UAAU,GAAG,YAAY,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,uCAAuC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACjF,CAAC;QACD,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,CAAC;IACtC,CAAC;IAED,YAAY,CAAC,QAAgB;QAC3B,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC3C,IAAI,KAAK,KAAK,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QACvF,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC,CAAE,CAAC,CAAC;IACnE,CAAC;IAEO,SAAS,CACf,KAAyB,EACzB,OAAe,EACf,OAAe,EACf,YAAoB;QAEpB,OAAO,CACL,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,IAAI;YACzB,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE;YACpB,MAAM,CAAC,OAAO,CAAC;YACf,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,IAAI,CAC3C,CAAC;IACJ,CAAC;CACF"}

package/dist/modules/transcription/CueWordReader.d.ts

@@ -0,0 +1,12 @@
+import type { Word } from '../document/Word';
+/**
+ * Turns the text of one cue into the words it holds, timed.
+ *
+ * Implementations differ in how much the file told them: some formats
+ * time nothing below the cue and leave the words to be guessed at,
+ * others mark when each word is spoken and can be taken at their word.
+ */
+export interface CueWordReader {
+    read(text: string, startSeconds: number, endSeconds: number): ReadonlyArray<Word>;
+}
+//# sourceMappingURL=CueWordReader.d.ts.map

package/dist/modules/transcription/CueWordReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CueWordReader.d.ts","sourceRoot":"","sources":["../../../src/modules/transcription/CueWordReader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAEnD;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;CACnF"}

package/dist/modules/transcription/CueWordReader.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=CueWordReader.js.map

package/dist/modules/transcription/CueWordReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CueWordReader.js","sourceRoot":"","sources":["../../../src/modules/transcription/CueWordReader.ts"],"names":[],"mappings":""}

package/dist/modules/transcription/EstimatedCueWordReader.d.ts

@@ -0,0 +1,16 @@
+import type { Word } from '../document/Word';
+import type { CueTextTokenizer } from '../transcription/CueTextTokenizer';
+import type { CueWordReader } from '../transcription/CueWordReader';
+import type { WordTimingEstimator } from '../transcription/WordTimingEstimator';
+/**
+ * Reads a cue from a format that times nothing below the cue itself.
+ * The words are known, when each is spoken is not, so the cue's own
+ * window is shared out among them.
+ */
+export declare class EstimatedCueWordReader implements CueWordReader {
+    private readonly tokenizer;
+    private readonly estimator;
+    constructor(tokenizer: CueTextTokenizer, estimator: WordTimingEstimator);
+    read(text: string, startSeconds: number, endSeconds: number): ReadonlyArray<Word>;
+}
+//# sourceMappingURL=EstimatedCueWordReader.d.ts.map

package/dist/modules/transcription/EstimatedCueWordReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EstimatedCueWordReader.d.ts","sourceRoot":"","sources":["../../../src/modules/transcription/EstimatedCueWordReader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAEtF;;;;GAIG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAExD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;gBADT,SAAS,EAAE,gBAAgB,EAC3B,SAAS,EAAE,mBAAmB;IAGjD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC;CAGlF"}

package/dist/modules/transcription/EstimatedCueWordReader.js

@@ -0,0 +1,17 @@
+/**
+ * Reads a cue from a format that times nothing below the cue itself.
+ * The words are known, when each is spoken is not, so the cue's own
+ * window is shared out among them.
+ */
+export class EstimatedCueWordReader {
+    tokenizer;
+    estimator;
+    constructor(tokenizer, estimator) {
+        this.tokenizer = tokenizer;
+        this.estimator = estimator;
+    }
+    read(text, startSeconds, endSeconds) {
+        return this.estimator.spread(this.tokenizer.tokenize(text), startSeconds, endSeconds);
+    }
+}
+//# sourceMappingURL=EstimatedCueWordReader.js.map

package/dist/modules/transcription/EstimatedCueWordReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EstimatedCueWordReader.js","sourceRoot":"","sources":["../../../src/modules/transcription/EstimatedCueWordReader.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,MAAM,OAAO,sBAAsB;IAEd;IACA;IAFnB,YACmB,SAA2B,EAC3B,SAA8B;QAD9B,cAAS,GAAT,SAAS,CAAkB;QAC3B,cAAS,GAAT,SAAS,CAAqB;IAC9C,CAAC;IAEJ,IAAI,CAAC,IAAY,EAAE,YAAoB,EAAE,UAAkB;QACzD,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;IACxF,CAAC;CACF"}

package/dist/modules/transcription/LogitsProcessorListFactory.d.ts

@@ -0,0 +1,43 @@
+import type * as Transformers from '@huggingface/transformers';
+import type { LogitsProcessorList } from '@huggingface/transformers';
+import type { WhisperLoopAbortLogitsProcessor } from '../transcription/WhisperLoopAbortLogitsProcessor';
+/**
+ * Builds the logits-processor list a generation is handed, out of the
+ * inference library's base classes.
+ *
+ * The two subclasses below are defined here, against a module passed in,
+ * rather than at the top of their own files against a static import.
+ * `extends` runs when a module loads, so a subclass of a library class
+ * makes that library a load-time dependency of every file that can reach
+ * it — which is the whole package, through its entry point. Everything
+ * that does not need the base class stays outside: the loop guard holds
+ * its own detection and this only dresses it.
+ *
+ * Both classes are built once and reused. They close over nothing per
+ * call, and rebuilding them would give the pipeline a different
+ * `constructor` identity each time, which is exactly what the list's
+ * replacement rule compares.
+ */
+export declare class LogitsProcessorListFactory {
+    private readonly module;
+    private listClass;
+    private guardClass;
+    constructor(module: typeof Transformers);
+    /** A list holding `guard`, ready to be passed as `logits_processor`. */
+    build(guard: WhisperLoopAbortLogitsProcessor): LogitsProcessorList;
+    /**
+     * A processor list whose `push` replaces any already-held processor of
+     * the same class instead of appending a duplicate.
+     *
+     * The ASR pipeline reuses one options object across every window of a
+     * long transcription, and Whisper's `generate` pushes a fresh set of
+     * internal processors into the provided list on every call. On a plain
+     * list those pile up — window N would run N copies of each internal
+     * processor. Replacement reproduces the fresh-list semantics the
+     * library assumes: the newest instance wins.
+     */
+    private replacingList;
+    /** Presents the loop guard as the processor shape the pipeline calls. */
+    private guardAdapter;
+}
+//# sourceMappingURL=LogitsProcessorListFactory.d.ts.map

package/dist/modules/transcription/LogitsProcessorListFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogitsProcessorListFactory.d.ts","sourceRoot":"","sources":["../../../src/modules/transcription/LogitsProcessorListFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,YAAY,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAmB,mBAAmB,EAAU,MAAM,2BAA2B,CAAC;AAC9F,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,wDAAwD,CAAC;AAE9G;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,0BAA0B;IAIzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAHnC,OAAO,CAAC,SAAS,CAAgD;IACjE,OAAO,CAAC,UAAU,CAAkF;gBAEvE,MAAM,EAAE,OAAO,YAAY;IAExD,wEAAwE;IACxE,KAAK,CAAC,KAAK,EAAE,+BAA+B,GAAG,mBAAmB;IAMlE;;;;;;;;;;OAUG;IACH,OAAO,CAAC,aAAa;IAerB,yEAAyE;IACzE,OAAO,CAAC,YAAY;CAcrB"}

package/dist/modules/transcription/LogitsProcessorListFactory.js

@@ -0,0 +1,72 @@
+/**
+ * Builds the logits-processor list a generation is handed, out of the
+ * inference library's base classes.
+ *
+ * The two subclasses below are defined here, against a module passed in,
+ * rather than at the top of their own files against a static import.
+ * `extends` runs when a module loads, so a subclass of a library class
+ * makes that library a load-time dependency of every file that can reach
+ * it — which is the whole package, through its entry point. Everything
+ * that does not need the base class stays outside: the loop guard holds
+ * its own detection and this only dresses it.
+ *
+ * Both classes are built once and reused. They close over nothing per
+ * call, and rebuilding them would give the pipeline a different
+ * `constructor` identity each time, which is exactly what the list's
+ * replacement rule compares.
+ */
+export class LogitsProcessorListFactory {
+    module;
+    listClass = null;
+    guardClass = null;
+    constructor(module) {
+        this.module = module;
+    }
+    /** A list holding `guard`, ready to be passed as `logits_processor`. */
+    build(guard) {
+        const list = new (this.replacingList())();
+        list.push(new (this.guardAdapter())(guard));
+        return list;
+    }
+    /**
+     * A processor list whose `push` replaces any already-held processor of
+     * the same class instead of appending a duplicate.
+     *
+     * The ASR pipeline reuses one options object across every window of a
+     * long transcription, and Whisper's `generate` pushes a fresh set of
+     * internal processors into the provided list on every call. On a plain
+     * list those pile up — window N would run N copies of each internal
+     * processor. Replacement reproduces the fresh-list semantics the
+     * library assumes: the newest instance wins.
+     */
+    replacingList() {
+        if (this.listClass === null) {
+            this.listClass = class extends this.module.LogitsProcessorList {
+                push(item) {
+                    const existing = this.processors.findIndex((held) => held.constructor === item.constructor);
+                    if (existing >= 0)
+                        this.processors.splice(existing, 1);
+                    super.push(item);
+                }
+            };
+        }
+        return this.listClass;
+    }
+    /** Presents the loop guard as the processor shape the pipeline calls. */
+    guardAdapter() {
+        if (this.guardClass === null) {
+            this.guardClass = class extends this.module.LogitsProcessor {
+                guard;
+                constructor(guard) {
+                    super();
+                    this.guard = guard;
+                }
+                _call(inputIds, logits) {
+                    return this.guard.apply(inputIds, logits);
+                }
+            };
+        }
+        return this.guardClass;
+    }
+}
+//# sourceMappingURL=LogitsProcessorListFactory.js.map

package/dist/modules/transcription/LogitsProcessorListFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogitsProcessorListFactory.js","sourceRoot":"","sources":["../../../src/modules/transcription/LogitsProcessorListFactory.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,0BAA0B;IAIR;IAHrB,SAAS,GAA2C,IAAI,CAAC;IACzD,UAAU,GAA6E,IAAI,CAAC;IAEpG,YAA6B,MAA2B;QAA3B,WAAM,GAAN,MAAM,CAAqB;IAAG,CAAC;IAE5D,wEAAwE;IACxE,KAAK,CAAC,KAAsC;QAC1C,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,EAAE,CAAC;QAC1C,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;OAUG;IACK,aAAa;QACnB,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,EAAE,CAAC;YAC5B,IAAI,CAAC,SAAS,GAAG,KAAM,SAAQ,IAAI,CAAC,MAAM,CAAC,mBAAmB;gBACnD,IAAI,CAAC,IAAqB;oBACjC,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CACxC,CAAC,IAAqB,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC,WAAW,CACjE,CAAC;oBACF,IAAI,QAAQ,IAAI,CAAC;wBAAE,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;oBACvD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACnB,CAAC;aACF,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,yEAAyE;IACjE,YAAY;QAClB,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;YAC7B,IAAI,CAAC,UAAU,GAAG,KAAM,SAAQ,IAAI,CAAC,MAAM,CAAC,eAAe;gBAC5B;gBAA7B,YAA6B,KAAsC;oBACjE,KAAK,EAAE,CAAC;oBADmB,UAAK,GAAL,KAAK,CAAiC;gBAEnE,CAAC;gBAED,KAAK,CAAC,QAAoB,EAAE,MAAc;oBACxC,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;gBAC5C,CAAC;aACF,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;CACF"}

package/dist/modules/transcription/MediaBunnyAudioDecoder.d.ts

@@ -0,0 +1,27 @@
+import type { AudioDecoder } from '../transcription/AudioDecoder';
+/**
+ * Decodes an audio/video Blob to mono `Float32Array` PCM at the
+ * requested sample rate by demuxing the container with mediabunny and
+ * iterating the primary audio track through {@link AudioSampleSink}.
+ * Downmixes and resamples in fixed-size batches via
+ * {@link BatchedMonoResampler} so peak memory is bounded by one batch
+ * of source-rate audio plus the pre-sized target buffer, not by the
+ * whole track — a long video no longer holds ~4× its useful PCM size
+ * in transient buffers on the way to the worker.
+ *
+ * Main-thread only — `OfflineAudioContext` is not available inside
+ * Worker contexts.
+ *
+ * A codec the current browser cannot decode surfaces as a
+ * `DOMException` named `NotSupportedError`, following the WebCodecs
+ * convention. Any other underlying mediabunny / WebCodecs failure is
+ * re-thrown verbatim so callers can inspect its `name` / `cause` to
+ * classify the reason.
+ */
+export declare class MediaBunnyAudioDecoder implements AudioDecoder {
+    decode(audio: Blob, targetSampleRate: number, onProgress?: (progress: number) => void): Promise<Float32Array>;
+    private decodeInput;
+    private streamMonoInto;
+    private progressAt;
+}
+//# sourceMappingURL=MediaBunnyAudioDecoder.d.ts.map

package/dist/modules/transcription/MediaBunnyAudioDecoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MediaBunnyAudioDecoder.d.ts","sourceRoot":"","sources":["../../../src/modules/transcription/MediaBunnyAudioDecoder.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAGxE;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,sBAAuB,YAAW,YAAY;IACnD,MAAM,CACV,KAAK,EAAE,IAAI,EACX,gBAAgB,EAAE,MAAM,EACxB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GACtC,OAAO,CAAC,YAAY,CAAC;YASV,WAAW;YAuBX,cAAc;IAmB5B,OAAO,CAAC,UAAU;CAQnB"}