@storyteller-platform/align 0.1.9 → 0.1.11

package/dist/errorAlign/hash.cjs

@@ -0,0 +1,173 @@
+"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 hash_exports = {};
+__export(hash_exports, {
+  hash: () => hash
+});
+module.exports = __toCommonJS(hash_exports);
+const MODULUS = (1n << 61n) - 1n;
+const UINT64_MASK = (1n << 64n) - 1n;
+const HASH_INF = 314159;
+const HASH_NAN = 0;
+const XX_PRIME_1 = 11400714785074694791n;
+const XX_PRIME_2 = 14029467366897019727n;
+const XX_PRIME_5 = 2870177450012600261n;
+function rotl64(v, s) {
+  return (v << s | v >> 64n - s) & UINT64_MASK;
+}
+function modpow(base, exp, mod) {
+  let result = 1n;
+  base %= mod;
+  while (exp > 0n) {
+    if (exp & 1n) result = result * base % mod;
+    base = base * base % mod;
+    exp >>= 1n;
+  }
+  return result;
+}
+function hashBigInt(n) {
+  const neg = n < 0n;
+  const x = (neg ? -n : n) % MODULUS;
+  const h = neg ? -Number(x) : Number(x);
+  return h === -1 ? -2 : h;
+}
+function hashFloat(x) {
+  if (isNaN(x)) return HASH_NAN;
+  if (!isFinite(x)) return x > 0 ? HASH_INF : -HASH_INF;
+  if (x === 0) return 0;
+  const buf = new ArrayBuffer(8);
+  const dv = new DataView(buf);
+  dv.setFloat64(0, x);
+  const hi = dv.getUint32(0);
+  const lo = dv.getUint32(4);
+  const sign = hi >>> 31 ? -1 : 1;
+  const biasedExp = hi >>> 20 & 2047;
+  const mantHi = hi & 1048575;
+  let m;
+  let e;
+  if (biasedExp === 0) {
+    m = BigInt(mantHi) << 32n | BigInt(lo);
+    e = 1 - 1023 - 52;
+  } else {
+    m = 1n << 52n | BigInt(mantHi) << 32n | BigInt(lo);
+    e = biasedExp - 1023 - 52;
+  }
+  const eMod = (BigInt(e) % 61n + 61n) % 61n;
+  const h = m % MODULUS * modpow(2n, eMod, MODULUS) % MODULUS;
+  const r = sign * Number(h);
+  return r === -1 ? -2 : r;
+}
+function sipRound(v) {
+  v[0] = v[0] + v[1] & UINT64_MASK;
+  v[1] = rotl64(v[1], 13n) ^ v[0];
+  v[0] = rotl64(v[0], 32n);
+  v[2] = v[2] + v[3] & UINT64_MASK;
+  v[3] = rotl64(v[3], 16n) ^ v[2];
+  v[0] = v[0] + v[3] & UINT64_MASK;
+  v[3] = rotl64(v[3], 21n) ^ v[0];
+  v[2] = v[2] + v[1] & UINT64_MASK;
+  v[1] = rotl64(v[1], 17n) ^ v[2];
+  v[2] = rotl64(v[2], 32n);
+}
+function siphash13(bytes, k0 = 0n, k1 = 0n) {
+  const v = [
+    k0 ^ 0x736f6d6570736575n,
+    k1 ^ 0x646f72616e646f6dn,
+    k0 ^ 0x6c7967656e657261n,
+    k1 ^ 0x7465646279746573n
+  ];
+  const blocks = Math.floor(bytes.length / 8);
+  for (let i = 0; i < blocks; i++) {
+    let m = 0n;
+    for (let j = 0; j < 8; j++) m |= BigInt(bytes[i * 8 + j]) << BigInt(j * 8);
+    v[3] ^= m;
+    sipRound(v);
+    v[0] ^= m;
+  }
+  const rem = bytes.length % 8;
+  const base = blocks * 8;
+  let last = BigInt(bytes.length & 255) << 56n;
+  for (let i = 0; i < rem; i++)
+    last |= BigInt(bytes[base + i]) << BigInt(i * 8);
+  v[3] ^= last;
+  sipRound(v);
+  v[0] ^= last;
+  v[2] ^= 0xffn;
+  sipRound(v);
+  sipRound(v);
+  sipRound(v);
+  return (v[0] ^ v[1] ^ v[2] ^ v[3]) & UINT64_MASK;
+}
+function encodeString(s) {
+  const codePoints = [...s].map((c) => c.codePointAt(0));
+  const maxCp = codePoints.reduce((m, cp) => cp > m ? cp : m, 0);
+  if (maxCp <= 255) {
+    return new Uint8Array(codePoints);
+  }
+  const bpc = maxCp <= 65535 ? 2 : 4;
+  const buf = new Uint8Array(codePoints.length * bpc);
+  const dv = new DataView(buf.buffer);
+  codePoints.forEach((cp, i) => {
+    if (bpc === 2) dv.setUint16(
+      i * 2,
+      cp,
+      /*LE*/
+      true
+    );
+    else dv.setUint32(
+      i * 4,
+      cp,
+      /*LE*/
+      true
+    );
+  });
+  return buf;
+}
+function hashString(s) {
+  const raw = siphash13(encodeString(s));
+  const signed = raw > 0x7fffffffffffffffn ? Number(raw - (1n << 64n)) : Number(raw);
+  return signed === -1 ? -2 : signed;
+}
+function hashTuple(items) {
+  let acc = XX_PRIME_5;
+  for (const item of items) {
+    const h = hash(item);
+    const lane = h < 0 ? BigInt(h) + (1n << 64n) : BigInt(h);
+    acc = acc + lane * XX_PRIME_2 & UINT64_MASK;
+    acc = rotl64(acc, 31n);
+    acc = acc * XX_PRIME_1 & UINT64_MASK;
+  }
+  acc = acc + (BigInt(items.length) ^ (XX_PRIME_5 ^ 3527539n)) & UINT64_MASK;
+  if (acc === UINT64_MASK) return 1546275796;
+  const signed = acc > 0x7fffffffffffffffn ? Number(acc - (1n << 64n)) : Number(acc);
+  return signed === -1 ? -2 : signed;
+}
+function hash(value) {
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (typeof value === "number")
+    return Number.isInteger(value) ? hashBigInt(BigInt(value)) : hashFloat(value);
+  if (typeof value === "bigint") return hashBigInt(value);
+  if (typeof value === "string") return hashString(value);
+  if (Array.isArray(value)) return hashTuple(value);
+  throw new TypeError(`unhashable type: ${typeof value}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hash
+});

package/dist/errorAlign/hash.d.cts

@@ -0,0 +1,28 @@
+/**
+ * TypeScript implementation of Python's built-in hash() function.
+ *
+ * Matches CPython for:
+ *   • int / bigint  — exact
+ *   • float         — exact
+ *   • bool          — exact  (True → 1, False → 0)
+ *   • str           — exact when PYTHONHASHSEED=0; Python randomises by default
+ *   • tuple         — exact, CPython 3.8+ xxHash-based algorithm
+ *                     (pass a readonly array to represent a tuple)
+ *
+ * hash(None) is intentionally unsupported: Python derives it from object
+ * identity (memory address), which cannot be replicated portably.
+ */
+type Hashable = number | bigint | string | boolean | readonly Hashable[];
+/**
+ * Compute Python's `hash()` for the given value.
+ *
+ * Supports: `boolean`, `number` (int & float), `bigint`, `string`, and tuples
+ * (represented as `readonly` arrays).
+ *
+ * **String hashing** is deterministic only when `PYTHONHASHSEED=0`.
+ * Python randomises string hashes by default, so results will differ from a
+ * live Python session unless you `export PYTHONHASHSEED=0` before running it.
+ */
+declare function hash(value: Hashable): number;
+
+export { type Hashable, hash };

package/dist/errorAlign/hash.d.ts

@@ -0,0 +1,28 @@
+/**
+ * TypeScript implementation of Python's built-in hash() function.
+ *
+ * Matches CPython for:
+ *   • int / bigint  — exact
+ *   • float         — exact
+ *   • bool          — exact  (True → 1, False → 0)
+ *   • str           — exact when PYTHONHASHSEED=0; Python randomises by default
+ *   • tuple         — exact, CPython 3.8+ xxHash-based algorithm
+ *                     (pass a readonly array to represent a tuple)
+ *
+ * hash(None) is intentionally unsupported: Python derives it from object
+ * identity (memory address), which cannot be replicated portably.
+ */
+type Hashable = number | bigint | string | boolean | readonly Hashable[];
+/**
+ * Compute Python's `hash()` for the given value.
+ *
+ * Supports: `boolean`, `number` (int & float), `bigint`, `string`, and tuples
+ * (represented as `readonly` arrays).
+ *
+ * **String hashing** is deterministic only when `PYTHONHASHSEED=0`.
+ * Python randomises string hashes by default, so results will differ from a
+ * live Python session unless you `export PYTHONHASHSEED=0` before running it.
+ */
+declare function hash(value: Hashable): number;
+
+export { type Hashable, hash };

package/dist/errorAlign/hash.js

@@ -0,0 +1,150 @@
+import "../chunk-BIEQXUOY.js";
+const MODULUS = (1n << 61n) - 1n;
+const UINT64_MASK = (1n << 64n) - 1n;
+const HASH_INF = 314159;
+const HASH_NAN = 0;
+const XX_PRIME_1 = 11400714785074694791n;
+const XX_PRIME_2 = 14029467366897019727n;
+const XX_PRIME_5 = 2870177450012600261n;
+function rotl64(v, s) {
+  return (v << s | v >> 64n - s) & UINT64_MASK;
+}
+function modpow(base, exp, mod) {
+  let result = 1n;
+  base %= mod;
+  while (exp > 0n) {
+    if (exp & 1n) result = result * base % mod;
+    base = base * base % mod;
+    exp >>= 1n;
+  }
+  return result;
+}
+function hashBigInt(n) {
+  const neg = n < 0n;
+  const x = (neg ? -n : n) % MODULUS;
+  const h = neg ? -Number(x) : Number(x);
+  return h === -1 ? -2 : h;
+}
+function hashFloat(x) {
+  if (isNaN(x)) return HASH_NAN;
+  if (!isFinite(x)) return x > 0 ? HASH_INF : -HASH_INF;
+  if (x === 0) return 0;
+  const buf = new ArrayBuffer(8);
+  const dv = new DataView(buf);
+  dv.setFloat64(0, x);
+  const hi = dv.getUint32(0);
+  const lo = dv.getUint32(4);
+  const sign = hi >>> 31 ? -1 : 1;
+  const biasedExp = hi >>> 20 & 2047;
+  const mantHi = hi & 1048575;
+  let m;
+  let e;
+  if (biasedExp === 0) {
+    m = BigInt(mantHi) << 32n | BigInt(lo);
+    e = 1 - 1023 - 52;
+  } else {
+    m = 1n << 52n | BigInt(mantHi) << 32n | BigInt(lo);
+    e = biasedExp - 1023 - 52;
+  }
+  const eMod = (BigInt(e) % 61n + 61n) % 61n;
+  const h = m % MODULUS * modpow(2n, eMod, MODULUS) % MODULUS;
+  const r = sign * Number(h);
+  return r === -1 ? -2 : r;
+}
+function sipRound(v) {
+  v[0] = v[0] + v[1] & UINT64_MASK;
+  v[1] = rotl64(v[1], 13n) ^ v[0];
+  v[0] = rotl64(v[0], 32n);
+  v[2] = v[2] + v[3] & UINT64_MASK;
+  v[3] = rotl64(v[3], 16n) ^ v[2];
+  v[0] = v[0] + v[3] & UINT64_MASK;
+  v[3] = rotl64(v[3], 21n) ^ v[0];
+  v[2] = v[2] + v[1] & UINT64_MASK;
+  v[1] = rotl64(v[1], 17n) ^ v[2];
+  v[2] = rotl64(v[2], 32n);
+}
+function siphash13(bytes, k0 = 0n, k1 = 0n) {
+  const v = [
+    k0 ^ 0x736f6d6570736575n,
+    k1 ^ 0x646f72616e646f6dn,
+    k0 ^ 0x6c7967656e657261n,
+    k1 ^ 0x7465646279746573n
+  ];
+  const blocks = Math.floor(bytes.length / 8);
+  for (let i = 0; i < blocks; i++) {
+    let m = 0n;
+    for (let j = 0; j < 8; j++) m |= BigInt(bytes[i * 8 + j]) << BigInt(j * 8);
+    v[3] ^= m;
+    sipRound(v);
+    v[0] ^= m;
+  }
+  const rem = bytes.length % 8;
+  const base = blocks * 8;
+  let last = BigInt(bytes.length & 255) << 56n;
+  for (let i = 0; i < rem; i++)
+    last |= BigInt(bytes[base + i]) << BigInt(i * 8);
+  v[3] ^= last;
+  sipRound(v);
+  v[0] ^= last;
+  v[2] ^= 0xffn;
+  sipRound(v);
+  sipRound(v);
+  sipRound(v);
+  return (v[0] ^ v[1] ^ v[2] ^ v[3]) & UINT64_MASK;
+}
+function encodeString(s) {
+  const codePoints = [...s].map((c) => c.codePointAt(0));
+  const maxCp = codePoints.reduce((m, cp) => cp > m ? cp : m, 0);
+  if (maxCp <= 255) {
+    return new Uint8Array(codePoints);
+  }
+  const bpc = maxCp <= 65535 ? 2 : 4;
+  const buf = new Uint8Array(codePoints.length * bpc);
+  const dv = new DataView(buf.buffer);
+  codePoints.forEach((cp, i) => {
+    if (bpc === 2) dv.setUint16(
+      i * 2,
+      cp,
+      /*LE*/
+      true
+    );
+    else dv.setUint32(
+      i * 4,
+      cp,
+      /*LE*/
+      true
+    );
+  });
+  return buf;
+}
+function hashString(s) {
+  const raw = siphash13(encodeString(s));
+  const signed = raw > 0x7fffffffffffffffn ? Number(raw - (1n << 64n)) : Number(raw);
+  return signed === -1 ? -2 : signed;
+}
+function hashTuple(items) {
+  let acc = XX_PRIME_5;
+  for (const item of items) {
+    const h = hash(item);
+    const lane = h < 0 ? BigInt(h) + (1n << 64n) : BigInt(h);
+    acc = acc + lane * XX_PRIME_2 & UINT64_MASK;
+    acc = rotl64(acc, 31n);
+    acc = acc * XX_PRIME_1 & UINT64_MASK;
+  }
+  acc = acc + (BigInt(items.length) ^ (XX_PRIME_5 ^ 3527539n)) & UINT64_MASK;
+  if (acc === UINT64_MASK) return 1546275796;
+  const signed = acc > 0x7fffffffffffffffn ? Number(acc - (1n << 64n)) : Number(acc);
+  return signed === -1 ? -2 : signed;
+}
+function hash(value) {
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (typeof value === "number")
+    return Number.isInteger(value) ? hashBigInt(BigInt(value)) : hashFloat(value);
+  if (typeof value === "bigint") return hashBigInt(value);
+  if (typeof value === "string") return hashString(value);
+  if (Array.isArray(value)) return hashTuple(value);
+  throw new TypeError(`unhashable type: ${typeof value}`);
+}
+export {
+  hash
+};

package/dist/errorAlign/native.cjs

@@ -0,0 +1,60 @@
+"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 __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 __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var native_exports = {};
+__export(native_exports, {
+  computeErrorAlignDistanceMatrix: () => computeErrorAlignDistanceMatrix,
+  computeLevenshteinDistanceMatrix: () => computeLevenshteinDistanceMatrix,
+  errorAlignBeamSearch: () => errorAlignBeamSearch
+});
+module.exports = __toCommonJS(native_exports);
+var import_node_path = require("node:path");
+var import_node_gyp_build = __toESM(require("node-gyp-build"), 1);
+var import_beamSearch = require("./beamSearch.cjs");
+const import_meta = {};
+const native = (0, import_node_gyp_build.default)(
+  process.env["ERROR_ALIGN_NATIVE_BINDING"] || (0, import_node_path.resolve)(import_meta.dirname, "../../")
+);
+function computeLevenshteinDistanceMatrix(ref, hyp, backtrace = false) {
+  return native.computeLevenshteinDistanceMatrix(ref, hyp, backtrace);
+}
+function computeErrorAlignDistanceMatrix(ref, hyp, backtrace = false) {
+  return native.computeErrorAlignDistanceMatrix(ref, hyp, backtrace);
+}
+function errorAlignBeamSearch(src, beamSize = 100) {
+  const endIndices = native.errorAlignBeamSearch(src, beamSize);
+  const path = new import_beamSearch.Path(src);
+  path.endIndices = endIndices;
+  return path;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computeErrorAlignDistanceMatrix,
+  computeLevenshteinDistanceMatrix,
+  errorAlignBeamSearch
+});

package/dist/errorAlign/native.d.cts

@@ -0,0 +1,18 @@
+import { Path } from './beamSearch.cjs';
+import { SubgraphMetadata } from './graphMetadata.cjs';
+import './backtraceGraph.cjs';
+import './utils.cjs';
+
+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[][];
+};
+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[][];
+};
+declare function errorAlignBeamSearch(src: SubgraphMetadata, beamSize?: number): Path;
+
+export { computeErrorAlignDistanceMatrix, computeLevenshteinDistanceMatrix, errorAlignBeamSearch };

package/dist/errorAlign/native.d.ts

@@ -0,0 +1,18 @@
+import { Path } from './beamSearch.js';
+import { SubgraphMetadata } from './graphMetadata.js';
+import './backtraceGraph.js';
+import './utils.js';
+
+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[][];
+};
+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[][];
+};
+declare function errorAlignBeamSearch(src: SubgraphMetadata, beamSize?: number): Path;
+
+export { computeErrorAlignDistanceMatrix, computeLevenshteinDistanceMatrix, errorAlignBeamSearch };

package/dist/errorAlign/native.js

@@ -0,0 +1,24 @@
+import "../chunk-BIEQXUOY.js";
+import { resolve } from "node:path";
+import requireBinding from "node-gyp-build";
+import { Path } from "./beamSearch.js";
+const native = requireBinding(
+  process.env["ERROR_ALIGN_NATIVE_BINDING"] || resolve(import.meta.dirname, "../../")
+);
+function computeLevenshteinDistanceMatrix(ref, hyp, backtrace = false) {
+  return native.computeLevenshteinDistanceMatrix(ref, hyp, backtrace);
+}
+function computeErrorAlignDistanceMatrix(ref, hyp, backtrace = false) {
+  return native.computeErrorAlignDistanceMatrix(ref, hyp, backtrace);
+}
+function errorAlignBeamSearch(src, beamSize = 100) {
+  const endIndices = native.errorAlignBeamSearch(src, beamSize);
+  const path = new Path(src);
+  path.endIndices = endIndices;
+  return path;
+}
+export {
+  computeErrorAlignDistanceMatrix,
+  computeLevenshteinDistanceMatrix,
+  errorAlignBeamSearch
+};

package/dist/errorAlign/node-gyp-build.d.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/errorAlign/node-gyp-build.d.d.cts

@@ -0,0 +1,3 @@
+declare module "node-gyp-build" {
+  export default function requireBinding(dirname: string): unknown
+}

package/dist/errorAlign/node-gyp-build.d.d.ts

@@ -0,0 +1,3 @@
+declare module "node-gyp-build" {
+  export default function requireBinding(dirname: string): unknown
+}

package/dist/errorAlign/pathToAlignment.cjs

@@ -0,0 +1,122 @@
+"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 __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 __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pathToAlignment_exports = {};
+__export(pathToAlignment_exports, {
+  getAlignments: () => getAlignments
+});
+module.exports = __toCommonJS(pathToAlignment_exports);
+var import_node_assert = __toESM(require("node:assert"), 1);
+var import_utils = require("./utils.cjs");
+function getDeleteAlignment(startRefIndex, endRefIndex, subgraphMetadata) {
+  const refSlice = (0, import_utils.translateSlice)(
+    [startRefIndex, endRefIndex],
+    subgraphMetadata.refIndexMap
+  );
+  (0, import_node_assert.default)(!!refSlice);
+  return new import_utils.Alignment(
+    "DELETE",
+    refSlice,
+    null,
+    subgraphMetadata.refRaw.slice(...refSlice)
+  );
+}
+function getInsertAlignment(startHypIndex, endHypIndex, subgraphMetadata) {
+  const hypSlice = (0, import_utils.translateSlice)(
+    [startHypIndex, endHypIndex],
+    subgraphMetadata.hypIndexMap
+  );
+  (0, import_node_assert.default)(!!hypSlice);
+  return new import_utils.Alignment(
+    "INSERT",
+    null,
+    hypSlice,
+    null,
+    subgraphMetadata.hypRaw.slice(...hypSlice),
+    subgraphMetadata.hypIndexMap[startHypIndex] >= 0,
+    subgraphMetadata.hypIndexMap[endHypIndex - 1] >= 0
+  );
+}
+function getMatchOrSubstitutionAlignment(startHypIndex, endHypIndex, startRefIndex, endRefIndex, score, subgraphMetadata) {
+  const hypSlice = (0, import_utils.translateSlice)(
+    [startHypIndex, endHypIndex],
+    subgraphMetadata.hypIndexMap
+  );
+  const refSlice = (0, import_utils.translateSlice)(
+    [startRefIndex, endRefIndex],
+    subgraphMetadata.refIndexMap
+  );
+  (0, import_node_assert.default)(!!hypSlice);
+  (0, import_node_assert.default)(!!refSlice);
+  const isMatchSegment = score === 0;
+  const opType = isMatchSegment ? "MATCH" : "SUBSTITUTE";
+  return new import_utils.Alignment(
+    opType,
+    refSlice,
+    hypSlice,
+    subgraphMetadata.refRaw.slice(...refSlice),
+    subgraphMetadata.hypRaw.slice(...hypSlice),
+    subgraphMetadata.hypIndexMap[startHypIndex] >= 0,
+    subgraphMetadata.hypIndexMap[endHypIndex - 1] >= 0
+  );
+}
+function getAlignments(path) {
+  const subgraphMetadata = path.src;
+  const segmentationIndices = path.endIndices;
+  const alignments = [];
+  let startHyp = 0;
+  let startRef = 0;
+  for (let [endHyp, endRef, score] of segmentationIndices) {
+    endHyp += 1;
+    endRef += 1;
+    if (startHyp === endHyp) {
+      const alignment = getDeleteAlignment(startRef, endRef, subgraphMetadata);
+      alignments.push(alignment);
+    } else if (startRef === endRef) {
+      const alignment = getInsertAlignment(startHyp, endHyp, subgraphMetadata);
+      alignments.push(alignment);
+    } else {
+      const alignment = getMatchOrSubstitutionAlignment(
+        startHyp,
+        endHyp,
+        startRef,
+        endRef,
+        score,
+        subgraphMetadata
+      );
+      alignments.push(alignment);
+    }
+    startHyp = endHyp;
+    startRef = endRef;
+  }
+  return alignments;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAlignments
+});

package/dist/errorAlign/pathToAlignment.d.cts

@@ -0,0 +1,11 @@
+import { Path } from './beamSearch.cjs';
+import { Alignment } from './utils.cjs';
+import './backtraceGraph.cjs';
+import './graphMetadata.cjs';
+
+/**
+ * Get the alignments of the path.
+ */
+declare function getAlignments(path: Path): Alignment[];
+
+export { getAlignments };

package/dist/errorAlign/pathToAlignment.d.ts

@@ -0,0 +1,11 @@
+import { Path } from './beamSearch.js';
+import { Alignment } from './utils.js';
+import './backtraceGraph.js';
+import './graphMetadata.js';
+
+/**
+ * Get the alignments of the path.
+ */
+declare function getAlignments(path: Path): Alignment[];
+
+export { getAlignments };