@storyteller-platform/align 0.1.9 → 0.1.11

package/dist/align/getSentenceRanges.js

@@ -1,27 +1,8 @@
 import "../chunk-BIEQXUOY.js";
-import { segmentText } from "@echogarden/text-segmentation";
+import { enumerate } from "itertools";
 import { getTrackDuration } from "../common/ffmpeg.js";
-import { findNearestMatch } from "./fuzzy.js";
+import { errorAlign } from "../errorAlign/errorAlign.js";
 import { slugify } from "./slugify.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
@@ -39,144 +20,92 @@ function findEndTimestamp(matchEndIndex, transcription) {
   );
   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;
+function getAlignmentsForSentence(sentence, alignments) {
+  const result = [];
+  let sentenceIndex = 0;
+  for (const alignment of alignments) {
+    if (sentenceIndex === sentence.length) break;
+    if (alignment.opType !== "INSERT") {
+      sentenceIndex += alignment.ref.length + (sentenceIndex === 0 ? 0 : 1);
+    }
+    result.push(alignment);
   }
-  return { index, offset };
+  return result;
 }
-function collapseWhitespace(input) {
-  return input.replaceAll(/\s+/g, " ");
-}
-async function getSentenceRanges(startSentence, transcription, sentences, chapterOffset, locale, lastSentenceRange) {
+async function getSentenceRanges(startSentence, endSentence, transcription, sentences, chapterOffset, chapterEndOffset, locale) {
   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 = [];
-  for (let i = 0; i < sentences.length; i++) {
-    const sentence = (await slugify(sentences[i], locale)).result;
-    if (sentence.length <= 3) {
-      if (i < startSentence) startSentenceEntry--;
-      continue;
-    }
-    sentenceEntries.push([i, sentence]);
-  }
-  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 { result: transcriptionWindow, mapping } = await slugify(
-      transcriptionWindowList.join("-").slice(transcriptionWindowOffset),
-      locale
-    );
-    const inverted = mapping.invert();
-    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 fullTranscript = transcription.transcript;
+  const chapterTranscript = fullTranscript.slice(
+    chapterOffset,
+    chapterEndOffset
+  );
+  const { result: slugifiedChapterTranscript, mapping: transcriptMapping } = await slugify(chapterTranscript, locale);
+  let chapterTranscriptEndIndex = chapterOffset;
+  let chapterSentenceIndex = startSentence;
+  let slugifiedChapterTranscriptWindowStartIndex = 0;
+  while (chapterSentenceIndex < endSentence) {
+    const slugifiedChapterSentenceWindowList = [];
+    let sentenceWindowLength = 0;
+    let i = chapterSentenceIndex;
+    while (sentenceWindowLength < 5e3 && i < sentences.length) {
+      const { result: sentence } = await slugify(sentences[i], locale);
+      slugifiedChapterSentenceWindowList.push(sentence);
+      sentenceWindowLength += sentence.length;
+      i++;
     }
-    const transcriptionOffset = transcriptionSentences.slice(0, transcriptionWindowIndex).join("").length;
-    const matchStart = inverted.map(firstMatch.index, 1);
-    const matchEnd = inverted.map(
-      firstMatch.index + firstMatch.match.length,
-      -1
+    const slugifiedChapterSentenceWindow = slugifiedChapterSentenceWindowList.join("-");
+    const slugifiedChapterTranscriptWindow = slugifiedChapterTranscript.slice(
+      slugifiedChapterTranscriptWindowStartIndex,
+      slugifiedChapterTranscriptWindowStartIndex + sentenceWindowLength * 1.2
     );
-    const startResult = findStartTimestamp(
-      matchStart + transcriptionOffset + transcriptionWindowOffset + chapterOffset,
-      transcription
+    const alignments = errorAlign(
+      slugifiedChapterSentenceWindow,
+      slugifiedChapterTranscriptWindow
     );
-    if (!startResult) {
-      sentenceIndex += 1;
-      continue;
-    }
-    let start = startResult.start;
-    const audiofile = startResult.audiofile;
-    const end = findEndTimestamp(
-      matchEnd + 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;
-        }
+    let alignmentIndex = 0;
+    let currentTranscriptWindowIndex = 0;
+    for (const [i2, slugifiedSentence] of enumerate(
+      slugifiedChapterSentenceWindowList
+    )) {
+      if (!slugifiedSentence) continue;
+      const sentenceAlignments = getAlignmentsForSentence(
+        slugifiedSentence,
+        alignments.slice(alignmentIndex)
+      );
+      const sentenceLengthInSlugifiedTranscript = sentenceAlignments.filter((a) => a.opType !== "DELETE").map((a) => a.hyp).join("-").length;
+      const start = findStartTimestamp(
+        chapterOffset + transcriptMapping.invert().map(
+          slugifiedChapterTranscriptWindowStartIndex + currentTranscriptWindowIndex,
+          1
+        ),
+        transcription
+      );
+      chapterTranscriptEndIndex = chapterOffset + transcriptMapping.invert().map(
+        slugifiedChapterTranscriptWindowStartIndex + currentTranscriptWindowIndex + sentenceLengthInSlugifiedTranscript,
+        -1
+      );
+      const end = findEndTimestamp(chapterTranscriptEndIndex, transcription);
+      if (start && end !== null) {
+        sentenceRanges.push({
+          id: i2 + chapterSentenceIndex,
+          start: start.start,
+          audiofile: start.audiofile,
+          end
+        });
       }
-    } 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;
-        }
+      alignmentIndex += sentenceAlignments.length;
+      currentTranscriptWindowIndex += sentenceLengthInSlugifiedTranscript;
+      if (slugifiedChapterTranscriptWindow[currentTranscriptWindowIndex] === "-") {
+        currentTranscriptWindowIndex++;
       }
-    } else if (sentenceId === 0) {
-      start = 0;
     }
-    sentenceRanges.push({
-      id: sentenceId,
-      start,
-      end,
-      audiofile
-    });
-    notFound = 0;
-    lastMatchEnd = matchEnd + transcriptionOffset + transcriptionWindowOffset + chapterOffset;
-    const windowIndexResult = getWindowIndexFromOffset(
-      transcriptionWindowList,
-      matchEnd + transcriptionWindowOffset
-    );
-    transcriptionWindowIndex += windowIndexResult.index;
-    transcriptionWindowOffset = windowIndexResult.offset;
-    lastGoodTranscriptionWindow = transcriptionWindowIndex;
-    sentenceIndex += 1;
+    chapterSentenceIndex += slugifiedChapterSentenceWindowList.length;
+    slugifiedChapterTranscriptWindowStartIndex += currentTranscriptWindowIndex;
+    if (slugifiedChapterTranscript[slugifiedChapterTranscriptWindowStartIndex] === "-") {
+      slugifiedChapterTranscriptWindowStartIndex++;
+    }
   }
-  return {
-    sentenceRanges,
-    transcriptionOffset: lastMatchEnd
-  };
+  return { sentenceRanges, transcriptionOffset: chapterTranscriptEndIndex };
 }
 async function getLargestGap(trailing, leading) {
   const leadingGap = leading.start;

package/dist/align/slugify.cjs

@@ -67,11 +67,15 @@ function createReplacers(locale) {
     const normalizedNumeral = numeralMatch.replaceAll(new RegExp(`\\${currencySymbols.group}`, "g"), "").replace(new RegExp(`\\${currencySymbols.decimal}`), ".");
     const number = parseFloat(normalizedNumeral);
     if (Number.isNaN(number)) return match[0];
-    return (0, import_to_words.toWords)(number, {
-      localeCode: `${maximizedLocale.language}-${maximizedLocale.region}`,
-      currency: true,
-      doNotAddOnly: true
-    });
+    try {
+      return (0, import_to_words.toWords)(number, {
+        localeCode: `${maximizedLocale.language}-${maximizedLocale.region}`,
+        currency: true,
+        doNotAddOnly: true
+      });
+    } catch {
+      return match[0];
+    }
   }
   const numberFormat = new Intl.NumberFormat(locale);
   const numberParts = numberFormat.formatToParts(demoNumber);
@@ -103,9 +107,13 @@ function createReplacers(locale) {
     const normalizedNumeral = numeralMatch.replaceAll(new RegExp(`\\${numberSymbols.group}`, "g"), "").replace(new RegExp(`\\${numberSymbols.decimal}`), ".");
     const number = parseFloat(normalizedNumeral);
     if (Number.isNaN(number)) return match[0];
-    return (0, import_to_words.toWords)(number, {
-      localeCode: `${maximizedLocale.language}-${maximizedLocale.region}`
-    });
+    try {
+      return (0, import_to_words.toWords)(number, {
+        localeCode: `${maximizedLocale.language}-${maximizedLocale.region}`
+      });
+    } catch {
+      return match[0];
+    }
   }
   return [
     [currencyRegex, currencyReplacer],

package/dist/align/slugify.js

@@ -45,11 +45,15 @@ function createReplacers(locale) {
     const normalizedNumeral = numeralMatch.replaceAll(new RegExp(`\\${currencySymbols.group}`, "g"), "").replace(new RegExp(`\\${currencySymbols.decimal}`), ".");
     const number = parseFloat(normalizedNumeral);
     if (Number.isNaN(number)) return match[0];
-    return toWords(number, {
-      localeCode: `${maximizedLocale.language}-${maximizedLocale.region}`,
-      currency: true,
-      doNotAddOnly: true
-    });
+    try {
+      return toWords(number, {
+        localeCode: `${maximizedLocale.language}-${maximizedLocale.region}`,
+        currency: true,
+        doNotAddOnly: true
+      });
+    } catch {
+      return match[0];
+    }
   }
   const numberFormat = new Intl.NumberFormat(locale);
   const numberParts = numberFormat.formatToParts(demoNumber);
@@ -81,9 +85,13 @@ function createReplacers(locale) {
     const normalizedNumeral = numeralMatch.replaceAll(new RegExp(`\\${numberSymbols.group}`, "g"), "").replace(new RegExp(`\\${numberSymbols.decimal}`), ".");
     const number = parseFloat(normalizedNumeral);
     if (Number.isNaN(number)) return match[0];
-    return toWords(number, {
-      localeCode: `${maximizedLocale.language}-${maximizedLocale.region}`
-    });
+    try {
+      return toWords(number, {
+        localeCode: `${maximizedLocale.language}-${maximizedLocale.region}`
+      });
+    } catch {
+      return match[0];
+    }
   }
   return [
     [currencyRegex, currencyReplacer],

package/dist/errorAlign/__tests__/errorAlign.test.cjs

@@ -0,0 +1,100 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_node_assert = __toESM(require("node:assert"), 1);
+var import_node_test = require("node:test");
+var import_editDistance = require("../editDistance.cjs");
+var import_errorAlign = require("../errorAlign.cjs");
+var import_utils = require("../utils.cjs");
+void (0, import_node_test.describe)("errorAlign", () => {
+  void (0, import_node_test.test)("error alignment for an example including all substitution types", () => {
+    const ref = "This is a substitution test deleted.";
+    const hyp = "Inserted this is a contribution test.";
+    const alignments = (0, import_errorAlign.errorAlign)(ref, hyp);
+    import_node_assert.default.deepStrictEqual(
+      alignments.map((a) => a.opType),
+      ["INSERT", "MATCH", "MATCH", "MATCH", "SUBSTITUTE", "MATCH", "DELETE"]
+    );
+  });
+  void (0, import_node_test.test)("error alignment for full match", () => {
+    const ref = "This is a test.";
+    const hyp = "This is a test.";
+    const alignments = (0, import_errorAlign.errorAlign)(ref, hyp);
+    import_node_assert.default.deepStrictEqual(
+      alignments.map((a) => a.opType),
+      ["MATCH", "MATCH", "MATCH", "MATCH"]
+    );
+  });
+  void (0, import_node_test.test)("error alignment for partial substitutions and insertions with compound markers", () => {
+    var _a, _b;
+    const ref = "test";
+    const hyp = "testpartial";
+    const alignments = (0, import_errorAlign.errorAlign)(ref, hyp);
+    import_node_assert.default.strictEqual(alignments.length, 2);
+    import_node_assert.default.strictEqual((_a = alignments[0]) == null ? void 0 : _a.opType, "SUBSTITUTE");
+    import_node_assert.default.strictEqual(alignments[0].leftCompound, false);
+    import_node_assert.default.strictEqual(alignments[0].rightCompound, true);
+    import_node_assert.default.strictEqual((_b = alignments[1]) == null ? void 0 : _b.opType, "INSERT");
+    import_node_assert.default.strictEqual(alignments[1].leftCompound, true);
+    import_node_assert.default.strictEqual(alignments[1].rightCompound, false);
+  });
+});
+void (0, import_node_test.test)("character categorization", () => {
+  import_node_assert.default.strictEqual((0, import_utils.categorizeChar)("<"), 0);
+  import_node_assert.default.strictEqual((0, import_utils.categorizeChar)("b"), 1);
+  import_node_assert.default.strictEqual((0, import_utils.categorizeChar)("a"), 2);
+  import_node_assert.default.strictEqual((0, import_utils.categorizeChar)("'"), 3);
+});
+void (0, import_node_test.test)("string representation of alignment objects", () => {
+  const deleteAlignment = (0, import_errorAlign.errorAlign)("deleted", "")[0];
+  import_node_assert.default.strictEqual(
+    deleteAlignment == null ? void 0 : deleteAlignment.toString(),
+    'Alignment(DELETE: "deleted")'
+  );
+  const insertAlignment = (0, import_errorAlign.errorAlign)("", "inserted")[0];
+  import_node_assert.default.strictEqual(
+    insertAlignment == null ? void 0 : insertAlignment.toString(),
+    'Alignment(INSERT: "inserted")'
+  );
+  const substituteAlignment = (0, import_errorAlign.errorAlign)(
+    "substitution",
+    "substitutiontesting"
+  )[0];
+  import_node_assert.default.strictEqual(substituteAlignment == null ? void 0 : substituteAlignment.leftCompound, false);
+  import_node_assert.default.strictEqual(substituteAlignment.rightCompound, true);
+  import_node_assert.default.strictEqual(
+    substituteAlignment.toString(),
+    'Alignment(SUBSTITUTE: "substitution"- -> "substitution")'
+  );
+  const matchAlignment = (0, import_errorAlign.errorAlign)("test", "test")[0];
+  import_node_assert.default.strictEqual(
+    matchAlignment == null ? void 0 : matchAlignment.toString(),
+    'Alignment(MATCH: "test" == "test")'
+  );
+});
+void (0, import_node_test.test)("Levenshtein distance matrix computation", () => {
+  const ref = "kitten";
+  const hyp = "sitting";
+  const distanceMatrix = (0, import_editDistance.computeLevenshteinDistanceMatrix)(ref, hyp);
+  import_node_assert.default.strictEqual(distanceMatrix.at(-1).at(-1), 3);
+});

package/dist/errorAlign/__tests__/errorAlign.test.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/errorAlign/__tests__/errorAlign.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/errorAlign/__tests__/errorAlign.test.js

@@ -0,0 +1,77 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { computeLevenshteinDistanceMatrix } from "../editDistance.js";
+import { errorAlign } from "../errorAlign.js";
+import { categorizeChar } from "../utils.js";
+void describe("errorAlign", () => {
+  void test("error alignment for an example including all substitution types", () => {
+    const ref = "This is a substitution test deleted.";
+    const hyp = "Inserted this is a contribution test.";
+    const alignments = errorAlign(ref, hyp);
+    assert.deepStrictEqual(
+      alignments.map((a) => a.opType),
+      ["INSERT", "MATCH", "MATCH", "MATCH", "SUBSTITUTE", "MATCH", "DELETE"]
+    );
+  });
+  void test("error alignment for full match", () => {
+    const ref = "This is a test.";
+    const hyp = "This is a test.";
+    const alignments = errorAlign(ref, hyp);
+    assert.deepStrictEqual(
+      alignments.map((a) => a.opType),
+      ["MATCH", "MATCH", "MATCH", "MATCH"]
+    );
+  });
+  void test("error alignment for partial substitutions and insertions with compound markers", () => {
+    var _a, _b;
+    const ref = "test";
+    const hyp = "testpartial";
+    const alignments = errorAlign(ref, hyp);
+    assert.strictEqual(alignments.length, 2);
+    assert.strictEqual((_a = alignments[0]) == null ? void 0 : _a.opType, "SUBSTITUTE");
+    assert.strictEqual(alignments[0].leftCompound, false);
+    assert.strictEqual(alignments[0].rightCompound, true);
+    assert.strictEqual((_b = alignments[1]) == null ? void 0 : _b.opType, "INSERT");
+    assert.strictEqual(alignments[1].leftCompound, true);
+    assert.strictEqual(alignments[1].rightCompound, false);
+  });
+});
+void test("character categorization", () => {
+  assert.strictEqual(categorizeChar("<"), 0);
+  assert.strictEqual(categorizeChar("b"), 1);
+  assert.strictEqual(categorizeChar("a"), 2);
+  assert.strictEqual(categorizeChar("'"), 3);
+});
+void test("string representation of alignment objects", () => {
+  const deleteAlignment = errorAlign("deleted", "")[0];
+  assert.strictEqual(
+    deleteAlignment == null ? void 0 : deleteAlignment.toString(),
+    'Alignment(DELETE: "deleted")'
+  );
+  const insertAlignment = errorAlign("", "inserted")[0];
+  assert.strictEqual(
+    insertAlignment == null ? void 0 : insertAlignment.toString(),
+    'Alignment(INSERT: "inserted")'
+  );
+  const substituteAlignment = errorAlign(
+    "substitution",
+    "substitutiontesting"
+  )[0];
+  assert.strictEqual(substituteAlignment == null ? void 0 : substituteAlignment.leftCompound, false);
+  assert.strictEqual(substituteAlignment.rightCompound, true);
+  assert.strictEqual(
+    substituteAlignment.toString(),
+    'Alignment(SUBSTITUTE: "substitution"- -> "substitution")'
+  );
+  const matchAlignment = errorAlign("test", "test")[0];
+  assert.strictEqual(
+    matchAlignment == null ? void 0 : matchAlignment.toString(),
+    'Alignment(MATCH: "test" == "test")'
+  );
+});
+void test("Levenshtein distance matrix computation", () => {
+  const ref = "kitten";
+  const hyp = "sitting";
+  const distanceMatrix = computeLevenshteinDistanceMatrix(ref, hyp);
+  assert.strictEqual(distanceMatrix.at(-1).at(-1), 3);
+});

package/dist/errorAlign/__tests__/native.test.cjs

@@ -0,0 +1,118 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_node_assert = __toESM(require("node:assert"), 1);
+var import_node_test = require("node:test");
+var import_beamSearch = require("../beamSearch.cjs");
+var import_editDistance = require("../editDistance.cjs");
+var import_graphMetadata = require("../graphMetadata.cjs");
+var import_native = require("../native.cjs");
+var import_pathToAlignment = require("../pathToAlignment.cjs");
+var import_utils = require("../utils.cjs");
+void (0, import_node_test.describe)("native C++ vs TypeScript implementations", () => {
+  void (0, import_node_test.describe)("Levenshtein distance matrix", () => {
+    void (0, import_node_test.test)("string input", () => {
+      const ref = "kitten";
+      const hyp = "sitting";
+      const tsResult = (0, import_editDistance.computeLevenshteinDistanceMatrix)(ref, hyp);
+      const nativeResult = (0, import_native.computeLevenshteinDistanceMatrix)(ref, hyp);
+      import_node_assert.default.deepStrictEqual(nativeResult, tsResult);
+    });
+    void (0, import_node_test.test)("string array input", () => {
+      const ref = ["hello", "world"];
+      const hyp = ["hello", "there"];
+      const tsResult = (0, import_editDistance.computeLevenshteinDistanceMatrix)(ref, hyp);
+      const nativeResult = (0, import_native.computeLevenshteinDistanceMatrix)(ref, hyp);
+      import_node_assert.default.deepStrictEqual(nativeResult, tsResult);
+    });
+    void (0, import_node_test.test)("with backtrace", () => {
+      const ref = "kitten";
+      const hyp = "sitting";
+      const tsResult = (0, import_editDistance.computeLevenshteinDistanceMatrix)(ref, hyp, true);
+      const nativeResult = (0, import_native.computeLevenshteinDistanceMatrix)(ref, hyp, true);
+      import_node_assert.default.deepStrictEqual(nativeResult, tsResult);
+    });
+  });
+  void (0, import_node_test.describe)("error align distance matrix", () => {
+    void (0, import_node_test.test)("string input", () => {
+      const ref = "test";
+      const hyp = "best";
+      const tsResult = (0, import_editDistance.computeErrorAlignDistanceMatrix)(ref, hyp);
+      const nativeResult = (0, import_native.computeErrorAlignDistanceMatrix)(ref, hyp);
+      import_node_assert.default.deepStrictEqual(nativeResult, tsResult);
+    });
+    void (0, import_node_test.test)("with backtrace", () => {
+      const ref = "test";
+      const hyp = "best";
+      const tsResult = (0, import_editDistance.computeErrorAlignDistanceMatrix)(ref, hyp, true);
+      const nativeResult = (0, import_native.computeErrorAlignDistanceMatrix)(ref, hyp, true);
+      import_node_assert.default.deepStrictEqual(nativeResult, tsResult);
+    });
+  });
+  void (0, import_node_test.describe)("beam search", () => {
+    function buildSubgraphMetadata(ref, hyp) {
+      const tokenizer = import_utils.basicTokenizer;
+      const normalizer = import_utils.basicNormalizer;
+      const unpackedTokenizer = (0, import_utils.unpackRegexMatch)(tokenizer);
+      const ensuredNormalizer = (0, import_utils.ensureLengthPreservation)(normalizer);
+      const refTokenMatches = unpackedTokenizer(ref);
+      const hypTokenMatches = unpackedTokenizer(hyp);
+      const refNorm = refTokenMatches.map(([r]) => ensuredNormalizer(r));
+      const hypNorm = hypTokenMatches.map(([h]) => ensuredNormalizer(h));
+      return new import_graphMetadata.SubgraphMetadata(
+        ref,
+        hyp,
+        refTokenMatches,
+        hypTokenMatches,
+        refNorm,
+        hypNorm
+      );
+    }
+    void (0, import_node_test.test)("simple substitution", () => {
+      const src = buildSubgraphMetadata("hello", "jello");
+      const tsPath = (0, import_beamSearch.errorAlignBeamSearch)(src);
+      const nativePath = (0, import_native.errorAlignBeamSearch)(src);
+      const tsAlignments = (0, import_pathToAlignment.getAlignments)(tsPath);
+      const nativeAlignments = (0, import_pathToAlignment.getAlignments)(nativePath);
+      import_node_assert.default.deepStrictEqual(nativeAlignments, tsAlignments);
+    });
+    void (0, import_node_test.test)("multi-word alignment with all op types", () => {
+      const ref = "This is a substitution test deleted.";
+      const hyp = "Inserted this is a contribution test.";
+      const src = buildSubgraphMetadata(ref, hyp);
+      const tsPath = (0, import_beamSearch.errorAlignBeamSearch)(src);
+      const nativePath = (0, import_native.errorAlignBeamSearch)(src);
+      const tsAlignments = (0, import_pathToAlignment.getAlignments)(tsPath);
+      const nativeAlignments = (0, import_pathToAlignment.getAlignments)(nativePath);
+      import_node_assert.default.deepStrictEqual(nativeAlignments, tsAlignments);
+    });
+    void (0, import_node_test.test)("identical strings", () => {
+      const src = buildSubgraphMetadata("test words", "test words");
+      const tsPath = (0, import_beamSearch.errorAlignBeamSearch)(src);
+      const nativePath = (0, import_native.errorAlignBeamSearch)(src);
+      const tsAlignments = (0, import_pathToAlignment.getAlignments)(tsPath);
+      const nativeAlignments = (0, import_pathToAlignment.getAlignments)(nativePath);
+      import_node_assert.default.deepStrictEqual(nativeAlignments, tsAlignments);
+    });
+  });
+});

package/dist/errorAlign/__tests__/native.test.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/errorAlign/__tests__/native.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }