@storyteller-platform/align 0.1.9 → 0.1.10

package/dist/errorAlign/beamSearch.js

@@ -0,0 +1,268 @@
+import "../chunk-BIEQXUOY.js";
+import assert from "node:assert";
+import { hash } from "./hash.js";
+import { END_DELIMITER, START_DELIMITER, translateSlice } from "./utils.js";
+const INT64_MASK = (1n << 64n) - 1n;
+const SORT_ID_BASE = 146527n;
+class Path {
+  constructor(src) {
+    this.src = src;
+  }
+  refIndex = -1;
+  hypIndex = -1;
+  lastHypIndex = -1;
+  lastRefIndex = -1;
+  closedCost = 0;
+  openCost = 0;
+  atUnambiguousMatchNode = false;
+  endIndices = [];
+  sortId = 0n;
+  /**
+   * Get the ID of the path used for pruning.
+   */
+  get pruneId() {
+    return hash([
+      this.hypIndex,
+      this.refIndex,
+      this.lastHypIndex,
+      this.lastRefIndex
+    ]);
+  }
+  /**
+   * Get the cost of the path.
+   */
+  get cost() {
+    const isSub = isSubstitution(
+      this.hypIndex,
+      this.refIndex,
+      this.lastHypIndex,
+      this.lastRefIndex
+    );
+    return this.closedCost + this.openCost + (isSub ? this.openCost : 0);
+  }
+  /**
+   * Get the normalized cost of the path.
+   */
+  get normCost() {
+    const cost = this.cost;
+    if (cost === 0) return 0;
+    return cost / (this.refIndex + this.hypIndex + 3);
+  }
+  /**
+   * Get the current node index of the path.
+   */
+  get index() {
+    return [this.hypIndex, this.refIndex];
+  }
+  /**
+   * Check if the path has reached the terminal node.
+   */
+  get atEnd() {
+    return this.hypIndex === this.src.hypMaxIndex && this.refIndex === this.src.refMaxIndex;
+  }
+  /**
+   * Update the sort ID for path ordering. Ensures identical behavior as C++ implementation.
+   */
+  updateSortId(t) {
+    this.sortId = this.sortId * SORT_ID_BASE + t & INT64_MASK;
+  }
+}
+function* expand(parent) {
+  const deletePath = addDelete(parent);
+  if (deletePath) yield deletePath;
+  const insertPath = addInsert(parent);
+  if (insertPath) yield insertPath;
+  const subOrMatchPath = addSubstitutionOrMatch(parent);
+  if (subOrMatchPath) yield subOrMatchPath;
+}
+function addSubstitutionOrMatch(parent) {
+  if (parent.refIndex >= parent.src.refMaxIndex || parent.hypIndex >= parent.src.hypMaxIndex) {
+    return null;
+  }
+  let child = transitionToChildNode(parent, {
+    refStep: 1,
+    hypStep: 1
+  });
+  const isMatch = parent.src.ref[child.refIndex] === parent.src.hyp[child.hypIndex];
+  if (!isMatch) {
+    const refIsDelimiter = parent.src.refCharTypes[child.refIndex] === 0;
+    const hypIsDelimiter = parent.src.hypCharTypes[child.hypIndex] === 0;
+    if (refIsDelimiter || hypIsDelimiter) return null;
+  }
+  if (parent.src.ref[child.refIndex] === START_DELIMITER) {
+    endInsertionSegment(child, parent.hypIndex, parent.refIndex);
+  }
+  if (!isMatch) {
+    const isBacktrace = parent.src.backtraceNodeSet.has(parent.index);
+    const isLetterTypeMatch = parent.src.refCharTypes[child.refIndex] === parent.src.hypCharTypes[child.hypIndex];
+    child.openCost += isLetterTypeMatch ? 2 : 3;
+    child.openCost += isBacktrace ? 0 : 1;
+  }
+  if (child.src.ref[child.refIndex] === END_DELIMITER) {
+    child = endSegment(child);
+  }
+  return child;
+}
+function addInsert(parent) {
+  if (parent.refIndex >= parent.src.refMaxIndex) {
+    return null;
+  }
+  let child = transitionToChildNode(parent, {
+    refStep: 1,
+    hypStep: 0
+  });
+  if (parent.src.ref[child.refIndex] === START_DELIMITER) {
+    endInsertionSegment(child, parent.hypIndex, parent.refIndex);
+  }
+  const isBacktrace = parent.src.backtraceNodeSet.has(parent.index);
+  const isDelimiter = parent.src.refCharTypes[child.refIndex] === 0;
+  child.openCost += isDelimiter ? 1 : 2;
+  child.openCost += isBacktrace || isDelimiter ? 0 : 1;
+  if (child.src.ref[child.refIndex] === END_DELIMITER) {
+    child = endSegment(child);
+  }
+  return child;
+}
+function addDelete(parent) {
+  if (parent.hypIndex >= parent.src.hypMaxIndex) {
+    return null;
+  }
+  const child = transitionToChildNode(parent, { refStep: 0, hypStep: 1 });
+  const isBacktrace = parent.src.backtraceNodeSet.has(parent.index);
+  const isDelimiter = parent.src.hypCharTypes[child.hypIndex] === 0;
+  child.openCost += isDelimiter ? 1 : 2;
+  child.openCost += isBacktrace || isDelimiter ? 0 : 1;
+  if (child.src.hyp[child.hypIndex] === END_DELIMITER) {
+    endInsertionSegment(child, child.hypIndex, child.refIndex);
+  }
+  return child;
+}
+function resetSegmentVariables(path, hypIndex, refIndex) {
+  path.closedCost += path.openCost;
+  const isSub = isSubstitution(
+    hypIndex,
+    refIndex,
+    path.lastHypIndex,
+    path.lastRefIndex
+  );
+  path.closedCost += isSub ? path.openCost : 0;
+  path.lastHypIndex = hypIndex;
+  path.lastRefIndex = refIndex;
+  path.openCost = 0;
+}
+function endInsertionSegment(path, hypIndex, refIndex) {
+  const hypSlice = translateSlice(
+    [path.lastHypIndex + 1, hypIndex + 1],
+    path.src.hypIndexMap
+  );
+  const refIsEmpty = refIndex === path.lastRefIndex;
+  if (hypSlice && refIsEmpty) {
+    path.endIndices = path.endIndices.concat([
+      [path.hypIndex, path.refIndex, path.openCost]
+    ]);
+    resetSegmentVariables(path, hypIndex, refIndex);
+  }
+}
+function endSegment(path) {
+  const hypSlice = translateSlice(
+    [path.lastHypIndex + 1, path.hypIndex + 1],
+    path.src.hypIndexMap
+  );
+  const refSlice = translateSlice(
+    [path.lastRefIndex + 1, path.refIndex + 1],
+    path.src.refIndexMap
+  );
+  assert(!!refSlice);
+  const hypIsEmpty = path.hypIndex === path.lastHypIndex;
+  if (hypIsEmpty) {
+    path.endIndices = path.endIndices.concat([
+      [path.hypIndex, path.refIndex, path.openCost]
+    ]);
+  } else {
+    if (!hypSlice) {
+      return null;
+    }
+    const isMatchSegment = path.openCost === 0;
+    path.atUnambiguousMatchNode = isMatchSegment && path.src.unambiguousMatches.has(path.index);
+    path.endIndices = path.endIndices.concat([
+      [path.hypIndex, path.refIndex, path.openCost]
+    ]);
+  }
+  resetSegmentVariables(path, path.hypIndex, path.refIndex);
+  return path;
+}
+function transitionToChildNode(parent, { refStep, hypStep }) {
+  const child = new Path(parent.src);
+  child.refIndex = parent.refIndex + refStep;
+  child.hypIndex = parent.hypIndex + hypStep;
+  child.lastHypIndex = parent.lastHypIndex;
+  child.lastRefIndex = parent.lastRefIndex;
+  child.closedCost = parent.closedCost;
+  child.openCost = parent.openCost;
+  child.atUnambiguousMatchNode = false;
+  child.endIndices = parent.endIndices;
+  child.sortId = parent.sortId;
+  child.updateSortId(BigInt(refStep + refStep + hypStep));
+  return child;
+}
+function isSubstitution(hypIndex, refIndex, lastHypIndex, lastRefIndex) {
+  return !(refIndex === lastRefIndex || hypIndex === lastHypIndex);
+}
+function errorAlignBeamSearch(src, beamSize = 100) {
+  var _a;
+  const startPath = new Path(src);
+  let beam = [startPath];
+  let pruneMap = {};
+  const ended = [];
+  while (beam.length > 0) {
+    const newBeam = {};
+    for (const path of beam) {
+      if (path.atEnd) {
+        ended.push(path);
+        continue;
+      }
+      for (const newPath of expand(path)) {
+        const newPathCost = newPath.cost;
+        const newPathPruneId = newPath.pruneId;
+        if (newPathPruneId in pruneMap) {
+          if (newPathCost > pruneMap[newPathPruneId]) {
+            continue;
+          }
+        }
+        pruneMap[newPathPruneId] = newPathCost;
+        if (!(newPathPruneId in newBeam) || newPathCost < newBeam[newPathPruneId].cost) {
+          newBeam[newPathPruneId] = newPath;
+        }
+      }
+    }
+    const newBeamPaths = Object.values(newBeam).toSorted((a, b) => {
+      if (a.normCost === b.normCost) {
+        const comp = a.sortId - b.sortId;
+        if (comp < 0n) return -1;
+        if (comp > 0n) return 1;
+        return 0;
+      }
+      return a.normCost - b.normCost;
+    });
+    beam = newBeamPaths.slice(0, beamSize);
+    if ((_a = beam[0]) == null ? void 0 : _a.atUnambiguousMatchNode) {
+      beam = beam.slice(0, 1);
+      pruneMap = {};
+    }
+  }
+  const [result] = ended.toSorted((a, b) => {
+    if (a.cost === b.cost) {
+      const comp = a.sortId - b.sortId;
+      if (comp < 0n) return -1;
+      if (comp > 0n) return 1;
+      return 0;
+    }
+    return a.cost - b.cost;
+  });
+  assert(!!result);
+  return result;
+}
+export {
+  Path,
+  errorAlignBeamSearch
+};

package/dist/errorAlign/core.cjs

@@ -0,0 +1,33 @@
+"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 core_exports = {};
+__export(core_exports, {
+  computeErrorAlignDistanceMatrix: () => import_editDistance.computeErrorAlignDistanceMatrix,
+  computeLevenshteinDistanceMatrix: () => import_editDistance.computeLevenshteinDistanceMatrix,
+  errorAlignBeamSearch: () => import_beamSearch.errorAlignBeamSearch
+});
+module.exports = __toCommonJS(core_exports);
+var import_editDistance = require("./editDistance.cjs");
+var import_beamSearch = require("./beamSearch.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computeErrorAlignDistanceMatrix,
+  computeLevenshteinDistanceMatrix,
+  errorAlignBeamSearch
+});

package/dist/errorAlign/core.d.cts

@@ -0,0 +1,5 @@
+export { computeErrorAlignDistanceMatrix, computeLevenshteinDistanceMatrix } from './editDistance.cjs';
+export { errorAlignBeamSearch } from './beamSearch.cjs';
+import './backtraceGraph.cjs';
+import './utils.cjs';
+import './graphMetadata.cjs';

package/dist/errorAlign/core.d.ts

@@ -0,0 +1,5 @@
+export { computeErrorAlignDistanceMatrix, computeLevenshteinDistanceMatrix } from './editDistance.js';
+export { errorAlignBeamSearch } from './beamSearch.js';
+import './backtraceGraph.js';
+import './utils.js';
+import './graphMetadata.js';

