@storyteller-platform/align 0.1.57 → 0.1.58

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

@@ -0,0 +1,21 @@
+import { Match } from './search.cjs';
+import '../../emit/fs.cjs';
+import '@storyteller-platform/ghost-story';
+import './emissions.cjs';
+
+interface TokenAlignment {
+    label: number;
+    startFrame: number;
+    endFrame: number;
+    score: number;
+}
+declare function ctcViterbiAlign(emissions: number[][], labels: number[], blankId: number, starId: number, starScore: number): {
+    label: number;
+    startFrame: number;
+    endFrame: number;
+    score: number;
+}[];
+declare function detectDroppedLabels(alignments: TokenAlignment[], startOffset: number, endOffset: number, minLength?: number): boolean;
+declare function ctcForcedAlign(baseline: string, emissions: number[][], anchors: Match[], vocab: Map<string, number>, blankId: number, dropLabels?: (labelOffset: number, alignments: TokenAlignment[]) => [number, number][]): TokenAlignment[];
+
+export { type TokenAlignment, ctcForcedAlign, ctcViterbiAlign, detectDroppedLabels };

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

@@ -0,0 +1,21 @@
+import { Match } from './search.js';
+import '../../emit/fs.js';
+import '@storyteller-platform/ghost-story';
+import './emissions.js';
+
+interface TokenAlignment {
+    label: number;
+    startFrame: number;
+    endFrame: number;
+    score: number;
+}
+declare function ctcViterbiAlign(emissions: number[][], labels: number[], blankId: number, starId: number, starScore: number): {
+    label: number;
+    startFrame: number;
+    endFrame: number;
+    score: number;
+}[];
+declare function detectDroppedLabels(alignments: TokenAlignment[], startOffset: number, endOffset: number, minLength?: number): boolean;
+declare function ctcForcedAlign(baseline: string, emissions: number[][], anchors: Match[], vocab: Map<string, number>, blankId: number, dropLabels?: (labelOffset: number, alignments: TokenAlignment[]) => [number, number][]): TokenAlignment[];
+
+export { type TokenAlignment, ctcForcedAlign, ctcViterbiAlign, detectDroppedLabels };

package/dist/align/ctc/forcedAlign.js

@@ -0,0 +1,248 @@
+import "../../chunk-BIEQXUOY.js";
+import { enumerate, range } from "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(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 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 range(lastUndroppedIndex, i - 1)) {
+      alignments.push({
+        startFrame: lastUndropped.endFrame,
+        endFrame: lastUndropped.endFrame,
+        score: -Infinity,
+        label: vocab.get(baseline[j])
+      });
+    }
+    alignments[i] = a;
+  }
+  return alignments;
+}
+export {
+  ctcForcedAlign,
+  ctcViterbiAlign,
+  detectDroppedLabels
+};

package/dist/align/ctc/greedyDecode.cjs

@@ -0,0 +1,61 @@
+"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 greedyDecode_exports = {};
+__export(greedyDecode_exports, {
+  argmax: () => argmax,
+  ctcGreedyDecode: () => ctcGreedyDecode
+});
+module.exports = __toCommonJS(greedyDecode_exports);
+function argmax(vector) {
+  let best = 0;
+  for (let i = 1; i < vector.length; i++) {
+    if (vector[i] > vector[best]) best = i;
+  }
+  return best;
+}
+async function ctcGreedyDecode(emissionsReader) {
+  const charByToken = /* @__PURE__ */ new Map();
+  for (const [char, id] of emissionsReader.vocab.entries()) {
+    if (id !== emissionsReader.blankId && char.length === 1 && char !== "|") {
+      charByToken.set(id, char);
+    }
+  }
+  const chars = [];
+  const frames = [];
+  let previous = -1;
+  let t = 0;
+  for await (const row of emissionsReader.frames()) {
+    const best = argmax(row);
+    if (best !== previous) {
+      const char = charByToken.get(best);
+      if (char !== void 0) {
+        chars.push(char);
+        frames.push(t);
+      }
+    }
+    previous = best;
+    t++;
+  }
+  return { text: chars.join(""), frames };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  argmax,
+  ctcGreedyDecode
+});

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

@@ -0,0 +1,15 @@
+import { EmissionsReader } from '../../emit/fs.cjs';
+import '@storyteller-platform/ghost-story';
+import './emissions.cjs';
+
+declare function argmax(vector: number[]): number;
+/**
+ * Returns the decoded text along with, for each character, the emission
+ * frame at which it was first observed.
+ */
+declare function ctcGreedyDecode(emissionsReader: EmissionsReader): Promise<{
+    text: string;
+    frames: number[];
+}>;
+
+export { argmax, ctcGreedyDecode };

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

@@ -0,0 +1,15 @@
+import { EmissionsReader } from '../../emit/fs.js';
+import '@storyteller-platform/ghost-story';
+import './emissions.js';
+
+declare function argmax(vector: number[]): number;
+/**
+ * Returns the decoded text along with, for each character, the emission
+ * frame at which it was first observed.
+ */
+declare function ctcGreedyDecode(emissionsReader: EmissionsReader): Promise<{
+    text: string;
+    frames: number[];
+}>;
+
+export { argmax, ctcGreedyDecode };

package/dist/align/ctc/greedyDecode.js

@@ -0,0 +1,37 @@
+import "../../chunk-BIEQXUOY.js";
+function argmax(vector) {
+  let best = 0;
+  for (let i = 1; i < vector.length; i++) {
+    if (vector[i] > vector[best]) best = i;
+  }
+  return best;
+}
+async function ctcGreedyDecode(emissionsReader) {
+  const charByToken = /* @__PURE__ */ new Map();
+  for (const [char, id] of emissionsReader.vocab.entries()) {
+    if (id !== emissionsReader.blankId && char.length === 1 && char !== "|") {
+      charByToken.set(id, char);
+    }
+  }
+  const chars = [];
+  const frames = [];
+  let previous = -1;
+  let t = 0;
+  for await (const row of emissionsReader.frames()) {
+    const best = argmax(row);
+    if (best !== previous) {
+      const char = charByToken.get(best);
+      if (char !== void 0) {
+        chars.push(char);
+        frames.push(t);
+      }
+    }
+    previous = best;
+    t++;
+  }
+  return { text: chars.join(""), frames };
+}
+export {
+  argmax,
+  ctcGreedyDecode
+};

package/dist/align/ctc/mediaOverlay.cjs

@@ -0,0 +1,248 @@
+"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 mediaOverlay_exports = {};
+__export(mediaOverlay_exports, {
+  buildFragmentMaps: () => buildFragmentMaps,
+  createMediaOverlay: () => createMediaOverlay
+});
+module.exports = __toCommonJS(mediaOverlay_exports);
+var import_posix = require("node:path/posix");
+var import_itertools = require("itertools");
+var import_epub = require("@storyteller-platform/epub");
+var import_textFragments = require("../textFragments.cjs");
+function createMediaOverlay(chapter, granularity, sentenceRanges, wordRanges, sentenceIdToBlockFragment, sentenceIdToFragment, wordIdToFragment) {
+  const subSequences = sentenceIdToBlockFragment ? createTextRangeLargeSequences(
+    chapter,
+    granularity,
+    sentenceRanges,
+    wordRanges,
+    sentenceIdToBlockFragment,
+    sentenceIdToFragment,
+    wordIdToFragment
+  ) : createTextRangeSmallSequences(
+    chapter,
+    granularity,
+    sentenceRanges,
+    wordRanges,
+    sentenceIdToFragment,
+    wordIdToFragment
+  );
+  return [
+    import_epub.Epub.createXmlElement(
+      "smil",
+      {
+        xmlns: "http://www.w3.org/ns/SMIL",
+        "xmlns:epub": "http://www.idpf.org/2007/ops",
+        version: "3.0"
+      },
+      [
+        import_epub.Epub.createXmlElement("body", {}, [
+          import_epub.Epub.createXmlElement(
+            "seq",
+            {
+              id: `${chapter.id}_overlay`,
+              "epub:textref": `../${chapter.href}`,
+              "epub:type": "chapter"
+            },
+            subSequences
+          )
+        ])
+      ]
+    )
+  ];
+}
+function createTextRangeLargeSequences(chapter, granularity, sentenceRanges, wordRanges, sentenceIdToBlockFragment, sentenceIdToFragment, wordIdToFragment) {
+  const blockStarts = sentenceIdToBlockFragment.entries().toArray().toSorted(([a], [b]) => a - b);
+  return blockStarts.map(([sentenceId, fragment], index) => {
+    const blockEnd = index === blockStarts.length - 1 ? sentenceRanges.length - 1 : (
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      blockStarts[index + 1][0]
+    );
+    const sentences = sentenceRanges.slice(sentenceId, blockEnd);
+    return import_epub.Epub.createXmlElement(
+      "seq",
+      {
+        id: `${chapter.id}-b${index}`,
+        "epub:type": "text-range-large",
+        "epub:textref": `../${chapter.href}#${fragment}`
+      },
+      createTextRangeSmallSequences(
+        chapter,
+        granularity,
+        sentences,
+        wordRanges,
+        sentenceIdToFragment,
+        wordIdToFragment
+      )
+    );
+  });
+}
+function createTextRangeSmallSequences(chapter, granularity, sentenceRanges, wordRanges, sentenceIdToFragment, wordIdToFragment) {
+  return sentenceRanges.map((sentenceRange) => {
+    if (granularity === "sentence" || !wordRanges.has(sentenceRange.id)) {
+      return import_epub.Epub.createXmlElement(
+        "par",
+        {
+          id: `${chapter.id}-s${sentenceRange.id}`
+        },
+        [
+          import_epub.Epub.createXmlElement("text", {
+            src: `../${chapter.href}#${sentenceIdToFragment.get(sentenceRange.id)}`
+          }),
+          import_epub.Epub.createXmlElement("audio", {
+            src: `../Audio/${(0, import_posix.basename)(sentenceRange.audiofile)}`,
+            clipBegin: `${sentenceRange.start.toFixed(3)}s`,
+            clipEnd: `${sentenceRange.end.toFixed(3)}s`
+          })
+        ]
+      );
+    }
+    const words = wordRanges.get(sentenceRange.id);
+    const wordToFragment = wordIdToFragment.get(sentenceRange.id);
+    return import_epub.Epub.createXmlElement(
+      "seq",
+      {
+        id: `${chapter.id}-s${sentenceRange.id}`,
+        "epub:type": "text-range-small",
+        "epub:textref": `../${chapter.href}#${sentenceIdToFragment.get(sentenceRange.id)}`
+      },
+      words.map(
+        (word) => import_epub.Epub.createXmlElement(
+          "par",
+          {
+            id: `${chapter.id}-s${sentenceRange.id}-w${word.id}`
+          },
+          [
+            import_epub.Epub.createXmlElement("text", {
+              src: `../${chapter.href}#${wordToFragment.get(word.id)}`
+            }),
+            import_epub.Epub.createXmlElement("audio", {
+              src: `../Audio/${(0, import_posix.basename)(word.audiofile)}`,
+              clipBegin: `${word.start.toFixed(3)}s`,
+              clipEnd: `${word.end.toFixed(3)}s`
+            })
+          ]
+        )
+      )
+    );
+  });
+}
+function buildFragmentMaps(sentenceRanges, wordRanges, sentences, locale, textRef, granularity) {
+  let sentenceIdToBlockFragment = null;
+  const sentenceIdToFragment = new Map(
+    sentenceRanges.map((range) => [
+      range.id,
+      `${range.chapterId}-s${range.id}`
+    ])
+  );
+  const wordIdToFragment = new Map(
+    wordRanges.map((ranges) => [
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      ranges[0].sentenceId,
+      new Map(
+        ranges.map((range) => [
+          range.id,
+          `${range.chapterId}-s${range.sentenceId}-w${range.id}`
+        ])
+      )
+    ])
+  );
+  const wordRangeMap = new Map(wordRanges.map((w) => [w[0].sentenceId, w]));
+  if (textRef === "text-fragment") {
+    sentenceIdToBlockFragment = /* @__PURE__ */ new Map();
+    const blocks = [[]];
+    for (const [i, sentence] of (0, import_itertools.enumerate)(sentences)) {
+      const text = sentence.text;
+      blocks.at(-1)?.push(text);
+      if (text.includes("\n") && i < sentences.length - 1) {
+        blocks.push([]);
+      }
+    }
+    const blockFactory = new import_textFragments.TextFragmentFactory(
+      blocks.map((block) => block.join("")),
+      locale
+    );
+    let sentenceRangeIndex = 0;
+    for (const [i, block] of (0, import_itertools.enumerate)(blocks)) {
+      sentenceIdToBlockFragment.set(
+        sentenceRangeIndex,
+        blockFactory.findMinimalFragment(i)
+      );
+      const sentenceFactory = new import_textFragments.TextFragmentFactory(
+        block.map((s) => s.replace("\n", "")),
+        locale
+      );
+      const blockRanges = sentenceRanges.slice(
+        sentenceRangeIndex,
+        sentenceRangeIndex + block.length
+      );
+      for (const [j, range] of (0, import_itertools.enumerate)(blockRanges)) {
+        sentenceIdToFragment.set(
+          range.id,
+          sentenceFactory.findMinimalFragment(j)
+        );
+      }
+      if (granularity === "word") {
+        const allWords = [];
+        for (const range of blockRanges) {
+          const sentence = sentences[range.id];
+          const words = [];
+          for (const w of sentence.words.entries) {
+            if (w.isPunctuation) {
+              const lastWord = words.at(-1);
+              if (lastWord === void 0) {
+                continue;
+              }
+              words[words.length - 1] = lastWord + w.text.replace("\n", "");
+            } else {
+              words.push(w.text);
+            }
+          }
+          allWords.push(...words);
+        }
+        const wordFactory = new import_textFragments.TextFragmentFactory(allWords);
+        let wordRangeIndex = 0;
+        for (const range of blockRanges) {
+          const ranges = wordRangeMap.get(range.id);
+          const toFragment = wordIdToFragment.get(range.id);
+          if (!ranges || !toFragment) continue;
+          for (const [k, wordRange] of (0, import_itertools.enumerate)(ranges)) {
+            toFragment.set(
+              wordRange.id,
+              wordFactory.findMinimalFragment(k + wordRangeIndex)
+            );
+          }
+          wordRangeIndex += ranges.length;
+        }
+      }
+      sentenceRangeIndex += block.length;
+    }
+  }
+  return {
+    sentenceIdToBlockFragment,
+    sentenceIdToFragment,
+    wordIdToFragment,
+    wordRangeMap
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildFragmentMaps,
+  createMediaOverlay
+});

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

