@storyteller-platform/align 0.0.1

package/dist/align/getSentenceRanges.js

@@ -0,0 +1,277 @@
+import "../chunk-BIEQXUOY.js";
+import { segmentText } from "@echogarden/text-segmentation";
+import { getTrackDuration } from "../common/ffmpeg.js";
+import { findNearestMatch } from "./fuzzy.js";
+async function getSentencesWithOffsets(text) {
+  const sentences = await segmentText(text).then(
+    (r) => r.sentences.map((s) => s.text)
+  );
+  const sentencesWithOffsets = [];
+  let lastSentenceEnd = 0;
+  for (const sentence of sentences) {
+    const sentenceStart = text.indexOf(sentence, lastSentenceEnd);
+    if (sentenceStart > lastSentenceEnd) {
+      sentencesWithOffsets.push(text.slice(lastSentenceEnd, sentenceStart));
+    }
+    sentencesWithOffsets.push(sentence);
+    lastSentenceEnd = sentenceStart + sentence.length;
+  }
+  if (text.length > lastSentenceEnd) {
+    sentencesWithOffsets.push(text.slice(lastSentenceEnd));
+  }
+  return sentencesWithOffsets;
+}
+function findStartTimestamp(matchStartIndex, transcription) {
+  const entry = transcription.timeline.find(
+    (entry2) => (entry2.endOffsetUtf16 ?? 0) > matchStartIndex
+  );
+  if (!entry) return null;
+  return {
+    start: entry.startTime,
+    end: entry.endTime,
+    audiofile: entry.audiofile
+  };
+}
+function findEndTimestamp(matchEndIndex, transcription) {
+  const entry = transcription.timeline.findLast(
+    (entry2) => (entry2.startOffsetUtf16 ?? 0) < matchEndIndex
+  );
+  return (entry == null ? void 0 : entry.endTime) ?? null;
+}
+function getWindowIndexFromOffset(window, offset) {
+  let index = 0;
+  while (index < window.length - 1 && offset >= window[index].length) {
+    offset -= window[index].length;
+    index += 1;
+  }
+  return { index, offset };
+}
+function collapseWhitespace(input) {
+  return input.replaceAll(/\s+/g, " ");
+}
+async function getSentenceRanges(startSentence, transcription, sentences, chapterOffset, lastSentenceRange) {
+  const sentenceRanges = [];
+  const fullTranscriptionText = transcription.transcript;
+  const transcriptionText = fullTranscriptionText.slice(chapterOffset);
+  const transcriptionSentences = await getSentencesWithOffsets(
+    transcriptionText
+  ).then((s) => s.map((sentence) => sentence.toLowerCase()));
+  let startSentenceEntry = startSentence;
+  const sentenceEntries = sentences.map((sentence, index) => [index, sentence]).filter(([index, sentence]) => {
+    if (sentence.replaceAll(/[.-_()[\],/?!@#$%^^&*`~;:='"<>+ˌˈ]/g, "").length <= 3) {
+      if (index < startSentence) startSentenceEntry--;
+      return false;
+    }
+    return true;
+  });
+  let transcriptionWindowIndex = 0;
+  let transcriptionWindowOffset = 0;
+  let lastGoodTranscriptionWindow = 0;
+  let notFound = 0;
+  let sentenceIndex = startSentenceEntry;
+  let lastMatchEnd = chapterOffset;
+  while (sentenceIndex < sentenceEntries.length) {
+    const [sentenceId, sentence] = sentenceEntries[sentenceIndex];
+    const transcriptionWindowList = transcriptionSentences.slice(
+      transcriptionWindowIndex,
+      transcriptionWindowIndex + 10
+    );
+    const transcriptionWindow = transcriptionWindowList.join("").slice(transcriptionWindowOffset);
+    const query = collapseWhitespace(sentence.trim()).toLowerCase();
+    const firstMatch = findNearestMatch(
+      query,
+      transcriptionWindow,
+      Math.max(Math.floor(0.25 * query.length), 1)
+    );
+    if (!firstMatch) {
+      sentenceIndex += 1;
+      notFound += 1;
+      if (notFound === 3 || sentenceIndex === sentenceEntries.length) {
+        transcriptionWindowIndex += 1;
+        if (transcriptionWindowIndex == lastGoodTranscriptionWindow + 30) {
+          transcriptionWindowIndex = lastGoodTranscriptionWindow;
+          notFound = 0;
+          continue;
+        }
+        sentenceIndex -= notFound;
+        notFound = 0;
+      }
+      continue;
+    }
+    const transcriptionOffset = transcriptionSentences.slice(0, transcriptionWindowIndex).join("").length;
+    const startResult = findStartTimestamp(
+      firstMatch.index + transcriptionOffset + transcriptionWindowOffset + chapterOffset,
+      transcription
+    );
+    if (!startResult) {
+      sentenceIndex += 1;
+      continue;
+    }
+    let start = startResult.start;
+    const audiofile = startResult.audiofile;
+    const end = findEndTimestamp(
+      firstMatch.index + firstMatch.match.length + transcriptionOffset + transcriptionWindowOffset + chapterOffset,
+      transcription
+    ) ?? startResult.end;
+    if (sentenceRanges.length > 0) {
+      const previousSentenceRange = sentenceRanges[sentenceRanges.length - 1];
+      const previousAudiofile = previousSentenceRange.audiofile;
+      if (audiofile === previousAudiofile) {
+        if (previousSentenceRange.id === sentenceId - 1) {
+          previousSentenceRange.end = start;
+        }
+      } else {
+        if (previousSentenceRange.id === sentenceId - 1) {
+          const lastTrackDuration = await getTrackDuration(previousAudiofile);
+          previousSentenceRange.end = lastTrackDuration;
+          start = 0;
+        }
+      }
+    } else if (lastSentenceRange !== null) {
+      if (audiofile === lastSentenceRange.audiofile) {
+        if (sentenceId === 0) {
+          lastSentenceRange.end = start;
+        }
+      } else {
+        const lastTrackDuration = await getTrackDuration(
+          lastSentenceRange.audiofile
+        );
+        lastSentenceRange.end = lastTrackDuration;
+        if (sentenceId === 0) {
+          start = 0;
+        }
+      }
+    } else if (sentenceId === 0) {
+      start = 0;
+    }
+    sentenceRanges.push({
+      id: sentenceId,
+      start,
+      end,
+      audiofile
+    });
+    notFound = 0;
+    lastMatchEnd = firstMatch.index + firstMatch.match.length + transcriptionOffset + transcriptionWindowOffset + chapterOffset;
+    const windowIndexResult = getWindowIndexFromOffset(
+      transcriptionWindowList,
+      firstMatch.index + firstMatch.match.length + transcriptionWindowOffset
+    );
+    transcriptionWindowIndex += windowIndexResult.index;
+    transcriptionWindowOffset = windowIndexResult.offset;
+    lastGoodTranscriptionWindow = transcriptionWindowIndex;
+    sentenceIndex += 1;
+  }
+  return {
+    sentenceRanges,
+    transcriptionOffset: lastMatchEnd
+  };
+}
+async function getLargestGap(trailing, leading) {
+  const leadingGap = leading.start;
+  const trailingGap = await getTrackDuration(trailing.audiofile) - trailing.end;
+  if (trailingGap > leadingGap) return [trailingGap, trailing.audiofile];
+  return [leadingGap, leading.audiofile];
+}
+async function interpolateSentenceRanges(sentenceRanges, lastSentenceRange) {
+  const interpolated = [];
+  const [first, ...rest] = sentenceRanges;
+  if (!first) return interpolated;
+  if (first.id !== 0) {
+    const count = first.id;
+    const crossesAudioBoundary = !lastSentenceRange || first.audiofile !== lastSentenceRange.audiofile;
+    let diff = crossesAudioBoundary ? first.start : first.start - lastSentenceRange.end;
+    if (!crossesAudioBoundary && diff <= 0) {
+      diff = 0.25;
+      lastSentenceRange.end = first.start - diff;
+    }
+    const interpolatedLength = diff / count;
+    const start = crossesAudioBoundary ? 0 : lastSentenceRange.end;
+    for (let i = 0; i < count; i++) {
+      interpolated.push({
+        id: i,
+        start: start + interpolatedLength * i,
+        end: start + interpolatedLength * (i + 1),
+        audiofile: first.audiofile
+      });
+    }
+    interpolated.push(first);
+  } else {
+    rest.unshift(first);
+  }
+  for (const sentenceRange of rest) {
+    if (interpolated.length === 0) {
+      interpolated.push(sentenceRange);
+      continue;
+    }
+    const lastSentenceRange2 = interpolated[interpolated.length - 1];
+    const count = sentenceRange.id - lastSentenceRange2.id - 1;
+    if (count === 0) {
+      interpolated.push(sentenceRange);
+      continue;
+    }
+    const crossesAudioBoundary = sentenceRange.audiofile !== lastSentenceRange2.audiofile;
+    let [diff, audiofile] = crossesAudioBoundary ? await getLargestGap(lastSentenceRange2, sentenceRange) : [sentenceRange.start - lastSentenceRange2.end, sentenceRange.audiofile];
+    if (diff <= 0) {
+      if (crossesAudioBoundary) {
+        const rangeLength = sentenceRange.end - sentenceRange.start;
+        diff = rangeLength < 0.5 ? rangeLength / 2 : 0.25;
+        sentenceRange.start = diff;
+      } else {
+        diff = 0.25;
+        lastSentenceRange2.end = sentenceRange.start - diff;
+      }
+    }
+    const interpolatedLength = diff / count;
+    const start = crossesAudioBoundary ? 0 : lastSentenceRange2.end;
+    for (let i = 0; i < count; i++) {
+      interpolated.push({
+        id: lastSentenceRange2.id + i + 1,
+        start: start + interpolatedLength * i,
+        end: start + interpolatedLength * (i + 1),
+        audiofile
+      });
+    }
+    interpolated.push(sentenceRange);
+  }
+  return interpolated;
+}
+function expandEmptySentenceRanges(sentenceRanges) {
+  const expandedRanges = [];
+  for (const sentenceRange of sentenceRanges) {
+    const previousSentenceRange = expandedRanges[expandedRanges.length - 1];
+    if (!previousSentenceRange) {
+      expandedRanges.push(sentenceRange);
+      continue;
+    }
+    const nudged = previousSentenceRange.end > sentenceRange.start && previousSentenceRange.audiofile === sentenceRange.audiofile ? { ...sentenceRange, start: previousSentenceRange.end } : sentenceRange;
+    const expanded = nudged.end <= nudged.start ? { ...nudged, end: nudged.start + 1e-3 } : nudged;
+    expandedRanges.push(expanded);
+  }
+  return expandedRanges;
+}
+function getChapterDuration(sentenceRanges) {
+  let i = 0;
+  let duration = 0;
+  let audiofile = null;
+  let start = 0;
+  let end = 0;
+  while (i < sentenceRanges.length) {
+    const sentenceRange = sentenceRanges[i];
+    if (sentenceRange.audiofile !== audiofile) {
+      duration += end - start;
+      start = sentenceRange.start;
+      audiofile = sentenceRange.audiofile;
+    }
+    end = sentenceRange.end;
+    i++;
+  }
+  duration += end - start;
+  return duration;
+}
+export {
+  expandEmptySentenceRanges,
+  findEndTimestamp,
+  getChapterDuration,
+  getSentenceRanges,
+  interpolateSentenceRanges
+};

package/dist/align/parse.cjs

@@ -0,0 +1,63 @@
+"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);
+var parse_exports = {};
+__export(parse_exports, {
+  alignCommand: () => alignCommand,
+  alignParser: () => alignParser
+});
+module.exports = __toCommonJS(parse_exports);
+var import_core = require("@optique/core");
+var import_valueparser = require("@optique/run/valueparser");
+var import_parse = require("../common/parse.cjs");
+const alignParser = (0, import_core.object)("Alignment", {
+  audiobook: (0, import_core.option)(
+    "--audiobook",
+    (0, import_valueparser.path)({ mustExist: true, type: "directory" })
+  ),
+  epub: (0, import_core.option)(
+    "--epub",
+    (0, import_valueparser.path)({ mustExist: true, type: "file", extensions: [".epub"] })
+  ),
+  reports: (0, import_core.optional)((0, import_core.option)("--reports", (0, import_valueparser.path)({ type: "directory" })))
+});
+const alignCommand = (0, import_core.command)(
+  "align",
+  (0, import_core.merge)(
+    (0, import_core.object)({
+      action: (0, import_core.constant)("align"),
+      transcriptions: (0, import_core.option)(
+        "--transcriptions",
+        (0, import_valueparser.path)({ mustExist: true, type: "directory" })
+      ),
+      output: (0, import_core.option)("--output", (0, import_valueparser.path)({ type: "file", extensions: [".epub"] }))
+    }),
+    alignParser,
+    import_parse.loggingParser,
+    import_parse.languageParser,
+    import_parse.granularityParser
+  ),
+  {
+    description: import_core.message`Run forced alignment to determine where each sentence|word is spoken in the audiobook and produce a new EPUB package with Media Overlays and embedded audio.`
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  alignCommand,
+  alignParser
+});

package/dist/align/parse.d.cts

@@ -0,0 +1,30 @@
+import * as _optique_core from '@optique/core';
+
+declare const alignParser: _optique_core.Parser<"sync", {
+    readonly audiobook: string;
+    readonly epub: string;
+    readonly reports: string | undefined;
+}, {
+    readonly audiobook: _optique_core.ValueParserResult<string> | undefined;
+    readonly epub: _optique_core.ValueParserResult<string> | undefined;
+    readonly reports: [_optique_core.ValueParserResult<string> | undefined] | undefined;
+}>;
+declare const alignCommand: _optique_core.Parser<"sync", {
+    readonly action: "align";
+    readonly transcriptions: string;
+    readonly output: string;
+} & {
+    readonly audiobook: string;
+    readonly epub: string;
+    readonly reports: string | undefined;
+} & {
+    readonly noProgress: boolean;
+    readonly logLevel: "silent" | "debug" | "info" | "warn" | "error";
+    readonly time: boolean;
+} & {
+    readonly language: Intl.Locale | undefined;
+} & {
+    readonly granularity: "word" | "sentence";
+}, ["matched", string] | ["parsing", Record<string | symbol, unknown>] | undefined>;
+
+export { alignCommand, alignParser };

package/dist/align/parse.d.ts

@@ -0,0 +1,30 @@
+import * as _optique_core from '@optique/core';
+
+declare const alignParser: _optique_core.Parser<"sync", {
+    readonly audiobook: string;
+    readonly epub: string;
+    readonly reports: string | undefined;
+}, {
+    readonly audiobook: _optique_core.ValueParserResult<string> | undefined;
+    readonly epub: _optique_core.ValueParserResult<string> | undefined;
+    readonly reports: [_optique_core.ValueParserResult<string> | undefined] | undefined;
+}>;
+declare const alignCommand: _optique_core.Parser<"sync", {
+    readonly action: "align";
+    readonly transcriptions: string;
+    readonly output: string;
+} & {
+    readonly audiobook: string;
+    readonly epub: string;
+    readonly reports: string | undefined;
+} & {
+    readonly noProgress: boolean;
+    readonly logLevel: "silent" | "debug" | "info" | "warn" | "error";
+    readonly time: boolean;
+} & {
+    readonly language: Intl.Locale | undefined;
+} & {
+    readonly granularity: "word" | "sentence";
+}, ["matched", string] | ["parsing", Record<string | symbol, unknown>] | undefined>;
+
+export { alignCommand, alignParser };

package/dist/align/parse.js

@@ -0,0 +1,51 @@
+import "../chunk-BIEQXUOY.js";
+import {
+  command,
+  constant,
+  merge,
+  message,
+  object,
+  option,
+  optional
+} from "@optique/core";
+import { path } from "@optique/run/valueparser";
+import {
+  granularityParser,
+  languageParser,
+  loggingParser
+} from "../common/parse.js";
+const alignParser = object("Alignment", {
+  audiobook: option(
+    "--audiobook",
+    path({ mustExist: true, type: "directory" })
+  ),
+  epub: option(
+    "--epub",
+    path({ mustExist: true, type: "file", extensions: [".epub"] })
+  ),
+  reports: optional(option("--reports", path({ type: "directory" })))
+});
+const alignCommand = command(
+  "align",
+  merge(
+    object({
+      action: constant("align"),
+      transcriptions: option(
+        "--transcriptions",
+        path({ mustExist: true, type: "directory" })
+      ),
+      output: option("--output", path({ type: "file", extensions: [".epub"] }))
+    }),
+    alignParser,
+    loggingParser,
+    languageParser,
+    granularityParser
+  ),
+  {
+    description: message`Run forced alignment to determine where each sentence|word is spoken in the audiobook and produce a new EPUB package with Media Overlays and embedded audio.`
+  }
+);
+export {
+  alignCommand,
+  alignParser
+};

package/dist/chunk-BIEQXUOY.js

@@ -0,0 +1,50 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+
+export {
+  __using,
+  __callDispose
+};