package/dist/errorAlign/core.js

@@ -0,0 +1,11 @@
+import "../chunk-BIEQXUOY.js";
+import {
+  computeErrorAlignDistanceMatrix,
+  computeLevenshteinDistanceMatrix
+} from "./editDistance.js";
+import { errorAlignBeamSearch } from "./beamSearch.js";
+export {
+  computeErrorAlignDistanceMatrix,
+  computeLevenshteinDistanceMatrix,
+  errorAlignBeamSearch
+};

package/dist/errorAlign/editDistance.cjs

@@ -0,0 +1,115 @@
+"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 editDistance_exports = {};
+__export(editDistance_exports, {
+  computeDistanceMatrix: () => computeDistanceMatrix,
+  computeErrorAlignDistanceMatrix: () => computeErrorAlignDistanceMatrix,
+  computeLevenshteinDistanceMatrix: () => computeLevenshteinDistanceMatrix
+});
+module.exports = __toCommonJS(editDistance_exports);
+var import_itertools = require("itertools");
+var import_utils = require("./utils.cjs");
+function getLevenshteinValues(refToken, hypToken) {
+  let diagCost;
+  if (hypToken === refToken) {
+    diagCost = 0;
+  } else {
+    diagCost = 1;
+  }
+  return [1, 1, diagCost];
+}
+function getErrorAlignValues(refToken, hypToken) {
+  let diagCost;
+  if (hypToken === refToken) {
+    diagCost = 0;
+  } else if (import_utils.DELIMITERS.has(hypToken) || import_utils.DELIMITERS.has(refToken)) {
+    diagCost = 3;
+  } else {
+    diagCost = 2;
+  }
+  return [1, 1, diagCost];
+}
+function computeDistanceMatrix(ref, hyp, scoreFunc, backtrace = false) {
+  const hypDim = hyp.length + 1;
+  const refDim = ref.length + 1;
+  const scoreMatrix = Array.from((0, import_itertools.range)(hypDim)).map(
+    (_) => Array.from((0, import_itertools.range)(refDim)).map((_2) => 0)
+  );
+  for (const j of (0, import_itertools.range)(refDim)) {
+    scoreMatrix[0][j] = j;
+  }
+  for (const i of (0, import_itertools.range)(hypDim)) {
+    scoreMatrix[i][0] = i;
+  }
+  let backtraceMatrix = null;
+  if (backtrace) {
+    backtraceMatrix = Array.from((0, import_itertools.range)(hypDim)).map(
+      (_) => Array.from((0, import_itertools.range)(refDim)).map((_2) => 0)
+    );
+    backtraceMatrix[0][0] = (0, import_utils.getOpTypeComboIndex)(["MATCH"]);
+    for (const j of (0, import_itertools.range)(1, refDim)) {
+      backtraceMatrix[0][j] = (0, import_utils.getOpTypeComboIndex)(["DELETE"]);
+    }
+    for (const i of (0, import_itertools.range)(1, hypDim)) {
+      backtraceMatrix[i][0] = (0, import_utils.getOpTypeComboIndex)(["INSERT"]);
+    }
+  }
+  for (const j of (0, import_itertools.range)(1, refDim)) {
+    for (const i of (0, import_itertools.range)(1, hypDim)) {
+      const [insCost, delCost, diagCost] = scoreFunc(ref[j - 1], hyp[i - 1]);
+      const insVal = scoreMatrix[i - 1][j] + insCost;
+      const delVal = scoreMatrix[i][j - 1] + delCost;
+      const diagVal = scoreMatrix[i - 1][j - 1] + diagCost;
+      const newVal = Math.min(insVal, delVal, diagVal);
+      scoreMatrix[i][j] = newVal;
+      if (backtraceMatrix) {
+        const posOps = [];
+        if (diagVal === newVal && diagCost <= 0) {
+          posOps.push("MATCH");
+        }
+        if (insVal === newVal) {
+          posOps.push("INSERT");
+        }
+        if (delVal === newVal) {
+          posOps.push("DELETE");
+        }
+        if (diagVal === newVal && diagCost > 0) {
+          posOps.push("SUBSTITUTE");
+        }
+        backtraceMatrix[i][j] = (0, import_utils.getOpTypeComboIndex)(posOps);
+      }
+    }
+  }
+  if (backtraceMatrix) {
+    return { scoreMatrix, backtraceMatrix };
+  }
+  return scoreMatrix;
+}
+function computeLevenshteinDistanceMatrix(ref, hyp, backtrace = false) {
+  return computeDistanceMatrix(ref, hyp, getLevenshteinValues, backtrace);
+}
+function computeErrorAlignDistanceMatrix(ref, hyp, backtrace = false) {
+  return computeDistanceMatrix(ref, hyp, getErrorAlignValues, backtrace);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computeDistanceMatrix,
+  computeErrorAlignDistanceMatrix,
+  computeLevenshteinDistanceMatrix
+});