@@ -0,0 +1,16 @@
+import * as _storyteller_platform_epub from '@storyteller-platform/epub';
+import { ManifestItem } from '@storyteller-platform/epub';
+import { SegmentationResult } from '@echogarden/text-segmentation';
+import { SentenceRange, WordRange } from '../getSentenceRanges.cjs';
+import '@storyteller-platform/ghost-story';
+import '@storyteller-platform/mapping';
+
+declare function createMediaOverlay(chapter: ManifestItem, granularity: "sentence" | "word", sentenceRanges: SentenceRange[], wordRanges: Map<number, WordRange[]>, sentenceIdToBlockFragment: Map<number, string> | null, sentenceIdToFragment: Map<number, string>, wordIdToFragment: Map<number, Map<number, string>>): _storyteller_platform_epub.XmlElement<"smil">[];
+declare function buildFragmentMaps(sentenceRanges: SentenceRange[], wordRanges: WordRange[][], sentences: SegmentationResult["sentences"], locale: Intl.Locale, textRef: "id-fragment" | "text-fragment", granularity: "sentence" | "word"): {
+    sentenceIdToBlockFragment: Map<number, string> | null;
+    sentenceIdToFragment: Map<number, string>;
+    wordIdToFragment: Map<number, Map<number, string>>;
+    wordRangeMap: Map<number, WordRange[]>;
+};
+
+export { buildFragmentMaps, createMediaOverlay };