@storyteller-platform/align 0.1.56 → 0.1.58

package/dist/align/ctc/align.cjs

@@ -0,0 +1,189 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 __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();
+};
+var align_exports = {};
+__export(align_exports, {
+  ctcAlign: () => ctcAlign
+});
+module.exports = __toCommonJS(align_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_shared = require("@readium/shared");
+var import_yazl = require("yazl");
+var import_epub = require("@storyteller-platform/epub");
+var import_fs = require("@storyteller-platform/fs");
+var import_media_types = require("@storyteller-platform/media-types");
+var import_fs2 = require("../../emit/fs.cjs");
+var import_guidedNavigation = require("../../readium/guidedNavigation.cjs");
+var import_Aligner = require("./Aligner.cjs");
+async function ctcAlign(input, output, emissionsDir, audiobookDir, options) {
+  var _stack2 = [];
+  try {
+    const outFormat = options.outFormat ?? "epub";
+    const epubPath = outFormat === "epub" ? (0, import_fs.scratchPath)(
+      `storyteller-platform-align-${(0, import_node_crypto.randomUUID)()}`,
+      (0, import_node_path.basename)(output)
+    ) : input;
+    const stack = __using(_stack2, new DisposableStack());
+    stack.defer(() => {
+      if (outFormat === "epub") {
+        try {
+          (0, import_node_fs.rmSync)((0, import_node_path.dirname)(epubPath), { recursive: true, force: true });
+        } catch {
+        }
+      }
+    });
+    if (outFormat === "epub") {
+      await (0, import_promises.mkdir)((0, import_node_path.dirname)(epubPath), { recursive: true });
+      await (0, import_promises.copyFile)(input, epubPath);
+    }
+    const audiobookFiles = await (0, import_promises.readdir)(audiobookDir).then(
+      (filenames) => filenames.filter((f) => import_media_types.MediaType.fromPath(f)?.kind === "audio").toSorted().map((f) => (0, import_node_path.join)(audiobookDir, f))
+    );
+    const epub = __using(_stack2, await import_epub.Epub.from(epubPath));
+    const emissions = await import_fs2.EmissionsReader.from(emissionsDir);
+    const aligner = new import_Aligner.Aligner(
+      epub,
+      audiobookFiles,
+      emissions,
+      options.granularity,
+      options.textRef,
+      options.primaryLocale,
+      options.logger
+    );
+    const timing = await aligner.alignBook(options.onProgress);
+    if (outFormat === "epub") {
+      await epub.saveAndClose();
+      await (0, import_promises.mkdir)((0, import_node_path.dirname)(output), { recursive: true });
+      await (0, import_promises.copyFile)(epubPath, output);
+    } else {
+      var _stack = [];
+      try {
+        const guidedNavigationDocuments = await (0, import_guidedNavigation.generateGuidedNavigationDocuments)(epub);
+        const manifest = (0, import_guidedNavigation.generateGuidedNavigationManifest)(
+          new import_shared.LocalizedString(
+            await epub.getTitle() ?? (0, import_node_path.basename)(input, (0, import_node_path.extname)(input))
+          ),
+          guidedNavigationDocuments
+        );
+        const tmpArchivePath = (0, import_fs.scratchPath)(
+          `storyteller-platform-epub-${(0, import_node_crypto.randomUUID)()}`
+        );
+        const { promise, resolve } = Promise.withResolvers();
+        const zipfile = new import_yazl.ZipFile();
+        const writeStream = (0, import_node_fs.createWriteStream)(tmpArchivePath);
+        writeStream.on("close", () => {
+          resolve();
+        });
+        const stack2 = __using(_stack, new AsyncDisposableStack(), true);
+        stack2.defer(async () => {
+          writeStream.close();
+          await (0, import_promises.rm)(tmpArchivePath, { force: true });
+        });
+        zipfile.outputStream.pipe(writeStream);
+        zipfile.addBuffer(
+          Buffer.from(JSON.stringify(manifest.serialize())),
+          "manifest.json"
+        );
+        for (const doc of guidedNavigationDocuments) {
+          const selfLink = doc.links?.findWithRel("self");
+          if (!selfLink) continue;
+          zipfile.addBuffer(
+            Buffer.from(JSON.stringify(doc.serialize())),
+            selfLink.href
+          );
+        }
+        zipfile.end();
+        await promise;
+        await (0, import_promises.cp)(tmpArchivePath, output);
+        epub.discardAndClose();
+      } catch (_) {
+        var _error = _, _hasError = true;
+      } finally {
+        var _promise = __callDispose(_stack, _error, _hasError);
+        _promise && await _promise;
+      }
+    }
+    if (options.reportsPath) {
+      await (0, import_promises.mkdir)((0, import_node_path.dirname)(options.reportsPath), { recursive: true });
+      await (0, import_promises.writeFile)(
+        options.reportsPath,
+        JSON.stringify(aligner.report, null, 2),
+        {
+          encoding: "utf-8"
+        }
+      );
+    }
+    return timing;
+  } catch (_2) {
+    var _error2 = _2, _hasError2 = true;
+  } finally {
+    __callDispose(_stack2, _error2, _hasError2);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ctcAlign
+});

package/dist/align/ctc/align.d.cts

@@ -0,0 +1,14 @@
+import * as _storyteller_platform_ghost_story from '@storyteller-platform/ghost-story';
+import { AlignOptions } from './Aligner.cjs';
+import 'pino';
+import '@storyteller-platform/epub';
+import '../../emit/fs.cjs';
+import './emissions.cjs';
+import './report.cjs';
+import '../getSentenceRanges.cjs';
+import '@echogarden/text-segmentation';
+import '@storyteller-platform/mapping';
+
+declare function ctcAlign(input: string, output: string, emissionsDir: string, audiobookDir: string, options: AlignOptions): Promise<_storyteller_platform_ghost_story.TimingAggregator>;
+
+export { ctcAlign };

package/dist/align/ctc/align.d.ts

@@ -0,0 +1,14 @@
+import * as _storyteller_platform_ghost_story from '@storyteller-platform/ghost-story';
+import { AlignOptions } from './Aligner.js';
+import 'pino';
+import '@storyteller-platform/epub';
+import '../../emit/fs.js';
+import './emissions.js';
+import './report.js';
+import '../getSentenceRanges.js';
+import '@echogarden/text-segmentation';
+import '@storyteller-platform/mapping';
+
+declare function ctcAlign(input: string, output: string, emissionsDir: string, audiobookDir: string, options: AlignOptions): Promise<_storyteller_platform_ghost_story.TimingAggregator>;
+
+export { ctcAlign };

package/dist/align/ctc/align.js

@@ -0,0 +1,132 @@
+import {
+  __callDispose,
+  __using
+} from "../../chunk-BIEQXUOY.js";
+import { randomUUID } from "node:crypto";
+import { createWriteStream, rmSync } from "node:fs";
+import { copyFile, cp, mkdir, readdir, rm, writeFile } from "node:fs/promises";
+import {
+  basename as autoBasename,
+  dirname as autoDirname,
+  extname,
+  join as autoJoin
+} from "node:path";
+import { LocalizedString } from "@readium/shared";
+import { ZipFile } from "yazl";
+import { Epub } from "@storyteller-platform/epub";
+import { scratchPath } from "@storyteller-platform/fs";
+import { MediaType } from "@storyteller-platform/media-types";
+import { EmissionsReader } from "../../emit/fs.js";
+import {
+  generateGuidedNavigationDocuments,
+  generateGuidedNavigationManifest
+} from "../../readium/guidedNavigation.js";
+import { Aligner } from "./Aligner.js";
+async function ctcAlign(input, output, emissionsDir, audiobookDir, options) {
+  var _stack2 = [];
+  try {
+    const outFormat = options.outFormat ?? "epub";
+    const epubPath = outFormat === "epub" ? scratchPath(
+      `storyteller-platform-align-${randomUUID()}`,
+      autoBasename(output)
+    ) : input;
+    const stack = __using(_stack2, new DisposableStack());
+    stack.defer(() => {
+      if (outFormat === "epub") {
+        try {
+          rmSync(autoDirname(epubPath), { recursive: true, force: true });
+        } catch {
+        }
+      }
+    });
+    if (outFormat === "epub") {
+      await mkdir(autoDirname(epubPath), { recursive: true });
+      await copyFile(input, epubPath);
+    }
+    const audiobookFiles = await readdir(audiobookDir).then(
+      (filenames) => filenames.filter((f) => MediaType.fromPath(f)?.kind === "audio").toSorted().map((f) => autoJoin(audiobookDir, f))
+    );
+    const epub = __using(_stack2, await Epub.from(epubPath));
+    const emissions = await EmissionsReader.from(emissionsDir);
+    const aligner = new Aligner(
+      epub,
+      audiobookFiles,
+      emissions,
+      options.granularity,
+      options.textRef,
+      options.primaryLocale,
+      options.logger
+    );
+    const timing = await aligner.alignBook(options.onProgress);
+    if (outFormat === "epub") {
+      await epub.saveAndClose();
+      await mkdir(autoDirname(output), { recursive: true });
+      await copyFile(epubPath, output);
+    } else {
+      var _stack = [];
+      try {
+        const guidedNavigationDocuments = await generateGuidedNavigationDocuments(epub);
+        const manifest = generateGuidedNavigationManifest(
+          new LocalizedString(
+            await epub.getTitle() ?? autoBasename(input, extname(input))
+          ),
+          guidedNavigationDocuments
+        );
+        const tmpArchivePath = scratchPath(
+          `storyteller-platform-epub-${randomUUID()}`
+        );
+        const { promise, resolve } = Promise.withResolvers();
+        const zipfile = new ZipFile();
+        const writeStream = createWriteStream(tmpArchivePath);
+        writeStream.on("close", () => {
+          resolve();
+        });
+        const stack2 = __using(_stack, new AsyncDisposableStack(), true);
+        stack2.defer(async () => {
+          writeStream.close();
+          await rm(tmpArchivePath, { force: true });
+        });
+        zipfile.outputStream.pipe(writeStream);
+        zipfile.addBuffer(
+          Buffer.from(JSON.stringify(manifest.serialize())),
+          "manifest.json"
+        );
+        for (const doc of guidedNavigationDocuments) {
+          const selfLink = doc.links?.findWithRel("self");
+          if (!selfLink) continue;
+          zipfile.addBuffer(
+            Buffer.from(JSON.stringify(doc.serialize())),
+            selfLink.href
+          );
+        }
+        zipfile.end();
+        await promise;
+        await cp(tmpArchivePath, output);
+        epub.discardAndClose();
+      } catch (_) {
+        var _error = _, _hasError = true;
+      } finally {
+        var _promise = __callDispose(_stack, _error, _hasError);
+        _promise && await _promise;
+      }
+    }
+    if (options.reportsPath) {
+      await mkdir(autoDirname(options.reportsPath), { recursive: true });
+      await writeFile(
+        options.reportsPath,
+        JSON.stringify(aligner.report, null, 2),
+        {
+          encoding: "utf-8"
+        }
+      );
+    }
+    return timing;
+  } catch (_2) {
+    var _error2 = _2, _hasError2 = true;
+  } finally {
+    __callDispose(_stack2, _error2, _hasError2);
+  }
+}
+export {
+  ctcAlign
+};

package/dist/{process/mime.cjs → align/ctc/emissions.cjs}

@@ -16,28 +16,15 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var mime_exports = {};
-__export(mime_exports, {
-  areSameType: () => areSameType
+var emissions_exports = {};
+__export(emissions_exports, {
+  framesToSeconds: () => framesToSeconds
 });
-module.exports = __toCommonJS(mime_exports);
-var import_audiobook = require("@storyteller-platform/audiobook");
-function areSameType(filepathA, filepathB) {
-  if (filepathA === filepathB) {
-    return true;
-  }
-  if (import_audiobook.MPEG4_FILE_EXTENSIONS.some((ext) => filepathA.endsWith(ext)) && import_audiobook.MPEG4_FILE_EXTENSIONS.some((ext) => filepathB.endsWith(ext))) {
-    return true;
-  }
-  if (import_audiobook.MP3_FILE_EXTENSIONS.some((ext) => filepathA.endsWith(ext)) && import_audiobook.MP3_FILE_EXTENSIONS.some((ext) => filepathB.endsWith(ext))) {
-    return true;
-  }
-  if (import_audiobook.OPUS_FILE_EXTENSIONS.some((ext) => filepathA.endsWith(ext)) && import_audiobook.OPUS_FILE_EXTENSIONS.some((ext) => filepathB.endsWith(ext))) {
-    return true;
-  }
-  return false;
+module.exports = __toCommonJS(emissions_exports);
+function framesToSeconds(frames, emissionTimings) {
+  return Math.floor(frames / emissionTimings.framesPerChunk) * emissionTimings.secondsPerChunk + frames % emissionTimings.framesPerChunk * emissionTimings.secondsPerFrame;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  areSameType
+  framesToSeconds
 });

package/dist/align/ctc/emissions.d.cts

@@ -0,0 +1,6 @@
+import { EmissionResult } from '@storyteller-platform/ghost-story';
+
+type EmissionTimings = Pick<EmissionResult, "secondsPerChunk" | "secondsPerFrame" | "framesPerChunk">;
+declare function framesToSeconds(frames: number, emissionTimings: EmissionTimings): number;
+
+export { type EmissionTimings, framesToSeconds };

package/dist/align/ctc/emissions.d.ts

@@ -0,0 +1,6 @@
+import { EmissionResult } from '@storyteller-platform/ghost-story';
+
+type EmissionTimings = Pick<EmissionResult, "secondsPerChunk" | "secondsPerFrame" | "framesPerChunk">;
+declare function framesToSeconds(frames: number, emissionTimings: EmissionTimings): number;
+
+export { type EmissionTimings, framesToSeconds };

package/dist/align/ctc/emissions.js

@@ -0,0 +1,7 @@
+import "../../chunk-BIEQXUOY.js";
+function framesToSeconds(frames, emissionTimings) {
+  return Math.floor(frames / emissionTimings.framesPerChunk) * emissionTimings.secondsPerChunk + frames % emissionTimings.framesPerChunk * emissionTimings.secondsPerFrame;
+}
+export {
+  framesToSeconds
+};

package/dist/align/ctc/forcedAlign.cjs

@@ -0,0 +1,273 @@
+"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 forcedAlign_exports = {};
+__export(forcedAlign_exports, {
+  ctcForcedAlign: () => ctcForcedAlign,
+  ctcViterbiAlign: () => ctcViterbiAlign,
+  detectDroppedLabels: () => detectDroppedLabels
+});
+module.exports = __toCommonJS(forcedAlign_exports);
+var import_itertools = require("itertools");
+function buildStateGraph(labels, starId, blankId) {
+  const tokens = [blankId].concat(labels.flatMap((l) => [l, blankId]));
+  const skipLegal = tokens.map(
+    (t, i) => i >= 2 && (t !== tokens[i - 2] || t === starId)
+  );
+  return { tokens, skipLegal };
+}
+function ctcViterbiAlign(emissions, labels, blankId, starId, starScore) {
+  if (!labels.length) return [];
+  function emitScore(row, token) {
+    return token === starId ? starScore : row[token];
+  }
+  const { tokens, skipLegal } = buildStateGraph(labels, starId, blankId);
+  const numStates = tokens.length;
+  const numFrames = emissions.length;
+  if (!numFrames) return [];
+  let prevScores = new Float32Array(numStates).fill(-Infinity);
+  const backpointers = new Uint8Array(numFrames * numStates);
+  prevScores[0] = emissions[0][blankId];
+  prevScores[1] = emitScore(emissions[0], tokens[1]);
+  if (labels[0] === starId) {
+    prevScores[2] = emissions[0][blankId];
+    prevScores[3] = emitScore(emissions[0], tokens[3]);
+  }
+  for (let t = 1; t < numFrames; t++) {
+    const row = emissions[t];
+    const currScores = new Float32Array(numStates).fill(-Infinity);
+    for (let s = 0; s < numStates; s++) {
+      const token = tokens[s];
+      let best = prevScores[s];
+      let bestOp = 0;
+      if (s > 0) {
+        const move = prevScores[s - 1];
+        if (move > best) {
+          best = move;
+          bestOp = 1;
+        }
+      }
+      if (skipLegal[s]) {
+        const move = prevScores[s - 2];
+        if (move > best) {
+          best = move;
+          bestOp = 2;
+        }
+      }
+      currScores[s] = emitScore(row, token) + best;
+      backpointers[t * numStates + s] = bestOp;
+    }
+    prevScores = currScores;
+  }
+  const terminalCandidates = [
+    numStates - 1,
+    numStates - 2,
+    // Same as above, only allow skipping the last label
+    // if it's a star
+    ...labels.at(-1) === starId ? [numStates - 3, numStates - 4] : []
+  ].filter((s) => s >= 0);
+  let terminal = terminalCandidates[0];
+  for (const s of terminalCandidates) {
+    if (prevScores[s] > prevScores[terminal]) terminal = s;
+  }
+  if (prevScores[terminal] === -Infinity) {
+    return labels.map((label) => ({
+      label,
+      startFrame: -1,
+      endFrame: -1,
+      score: -Infinity
+    }));
+  }
+  const path = new Int32Array(numFrames);
+  path[numFrames - 1] = terminal;
+  for (let t = numFrames - 1; t > 0; t--) {
+    const s = path[t];
+    const op = backpointers[t * numStates + s];
+    path[t - 1] = s - op;
+  }
+  const firstFrames = new Int32Array(numStates).fill(-1);
+  const lastFrames = new Int32Array(numStates).fill(-1);
+  const scoreSums = new Float64Array(numStates);
+  const frameCounts = new Int32Array(numStates);
+  for (let t = 0; t < numFrames; t++) {
+    const s = path[t];
+    if (firstFrames[s] === -1) firstFrames[s] = t;
+    lastFrames[s] = t;
+    const row = emissions[t];
+    const token = tokens[s];
+    scoreSums[s] += emitScore(row, token);
+    frameCounts[s]++;
+  }
+  const alignments = [];
+  for (let l = 0; l < labels.length; l++) {
+    const state = 2 * l + 1;
+    const startFrame = firstFrames[state];
+    const endFrame = lastFrames[state];
+    const scoreSum = scoreSums[state];
+    const frameCount = frameCounts[state];
+    const meanScore = frameCount > 0 ? scoreSum / frameCount : -Infinity;
+    alignments.push({
+      label: labels[l],
+      startFrame,
+      endFrame,
+      score: meanScore
+    });
+  }
+  return alignments;
+}
+function detectDroppedLabels(alignments, startOffset, endOffset, minLength = 8) {
+  if (endOffset < startOffset || endOffset - startOffset <= minLength) {
+    return false;
+  }
+  const endFrame = alignments[endOffset]?.endFrame;
+  if (endFrame === void 0) {
+    throw new Error(`endOffset ${endOffset} out of bounds`);
+  }
+  const startFrame = alignments[startOffset]?.startFrame;
+  if (startFrame === void 0) {
+    throw new Error(`startOffset ${startOffset} out of bounds`);
+  }
+  const framesPerChar = (endFrame - startFrame) / (endOffset - startOffset);
+  return framesPerChar < 2;
+}
+function removeLabelRanges(input, removals) {
+  const inputIndices = [];
+  let nextRemovalIndex = 0;
+  const result = [];
+  let i = 0;
+  while (i < input.length) {
+    const l = input[i];
+    const nextRemoval = removals[nextRemovalIndex];
+    if (!nextRemoval) {
+      inputIndices.push(i);
+      result.push(l);
+      i++;
+      continue;
+    }
+    if (i >= nextRemoval[0] && i <= nextRemoval[1]) {
+      i++;
+      continue;
+    }
+    if (i > nextRemoval[1]) {
+      nextRemovalIndex++;
+      continue;
+    }
+    inputIndices.push(i);
+    result.push(l);
+    i++;
+  }
+  return { result, inputIndices };
+}
+const STAR_SCORE = -3;
+function ctcForcedAlign(baseline, emissions, anchors, vocab, blankId, dropLabels = () => []) {
+  const star = vocab.size;
+  const segments = [];
+  for (let i = 0; i < anchors.length + 1; i++) {
+    const prevAnchor = anchors[i - 1];
+    const nextAnchor = anchors[i];
+    segments.push({
+      labels: baseline.slice(prevAnchor?.offset, nextAnchor?.offset).split("").map((c) => vocab.get(c) ?? star),
+      labelsStart: prevAnchor?.offset ?? 0,
+      emissions: emissions.slice(prevAnchor?.position, nextAnchor?.position),
+      emissionsStart: prevAnchor?.position ?? 0
+    });
+  }
+  segments[0]?.labels.unshift(star);
+  segments.at(-1)?.labels.push(star);
+  const alignmentsWithRemovals = [];
+  const inputIndices = [];
+  for (const segment of segments) {
+    let stripBoundingStars2 = function(arr) {
+      let result = arr;
+      if (segment === segments[0]) {
+        result = result.slice(1);
+      }
+      if (segment === segments.at(-1)) {
+        result = result.slice(0, -1);
+      }
+      return result;
+    };
+    var stripBoundingStars = stripBoundingStars2;
+    let indices = Array.from((0, import_itertools.range)(stripBoundingStars2(segment.labels).length));
+    let unmapped = ctcViterbiAlign(
+      segment.emissions,
+      segment.labels,
+      blankId,
+      star,
+      STAR_SCORE
+    );
+    const dropped = dropLabels(
+      segment.labelsStart,
+      stripBoundingStars2(unmapped)
+    ).map(([s, e]) => [
+      s - segment.labelsStart,
+      e - segment.labelsStart
+    ]);
+    if (dropped.length) {
+      const { result: adjustedLabels, inputIndices: adjustedIndices } = removeLabelRanges(stripBoundingStars2(segment.labels), dropped);
+      indices = adjustedIndices;
+      if (segment === segments[0]) {
+        adjustedLabels.unshift(star);
+      }
+      if (segment === segments.at(-1)) {
+        adjustedLabels.push(star);
+      }
+      unmapped = ctcViterbiAlign(
+        segment.emissions,
+        adjustedLabels,
+        blankId,
+        star,
+        STAR_SCORE
+      );
+    }
+    const segmentAlignments = unmapped.map((a) => ({
+      ...a,
+      startFrame: a.startFrame + segment.emissionsStart,
+      endFrame: a.endFrame + segment.emissionsStart
+    }));
+    inputIndices.push(...indices.map((i) => i + segment.labelsStart));
+    alignmentsWithRemovals.push(...segmentAlignments);
+  }
+  const alignments = [];
+  for (const [k, a] of (0, import_itertools.enumerate)(alignmentsWithRemovals.slice(1, -1))) {
+    const i = inputIndices[k];
+    const lastUndroppedIndex = alignments.length - 1;
+    const lastUndropped = alignments[lastUndroppedIndex] ?? {
+      startFrame: 0,
+      endFrame: 0,
+      score: -Infinity,
+      label: star
+    };
+    for (const j of (0, import_itertools.range)(lastUndroppedIndex, i - 1)) {
+      alignments.push({
+        startFrame: lastUndropped.endFrame,
+        endFrame: lastUndropped.endFrame,
+        score: -Infinity,
+        label: vocab.get(baseline[j])
+      });
+    }
+    alignments[i] = a;
+  }
+  return alignments;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ctcForcedAlign,
+  ctcViterbiAlign,
+  detectDroppedLabels
+});