package/dist/errorAlign/editDistance.d.cts

@@ -0,0 +1,46 @@
+/**
+ * Compute the edit distance score matrix between two sequences x (hyp) and y (ref)
+ * using only pure Python lists.
+ *
+ * @param ref The reference sequence/transcript.
+ * @param hyp The hypothesis sequence/transcript.
+ * @param scoreFunc A function that takes two tokens (refToken, hypToken) and returns
+ *                  a tuple of (deletionCost, insertionCost, diagonalCost)
+ * @param backtrace Whether to compute the backtrace matrix.
+ * @returns The score matrix and optionally the backtrace matrix
+ */
+declare function computeDistanceMatrix(ref: string | string[], hyp: string | string[], scoreFunc: (refToken: string, hypToken: string) => [number, number, number]): number[][];
+declare function computeDistanceMatrix(ref: string | string[], hyp: string | string[], scoreFunc: (refToken: string, hypToken: string) => [number, number, number], backtrace: boolean): {
+    scoreMatrix: number[][];
+    backtraceMatrix: number[][];
+};
+/**
+ * Compute the Levenshtein distance matrix between two sequences.
+ *
+ * @param ref The reference sequence/transcript.
+ * @param hyp The hypothesis sequence/transcript.
+ * @param backtrace Whether to compute the backtrace matrix.
+ *
+ * @returns The score matrix and optionally the backtrace matrix
+ */
+declare function computeLevenshteinDistanceMatrix(ref: string | string[], hyp: string | string[]): number[][];
+declare function computeLevenshteinDistanceMatrix(ref: string | string[], hyp: string | string[], backtrace: true): {
+    scoreMatrix: number[][];
+    backtraceMatrix: number[][];
+};
+/**
+ * Compute the error alignment distance matrix between two sequences.
+ *
+ * @param ref The reference sequence/transcript.
+ * @param hyp The hypothesis sequence/transcript.
+ * @param backtrace Whether to compute the backtrace matrix.
+ *
+ * @returns The score matrix and optionally the backtrace matrix.
+ */
+declare function computeErrorAlignDistanceMatrix(ref: string | string[], hyp: string | string[]): number[][];
+declare function computeErrorAlignDistanceMatrix(ref: string | string[], hyp: string | string[], backtrace: true): {
+    scoreMatrix: number[][];
+    backtraceMatrix: number[][];
+};
+
+export { computeDistanceMatrix, computeErrorAlignDistanceMatrix, computeLevenshteinDistanceMatrix };

package/dist/errorAlign/editDistance.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Compute the edit distance score matrix between two sequences x (hyp) and y (ref)
+ * using only pure Python lists.
+ *
+ * @param ref The reference sequence/transcript.
+ * @param hyp The hypothesis sequence/transcript.
+ * @param scoreFunc A function that takes two tokens (refToken, hypToken) and returns
+ *                  a tuple of (deletionCost, insertionCost, diagonalCost)
+ * @param backtrace Whether to compute the backtrace matrix.
+ * @returns The score matrix and optionally the backtrace matrix
+ */
+declare function computeDistanceMatrix(ref: string | string[], hyp: string | string[], scoreFunc: (refToken: string, hypToken: string) => [number, number, number]): number[][];
+declare function computeDistanceMatrix(ref: string | string[], hyp: string | string[], scoreFunc: (refToken: string, hypToken: string) => [number, number, number], backtrace: boolean): {
+    scoreMatrix: number[][];
+    backtraceMatrix: number[][];
+};
+/**
+ * Compute the Levenshtein distance matrix between two sequences.
+ *
+ * @param ref The reference sequence/transcript.
+ * @param hyp The hypothesis sequence/transcript.
+ * @param backtrace Whether to compute the backtrace matrix.
+ *
+ * @returns The score matrix and optionally the backtrace matrix
+ */
+declare function computeLevenshteinDistanceMatrix(ref: string | string[], hyp: string | string[]): number[][];
+declare function computeLevenshteinDistanceMatrix(ref: string | string[], hyp: string | string[], backtrace: true): {
+    scoreMatrix: number[][];
+    backtraceMatrix: number[][];
+};
+/**
+ * Compute the error alignment distance matrix between two sequences.
+ *
+ * @param ref The reference sequence/transcript.
+ * @param hyp The hypothesis sequence/transcript.
+ * @param backtrace Whether to compute the backtrace matrix.
+ *
+ * @returns The score matrix and optionally the backtrace matrix.
+ */
+declare function computeErrorAlignDistanceMatrix(ref: string | string[], hyp: string | string[]): number[][];
+declare function computeErrorAlignDistanceMatrix(ref: string | string[], hyp: string | string[], backtrace: true): {
+    scoreMatrix: number[][];
+    backtraceMatrix: number[][];
+};
+
+export { computeDistanceMatrix, computeErrorAlignDistanceMatrix, computeLevenshteinDistanceMatrix };

package/dist/errorAlign/editDistance.js

@@ -0,0 +1,90 @@
+import "../chunk-BIEQXUOY.js";
+import { range } from "itertools";
+import { DELIMITERS, getOpTypeComboIndex } from "./utils.js";
+function getLevenshteinValues(refToken, hypToken) {
+  let diagCost;
+  if (hypToken === refToken) {
+    diagCost = 0;
+  } else {
+    diagCost = 1;
+  }
+  return [1, 1, diagCost];
+}
+function getErrorAlignValues(refToken, hypToken) {
+  let diagCost;
+  if (hypToken === refToken) {
+    diagCost = 0;
+  } else if (DELIMITERS.has(hypToken) || DELIMITERS.has(refToken)) {
+    diagCost = 3;
+  } else {
+    diagCost = 2;
+  }
+  return [1, 1, diagCost];
+}
+function computeDistanceMatrix(ref, hyp, scoreFunc, backtrace = false) {
+  const hypDim = hyp.length + 1;
+  const refDim = ref.length + 1;
+  const scoreMatrix = Array.from(range(hypDim)).map(
+    (_) => Array.from(range(refDim)).map((_2) => 0)
+  );
+  for (const j of range(refDim)) {
+    scoreMatrix[0][j] = j;
+  }
+  for (const i of range(hypDim)) {
+    scoreMatrix[i][0] = i;
+  }
+  let backtraceMatrix = null;
+  if (backtrace) {
+    backtraceMatrix = Array.from(range(hypDim)).map(
+      (_) => Array.from(range(refDim)).map((_2) => 0)
+    );
+    backtraceMatrix[0][0] = getOpTypeComboIndex(["MATCH"]);
+    for (const j of range(1, refDim)) {
+      backtraceMatrix[0][j] = getOpTypeComboIndex(["DELETE"]);
+    }
+    for (const i of range(1, hypDim)) {
+      backtraceMatrix[i][0] = getOpTypeComboIndex(["INSERT"]);
+    }
+  }
+  for (const j of range(1, refDim)) {
+    for (const i of range(1, hypDim)) {
+      const [insCost, delCost, diagCost] = scoreFunc(ref[j - 1], hyp[i - 1]);
+      const insVal = scoreMatrix[i - 1][j] + insCost;
+      const delVal = scoreMatrix[i][j - 1] + delCost;
+      const diagVal = scoreMatrix[i - 1][j - 1] + diagCost;
+      const newVal = Math.min(insVal, delVal, diagVal);
+      scoreMatrix[i][j] = newVal;
+      if (backtraceMatrix) {
+        const posOps = [];
+        if (diagVal === newVal && diagCost <= 0) {
+          posOps.push("MATCH");
+        }
+        if (insVal === newVal) {
+          posOps.push("INSERT");
+        }
+        if (delVal === newVal) {
+          posOps.push("DELETE");
+        }
+        if (diagVal === newVal && diagCost > 0) {
+          posOps.push("SUBSTITUTE");
+        }
+        backtraceMatrix[i][j] = getOpTypeComboIndex(posOps);
+      }
+    }
+  }
+  if (backtraceMatrix) {
+    return { scoreMatrix, backtraceMatrix };
+  }
+  return scoreMatrix;
+}
+function computeLevenshteinDistanceMatrix(ref, hyp, backtrace = false) {
+  return computeDistanceMatrix(ref, hyp, getLevenshteinValues, backtrace);
+}
+function computeErrorAlignDistanceMatrix(ref, hyp, backtrace = false) {
+  return computeDistanceMatrix(ref, hyp, getErrorAlignValues, backtrace);
+}
+export {
+  computeDistanceMatrix,
+  computeErrorAlignDistanceMatrix,
+  computeLevenshteinDistanceMatrix
+};