{"version":3,"sources":["../src/index.ts","../src/utils/matrixLike.ts","../src/utils/matrix.ts","../src/helpers.ts","../src/utils/is.ts","../src/utils/inspectNumeric.ts","../src/core/big/utils.ts","../src/core/shared.ts","../src/core/big/munkresB.ts","../src/core/big/munkres.ts","../src/core/num/utils.ts","../src/core/num/munkresB.ts","../src/core/num/munkres.ts","../src/core/inf/munkresB.ts","../src/core/inf/munkres.ts","../src/core/munkres.ts","../src/utils/arrayLike.ts","../src/utils/matching.ts","../src/munkres.ts"],"sourcesContent":["// Types\nexport type { Matrix } from \"./types/matrix.ts\";\nexport type { MatrixLike } from \"./types/matrixLike.ts\";\nexport type { MunkresOptions } from \"./types/munkresOptions.ts\";\nexport type { Pair } from \"./types/pair.ts\";\n\n// Cost Matrix Helpers\nexport {\n  copyMatrix,\n  createMatrix,\n  genMatrix,\n  getMatrixMax,\n  getMatrixMin,\n  invertMatrix,\n  negateMatrix,\n} from \"./helpers.ts\";\n\n// Algorithm\nexport { munkres } from \"./munkres.ts\";\n\n// Default\nimport { munkres } from \"./munkres.ts\";\nexport default munkres;\n","import type { MatrixLike } from \"../types/matrixLike.ts\";\n\n/**\n * Finds the maximum value in a given matrix.\n *\n * @param matrix - The matrix.\n *\n * @returns The maximum value, or `undefined` if the matrix is empty.\n *\n * @example\n * const matrix = [\n *   [1, 3, 2],\n *   [4, 0, 6],\n *   [7, 5, 8]\n * ];\n * console.log(getMax(matrix)); // Output: 8\n *\n * @example\n * const matrix = [\n *   [1n, 3n, 2n],\n *   [4n, 0n, 6n],\n *   [7n, 5n, 8n]\n * ];\n * console.log(getMax(matrix)); // Output: 8n\n *\n * @example\n * const matrix = [\n *   ['b', 'd', 'c'],\n *   ['e', 'a', 'g'],\n *   ['h', 'f', 'i']\n * ];\n * console.log(getMax(matrix)); // Output: 'i'\n */\nexport function getMax(matrix: MatrixLike<number>): number | undefined;\nexport function getMax(matrix: MatrixLike<bigint>): bigint | undefined;\nexport function getMax(matrix: MatrixLike<string>): string | undefined;\nexport function getMax<T extends number | bigint | string>(\n  matrix: MatrixLike<T>,\n): T | undefined {\n  const Y = matrix.length;\n  const X = matrix[0]?.length ?? 0;\n  if (Y <= 0 || X <= 0) {\n    return undefined;\n  }\n\n  let max = matrix[0][0];\n  for (let y = 0; y < Y; ++y) {\n    const row = matrix[y];\n    for (let x = 0; x < X; ++x) {\n      if (max < row[x]) {\n        max = row[x];\n      }\n    }\n  }\n\n  return max;\n}\n\n/**\n * Finds the minimum value in a given matrix.\n *\n * @param matrix - The matrix.\n *\n * @returns The minimum value, or `undefined` if the matrix is empty.\n *\n * @example\n * const matrix = [\n *   [1, 3, 2],\n *   [4, 0, 6],\n *   [7, 5, 8]\n * ];\n * console.log(getMin(matrix)); // Output: 0\n *\n * @example\n * const matrix = [\n *   [1n, 3n, 2n],\n *   [4n, 0n, 6n],\n *   [7n, 5n, 8n]\n * ];\n * console.log(getMin(matrix)); // Output: 0n\n *\n * @example\n * const matrix = [\n *   ['b', 'd', 'c'],\n *   ['e', 'a', 'g'],\n *   ['h', 'f', 'i']\n * ];\n * console.log(getMin(matrix)); // Output: 'a'\n */\nexport function getMin(matrix: MatrixLike<number>): number | undefined;\nexport function getMin(matrix: MatrixLike<bigint>): bigint | undefined;\nexport function getMin(matrix: MatrixLike<string>): string | undefined;\nexport function getMin<T extends number | bigint | string>(\n  matrix: MatrixLike<T>,\n): T | undefined {\n  const Y = matrix.length;\n  const X = matrix[0]?.length ?? 0;\n  if (Y <= 0 || X <= 0) {\n    return undefined;\n  }\n\n  let min = matrix[0][0];\n  for (let y = 0; y < Y; ++y) {\n    const row = matrix[y];\n    for (let x = 0; x < X; ++x) {\n      if (min > row[x]) {\n        min = row[x];\n      }\n    }\n  }\n\n  return min;\n}\n","import type { Matrix } from \"../types/matrix.ts\";\nimport type { MatrixLike } from \"../types/matrixLike.ts\";\n\nimport { getMax } from \"./matrixLike.ts\";\n\n/**\n * Creates a matrix with specified rows and columns.\n *\n * The callback function is called for every combination of elements from the\n * `rows` and `columns` arrays, receiving the current row and column elements\n * as arguments, and its return value is used to populate the matrix.\n *\n * @param rows - An array of row elements.\n * @param columns - An array of column elements.\n * @param callbackFn - A function that produces values for the new matrix,\n *                     taking a row element and a column element as arguments.\n *\n * @returns A matrix populated by the results of the `callbackFn` function.\n *\n * @example\n * const rows = [1, 2];\n * const cols = ['a', 'b', 'c'];\n * const callbackFn = (row, col) =\\> `${row}${col}`;\n *\n * const matrix = create(rows, cols, callbackFn);\n * // matrix is:\n * // [\n * //   ['1a', '1b', '1c'],\n * //   ['2a', '2b', '2c']\n * // ]\n */\nexport function create<R, C, T>(\n  rows: ArrayLike<R>,\n  columns: ArrayLike<C>,\n  callbackFn: (row: R, col: C) => T,\n): Matrix<T> {\n  const Y = rows.length;\n  const X = columns.length;\n  const mat = new Array<T[]>(Y);\n  for (let y = 0; y < Y; ++y) {\n    const row = new Array<T>(X);\n    for (let x = 0; x < X; ++x) {\n      row[x] = callbackFn(rows[y], columns[x]);\n    }\n    mat[y] = row;\n  }\n  return mat;\n}\n\n/**\n * Flips a matrix horizontally.\n *\n * After the flip, the element at position `[y][x]` moves to `[y][M-x-1]`,\n * where `M` is the number of columns in the matrix.\n *\n * @param matrix - The matrix to be flipped. Modified in place.\n *\n * @example\n * const matrix = [\n *   [1, 2, 3],\n *   [4, 5, 6],\n *   [7, 8, 9]\n * ];\n *\n * flipH(matrix);\n * // matrix is now:\n * // [\n * //   [3, 2, 1],\n * //   [6, 5, 4],\n * //   [9, 8, 7]\n * // ]\n */\nexport function flipH<T>(matrix: Matrix<T>): void {\n  const Y = matrix.length;\n  for (let y = 0; y < Y; ++y) {\n    matrix[y].reverse();\n  }\n}\n\n/**\n * Flips a matrix vertically.\n *\n * After the flip, the element at position `[y][x]` moves to `[N-y-1][x]`,\n * where `N` is the number of rows in the matrix.\n *\n * @param matrix - The matrix to be flipped. Modified in place.\n *\n * @example\n * const matrix = [\n *   [1, 2, 3],\n *   [4, 5, 6],\n *   [7, 8, 9]\n * ];\n *\n * flipV(matrix);\n * // matrix is now:\n * // [\n * //   [7, 8, 9],\n * //   [4, 5, 6],\n * //   [1, 2, 3]\n * // ]\n */\nexport function flipV<T>(matrix: Matrix<T>): void {\n  matrix.reverse();\n}\n\n/**\n * Creates a {@link Matrix} from a given {@link MatrixLike}.\n *\n * @param matrix - The matrix to be copied.\n *\n * @returns A copy of the given matrix.\n */\nexport function from<T>(matrix: MatrixLike<T>): Matrix<T> {\n  const Y = matrix.length;\n  const dupe: Matrix<T> = new Array(Y);\n  for (let y = 0; y < Y; ++y) {\n    const rowA = matrix[y];\n    const X = rowA.length;\n    const rowB = new Array(X);\n    for (let x = 0; x < X; ++x) {\n      rowB[x] = rowA[x];\n    }\n    dupe[y] = rowB;\n  }\n  return dupe;\n}\n\n/**\n * Generates a matrix with specified rows and columns.\n *\n * The callback function is called with every combination of row and column indices,\n * and its return value is used to populate the matrix.\n *\n * @param rows - The number of rows.\n * @param columns - The number of columns.\n * @param callbackFn - A function that produces values for the new matrix,\n *                     taking a row and column index as arguments.\n *\n * @returns A matrix populated by the results of the `callbackFn` function.\n *\n * @example\n * const rows = 2;\n * const cols = 3;\n * const callbackFn = (row, col) =\\> `(${row},${col})`;\n *\n * const matrix = create(rows, cols, callbackFn);\n * // matrix is:\n * // [\n * //   ['(0,0)', '(0,1)', '(0,2)'],\n * //   ['(1,0)', '(1,1)', '(1,2)']\n * // ]\n */\nexport function gen<T>(\n  rows: number,\n  cols: number,\n  callbackFn: (row: number, col: number) => T,\n): Matrix<T> {\n  const matrix: Matrix<T> = new Array(rows);\n\n  for (let r = 0; r < rows; ++r) {\n    const row = new Array<T>(cols);\n    for (let c = 0; c < cols; ++c) {\n      row[c] = callbackFn(r, c);\n    }\n    matrix[r] = row;\n  }\n\n  return matrix;\n}\n\n/**\n * Inverts the values in a given matrix by\n * subtracting each element from a given large value.\n *\n * @param matrix - The matrix to be inverted. Modified in place.\n * @param bigVal - (Optional) A large value used as the basis for inversion.\n * If not provided, uses the maximum value in the matrix.\n *\n * @example\n * const matrix = [\n *   [1, 2, 3],\n *   [4, 5, 6]\n * ];\n *\n * invert(matrix);\n * // matrix is now:\n * // [\n * //   [5, 4, 3],\n * //   [2, 1, 0]\n * // ]\n *\n * @example\n * const matrix = [\n *   [10, 20],\n *   [30, 40]\n * ];\n *\n * invert(matrix, 50);\n * // matrix is now:\n * // [\n * //   [40, 30],\n * //   [20, 10]\n * // ]\n */\nexport function invert(matrix: Matrix<number>, bigVal?: number): void;\nexport function invert(matrix: Matrix<bigint>, bigVal?: bigint): void;\nexport function invert<T extends number | bigint>(\n  matrix: Matrix<T>,\n  bigVal?: T,\n): void {\n  const Y = matrix.length;\n  const X = matrix[0]?.length ?? 0;\n  if (Y <= 0 || X <= 0) {\n    return undefined;\n  }\n\n  bigVal = bigVal ?? (getMax(matrix as Matrix<number>)! as T);\n  for (let y = 0; y < Y; ++y) {\n    const row = matrix[y];\n    for (let x = 0; x < X; ++x) {\n      row[x] = (bigVal - row[x]) as T;\n    }\n  }\n}\n\n/**\n * Calls a defined callback function on each element\n * of a matrix, and returns a new matrix of the results.\n *\n * @param matrix - The original matrix.\n * @param callbackfn - A function that accepts up to four arguments.\n * Will be called once per element in the matrix.\n *\n * @returns The result matrix.\n *\n * @example\n * const matrix = [\n *   [1, 3, 2],\n *   [4, 0, 6],\n *   [7, 5, 8]\n * ];\n * console.log(map(matrix, v =\\> v * v));\n * // Output: [\n * //   [ 1,  9,  4],\n * //   [16,  0, 36],\n * //   [49, 25, 64]\n * // ]\n */\nexport function map<T, R>(\n  matrix: MatrixLike<T>,\n  callbackFn: (value: T, y: number, x: number, mat: typeof matrix) => R,\n): Matrix<R> {\n  const Y = matrix.length;\n  const out: Matrix<R> = new Array(Y);\n  for (let y = 0; y < Y; ++y) {\n    const from = matrix[y];\n    const X = from.length;\n    const to = new Array(X);\n    for (let x = 0; x < X; ++x) {\n      to[x] = callbackFn(from[x], y, x, matrix);\n    }\n    out[y] = to;\n  }\n  return out;\n}\n\n/**\n * Negates the values in a given matrix.\n *\n * @param matrix - The matrix to be negated. Modified in place.\n *\n * @example\n * const matrix = [\n *   [1,  2, 3],\n *   [4, -5, 6],\n *   [7,  8, 9]\n * ];\n *\n * negate(matrix);\n * // matrix is now:\n * // [\n * //   [-1, -2, -3],\n * //   [-4,  5, -6],\n * //   [-7, -8, -9]\n * // ]\n */\nexport function negate(matrix: Matrix<number>): void;\nexport function negate(matrix: Matrix<bigint>): void;\nexport function negate(matrix: Matrix<number | bigint>): void;\nexport function negate<T extends number | bigint>(matrix: Matrix<T>): void {\n  const Y = matrix.length;\n  const X = matrix[0]?.length ?? 0;\n  for (let y = 0; y < Y; ++y) {\n    const row = matrix[y];\n    for (let x = 0; x < X; ++x) {\n      row[x] = -row[x] as T;\n    }\n  }\n}\n\n/**\n * Transpose a given matrix, switching its rows and columns.\n *\n * In the transposed matrix, the value originally at position [y][x]\n * moves to [x][y], effectively turning rows of the original matrix into\n * columns in the output matrix, and vice versa.\n *\n * @param matrix - The matrix to transpose. Modified in place.\n *\n * @example\n * // Transpose a 2x3 matrix to a 3x2 matrix\n * const original = [\n *   [1, 2, 3],\n *   [4, 5, 6]\n * ];\n *\n * transpose(original);\n * // transposed is now:\n * // [\n * //   [1, 4],\n * //   [2, 5],\n * //   [3, 6]\n * // ]\n */\nexport function transpose<T>(matrix: Matrix<T>): void {\n  const Y = matrix.length;\n  const X = matrix[0]?.length ?? 0;\n\n  // Transpose shared square\n  const N = Math.min(Y, X);\n  for (let y = 1; y < N; ++y) {\n    for (let x = 0; x < y; ++x) {\n      const temp = matrix[y][x];\n      matrix[y][x] = matrix[x][y];\n      matrix[x][y] = temp;\n    }\n  }\n\n  // Add columns\n  if (Y > X) {\n    for (let y = 0; y < X; ++y) {\n      const row = matrix[y];\n      row.length = Y;\n      for (let x = X; x < Y; ++x) {\n        row[x] = matrix[x][y];\n      }\n    }\n    matrix.length = X;\n  }\n\n  // Add rows\n  if (Y < X) {\n    matrix.length = X;\n    for (let y = Y; y < X; ++y) {\n      const row = new Array(Y);\n      for (let x = 0; x < Y; ++x) {\n        row[x] = matrix[x][y];\n      }\n      matrix[y] = row;\n    }\n    for (let y = 0; y < Y; ++y) {\n      matrix[y].length = Y;\n    }\n  }\n}\n","import type { Matrix } from \"./types/matrix.ts\";\nimport type { MatrixLike } from \"./types/matrixLike.ts\";\n\nimport { create, from, gen, invert, negate } from \"./utils/matrix.ts\";\nimport { getMax, getMin } from \"./utils/matrixLike.ts\";\n\n/**\n * Creates a copy from a given matrix or matrix-like input.\n *\n * @param matrix - The matrix to be copied.\n *\n * @returns A copy of the given matrix.\n */\nexport function copyMatrix<T>(matrix: MatrixLike<T>): Matrix<T> {\n  return from(matrix);\n}\n\n/**\n * Constructs a matrix from a set of row\n * and column objects using a provided callback function.\n *\n * @param rows - An array of row objects (such as workers).\n * @param cols - An array of column objects (such as jobs).\n * @param callbackFn - Given a row and a column, returns a value.\n *\n * @returns A matrix where the values at position `[r][c]`\n * represent the value derived from row `r` and column `c`.\n *\n * @example\n * ```typescript\n * // Define workers, jobs, and a simple cost function\n * const workers = ['Alice', 'Bob'];\n * const jobs = ['Job1', 'Job2'];\n * const costFn = (worker: string, job: string) => worker.length + job.length;\n *\n * // Create a cost matrix\n * const costs = createMatrix(workers, jobs, costFn);\n * // [\n * //   [9, 9], // ['Alice' + 'Job1', 'Alice' + 'Job2']\n * //   [7, 7]  // [  'Bob' + 'Job1',   'Bob' + 'Job2']\n * // ]\n * ```\n */\nexport function createMatrix<R, C, T>(\n  rows: ArrayLike<R>,\n  cols: ArrayLike<C>,\n  callbackFn: (row: R, col: C) => T,\n): Matrix<T> {\n  return create(rows, cols, callbackFn);\n}\n\n/**\n * Constructs a matrix with given dimensions\n * using a provided callback function.\n *\n * @param rows - The number of rows in the matrix.\n * @param cols - The number of columns in the matrix.\n * @param callbackFn - Given row and column indices, returns a value.\n *\n * @returns A matrix where the values at position `[r][c]`\n * represent the value derived from row `r` and column `c`.\n *\n * @example\n * ```typescript\n * // Define workers, jobs, and a simple cost function\n * const workers = ['Alice', 'Bob'];\n * const jobs = ['Job1', 'Job2'];\n * const costFn = (w: number, j: number) => workers[w].length + jobs[j].length;\n *\n * // Create a cost matrix\n * const costs = createMatrix(workers.length, jobs.length, costFn);\n * // [\n * //   [9, 9], // ['Alice' + 'Job1', 'Alice' + 'Job2']\n * //   [7, 7]  // [  'Bob' + 'Job1',   'Bob' + 'Job2']\n * // ]\n * ```\n */\nexport function genMatrix<T>(\n  rows: number,\n  cols: number,\n  callbackFn: (row: number, col: number) => T,\n): Matrix<T> {\n  return gen(rows, cols, callbackFn);\n}\n\n/**\n * Finds the maximum value in a given matrix.\n *\n * @param matrix - The matrix.\n *\n * @returns The maximum value, or `undefined` if the matrix is empty.\n */\nexport function getMatrixMax(matrix: MatrixLike<number>): number | undefined;\nexport function getMatrixMax(matrix: MatrixLike<bigint>): bigint | undefined;\nexport function getMatrixMax<T extends number | bigint>(\n  matrix: MatrixLike<T>,\n): T | undefined {\n  return getMax(matrix as MatrixLike<number>) as T | undefined;\n}\n\n/**\n * Finds the minimum value in a given matrix.\n *\n * @param matrix - The matrix.\n *\n * @returns The minimum value, or `undefined` if the matrix is empty.\n */\nexport function getMatrixMin(matrix: MatrixLike<number>): number | undefined;\nexport function getMatrixMin(matrix: MatrixLike<bigint>): bigint | undefined;\nexport function getMatrixMin<T extends number | bigint>(\n  matrix: MatrixLike<T>,\n): T | undefined {\n  return getMin(matrix as MatrixLike<number>) as T | undefined;\n}\n\n/**\n * Inverts the values in a given matrix by\n * subtracting each element from a specified large value.\n *\n * This is useful for converting a profit matrix\n * into a cost matrix, or vice versa.\n *\n * @param matrix - The cost matrix to be inverted. Modified in place.\n * @param bigVal - (Optional) A large value used as the basis for inversion.\n * If not provided, the maximum value in the matrix is used.\n *\n * @example\n * const matrix = [\n *   [1, 2, 3],\n *   [4, 5, 6]\n * ];\n *\n * // Invert the matrix\n * invertMatrix(matrix);\n *\n * // matrix is now:\n * // [\n * //   [5, 4, 3],\n * //   [2, 1, 0]\n * // ]\n *\n * @example\n * const matrix = [\n *   [10, 20],\n *   [30, 40]\n * ];\n *\n * // Invert the matrix with a given bigVal\n * invertMatrix(matrix, 50);\n *\n * // matrix is now:\n * // [\n * //   [40, 30],\n * //   [20, 10]\n * // ]\n */\nexport function invertMatrix(matrix: Matrix<number>, bigVal?: number): void;\nexport function invertMatrix(matrix: Matrix<bigint>, bigVal?: bigint): void;\nexport function invertMatrix<T extends number | bigint>(\n  matrix: Matrix<T>,\n  bigVal?: T,\n): void {\n  invert(matrix as Matrix<number>, bigVal as number);\n}\n\n/**\n * Negates the values in a given matrix.\n *\n * This is useful for converting a profit matrix\n * into a cost matrix, or vice versa.\n *\n * @param matrix - The matrix to be negated. Modified in place.\n *\n * @example\n * const matrix = [\n *   [1,  2, 3],\n *   [4, -5, 6],\n *   [7,  8, 9]\n * ];\n *\n * // Negate the matrix\n * negateMatrix(matrix);\n *\n * // matrix is now:\n * // [\n * //   [-1, -2, -3],\n * //   [-4,  5, -6],\n * //   [-7, -8, -9]\n * // ]\n */\nexport function negateMatrix(matrix: Matrix<number>): void;\nexport function negateMatrix(matrix: Matrix<bigint>): void;\nexport function negateMatrix<T extends number | bigint>(\n  matrix: Matrix<T>,\n): void {\n  negate(matrix);\n}\n","/**\n * Checks if the given value is of type `bigint`.\n *\n * @param value - The value to check.\n *\n * @returns `true` if the value is of type `bigint`, `false` otherwise.\n *\n * @example\n * console.log(isBigInt(10n)); // true\n *\n * @example\n * console.log(isBigInt(10)); // false\n */\nexport function isBigInt(value: unknown): value is bigint {\n  return typeof value === \"bigint\";\n}\n","import type { MatrixLike } from \"../types/matrixLike.ts\";\nimport type { Pair } from \"../types/pair.ts\";\n\n/**\n * Result of inspecting a numeric matrix. Mutually exclusive variants on\n * `nanAt` / `infinityAt`:\n *\n *  - all-finite, non-empty  → `{ rangeMin, rangeMax }`\n *  - all-finite, empty      → `{}`\n *  - contains NaN           → `{ nanAt: [y, x] }`\n *  - contains Infinity      → `{ infinityAt: [y, x] }`\n *\n * NaN takes precedence: if both NaN and Infinity are present, only\n * `nanAt` is returned (the caller is expected to throw on NaN, so\n * Infinity coordinates are moot).\n *\n * `rangeMin` / `rangeMax` are present only in the all-finite non-empty\n * variant. They let the dispatcher enforce the overflow-safety bound\n * `max - min <= Number.MAX_VALUE / 2` (tightness verified via the Z3\n * SMT search in `scripts/overflow-smt-search.py`).\n *\n * CAUTION: `rangeMin` / `rangeMax` track finite cells ONLY. When\n * `infinityAt` is set they are partial (the min/max of the finite\n * subset, ignoring the Infinity cells) and for an all-Infinity matrix\n * they retain their sentinel init values (`rangeMin = +Infinity`,\n * `rangeMax = -Infinity`, so `rangeMax - rangeMin = -Infinity`).\n * Callers must branch on `infinityAt` before trusting the range — the\n * dispatcher does exactly this. See the INVARIANT comment in\n * `src/core/munkres.ts`.\n */\nexport type NumericInspection =\n  | {\n      nanAt?: never;\n      infinityAt?: Pair<number>;\n      rangeMin?: number;\n      rangeMax?: number;\n    }\n  | {\n      nanAt: Pair<number>;\n      infinityAt?: never;\n      rangeMin?: never;\n      rangeMax?: never;\n    };\n\n/**\n * Single-pass O(Y*X) scan of a numeric matrix. Returns the coordinates\n * of the first NaN encountered (in row-major order), or — if no NaN\n * exists — the first ±Infinity. For fully-finite non-empty matrices,\n * also reports the minimum and maximum finite values for downstream\n * range validation.\n */\nexport function inspectNumeric(matrix: MatrixLike<number>): NumericInspection {\n  const Y = matrix.length;\n  if (Y === 0) return {};\n  const X = matrix[0]?.length ?? 0;\n  if (X === 0) return {};\n\n  let infinityAt: Pair<number> | undefined;\n  let rangeMin = Infinity;\n  let rangeMax = -Infinity;\n  for (let y = 0; y < Y; ++y) {\n    const row = matrix[y];\n    for (let x = 0; x < X; ++x) {\n      const v = row[x];\n      if (v !== v) return { nanAt: [y, x] };\n      if (v === Infinity || v === -Infinity) {\n        if (!infinityAt) infinityAt = [y, x];\n        continue;\n      }\n      if (v < rangeMin) rangeMin = v;\n      if (v > rangeMax) rangeMax = v;\n    }\n  }\n  \n  return { infinityAt, rangeMin, rangeMax };\n}\n","// Bigint-typed array helpers for the bigint (`big`) solver.\n//\n// Split from the number copies in `../num/utils.ts` so each call site\n// stays monomorphic in V8's type feedback. See `../num/utils.ts` for the\n// full rationale.\n//\n// **Keep in sync with `../num/utils.ts`.** The bodies are identical;\n// only the element type differs.\nimport type { MutableArrayLike } from \"../../types/mutableArrayLike.ts\";\n\n/**\n * Find the minimum value in an array.\n *\n * @param array - An array.\n *\n * @returns The minimum value, or `undefined` if the array is empty.\n */\nexport function getMin(array: ArrayLike<bigint>): bigint | undefined {\n  const N = array.length;\n  if (N <= 0) {\n    return undefined;\n  }\n\n  let min = array[0];\n  for (let i = 1; i < N; ++i) {\n    if (min > array[i]) {\n      min = array[i];\n    }\n  }\n\n  return min;\n}\n\n/**\n * Partitions an array of indices based on the minimum value of the\n * indices in another array.\n *\n * @param indices - The array of indices to be partitioned. Modified in place.\n * @param values - The array from which index values are read.\n * @param min - The starting position in `indices` (inclusive). Defaults to 0.\n * @param max - The ending position in `indices` (exclusive). Defaults to `indices.length`.\n *\n * @returns The position one more than the partitioned portion of `indices`.\n */\nexport function partitionByMin(\n  indices: MutableArrayLike<number>,\n  values: ArrayLike<bigint>,\n  min = 0,\n  max = indices.length,\n): number {\n  let mid = min + 1;\n  let minIndex = indices[min];\n\n  for (let pos = mid; pos < max; ++pos) {\n    const index = indices[pos];\n    if (values[index] > values[minIndex]) {\n      continue;\n    }\n    if (values[index] < values[minIndex]) {\n      minIndex = index;\n      mid = min;\n    }\n    indices[pos] = indices[mid];\n    indices[mid++] = index;\n  }\n\n  return mid;\n}\n","import type { MutableArrayLike } from \"../types/mutableArrayLike.ts\";\n\n/**\n * Augments the current matching.\n *\n * This step effectively increases the number of matches (stars)\n * by 1, bringing the algorithm closer to an optimal assignment.\n *\n * Augmentation is performed by flipping matched and unmatched edges along\n * an augmenting path, starting from an unmatched node / edge and\n * continuing until no matched edge can be found.\n *\n * @param x - The starting node's column.\n * @param primeX - An array mapping primed columns to rows.\n * @param starsX - An array mapping star columns to row. Modified in place.\n * @param starsY - An array mapping star rows to columns. Modified in place.\n */\nexport function step5(\n  x: number,\n  primeX: ArrayLike<number>,\n  starsX: MutableArrayLike<number>,\n  starsY: MutableArrayLike<number>,\n): void {\n  do {\n    const y = primeX[x];\n    const sx = starsY[y];\n    starsX[x] = y;\n    starsY[y] = x;\n    x = sx;\n  } while (x !== -1);\n}\n\n/**\n * Augments the current matching.\n *\n * This step effectively increases the number of matches (stars)\n * by 1, bringing the algorithm closer to an optimal assignment.\n *\n * Augmentation is performed by flipping matched and unmatched edges along\n * an augmenting path, starting from an unmatched node / edge and\n * continuing until no matched edge can be found.\n *\n * @param y - The starting node's row.\n * @param primeY - An array mapping primed rows to columns.\n * @param starsX - An array mapping star columns to row. Modified in place.\n * @param starsY - An array mapping star rows to columns. Modified in place.\n */\nexport function step5B(\n  y: number,\n  primeY: ArrayLike<number>,\n  starsX: MutableArrayLike<number>,\n  starsY: MutableArrayLike<number>,\n): void {\n  do {\n    const x = primeY[y];\n    const sy = starsX[x];\n    starsX[x] = y;\n    starsY[y] = x;\n    y = sy;\n  } while (y !== -1);\n}\n","// Same algorithm as `../num/munkresB.ts`; keep the two in sync.\nimport type { MatrixLike } from \"../../types/matrixLike.ts\";\nimport type { MutableArrayLike } from \"../../types/mutableArrayLike.ts\";\n\nimport { partitionByMin } from \"./utils.ts\";\n\nimport { step5B } from \"../shared.ts\";\n\n/**\n * This step iteratively improves upon an initial matching until a complete\n * matching is found. This involves updating dual variables and managing\n * slack values to uncover new opportunities for optimal assignments.\n *\n * @param unmatched - The number of missing matches.\n * @param mat - An MxN cost matrix.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n * @param starsX - An array mapping star columns to row. Modified in place.\n * @param starsY - An array mapping star rows to columns. Modified in place.\n */\nexport function step4B(\n  unmatched: number,\n  matrix: MatrixLike<bigint>,\n  dualX: MutableArrayLike<bigint>,\n  dualY: MutableArrayLike<bigint>,\n  starsX: MutableArrayLike<number>,\n  starsY: MutableArrayLike<number>,\n): void {\n  // If no unmatched column\n  if (unmatched <= 0) {\n    return;\n  }\n\n  const Y = dualY.length;\n  const slack = new Uint32Array(Y);\n  const slackV = new Array<bigint>(Y);\n  const slackX = new Uint32Array(Y);\n\n  // Match unmatched columns\n  for (let x = 0; unmatched > 0; ++x) {\n    if (starsX[x] !== -1) {\n      continue;\n    }\n\n    const N = matchB(x, matrix, dualX, dualY, starsY, slack, slackV, slackX);\n    --unmatched;\n\n    // Update dual variables\n    step6B(x, N, dualX, dualY, slack, slackV, starsY);\n\n    // Update matching\n    step5B(slack[N - 1], slackX, starsX, starsY);\n  }\n}\n\n/**\n * Adjusts dual variables to uncover more admissible edges.\n *\n * @param x - The starting node's column.\n * @param N - The number of adjustments to make.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n * @param slack - An array of covered row indices.\n * @param slackV - The slack values for each row.\n * @param starsY - An array mapping star rows to columns.\n */\nexport function step6B(\n  x: number,\n  N: number,\n  dualX: MutableArrayLike<bigint>,\n  dualY: MutableArrayLike<bigint>,\n  slack: ArrayLike<number>,\n  slackV: ArrayLike<bigint>,\n  starsY: ArrayLike<number>,\n): void {\n  const sum = slackV[slack[N - 1]];\n\n  let min = sum;\n  for (let i = 0; i < N; ++i) {\n    const y = slack[i];\n    dualX[x] += min;\n    min = sum - slackV[y];\n    dualY[y] -= min;\n    x = starsY[y];\n  }\n}\n\n/**\n * Matches a given unmatched column to an unmatched row.\n *\n * @param x - An unmatched column.\n * @param matrix - An MxN cost matrix.\n * @param dualX - The dual variables for each matrix column.\n * @param dualY - The dual variables for each matrix row.\n * @param starsY - An array mapping star rows to columns.\n * @param slack - An array of covered row indices. Modified in place.\n * @param slackV - The slack values for each row. Modified in place.\n * @param slackX - An array mapping a slack row to column. Modified in place.\n */\nexport function matchB(\n  x: number,\n  matrix: MatrixLike<bigint>,\n  dualX: ArrayLike<bigint>,\n  dualY: ArrayLike<bigint>,\n  starsY: ArrayLike<number>,\n  slack: MutableArrayLike<number>,\n  slackV: MutableArrayLike<bigint>,\n  slackX: MutableArrayLike<number>,\n): number {\n  const Y = slack.length;\n\n  // Initialize slack\n  let dx = dualX[x];\n  for (let y = 0; y < Y; ++y) {\n    slack[y] = y;\n    slackV[y] = matrix[y][x] - dualY[y] - dx;\n    slackX[y] = x;\n  }\n\n  // Initialize zeros\n  let zeros = partitionByMin(slack, slackV, 0);\n  let zero = slackV[slack[0]];\n\n  // Grow a hungarian tree until an augmenting path is found\n  let steps = 1;\n  for (let y = slack[0]; starsY[y] !== -1; y = slack[steps++]) {\n    // Update slack\n    x = starsY[y];\n    dx = dualX[x] - zero;\n    for (let i = zeros; i < Y; ++i) {\n      y = slack[i];\n      const value = matrix[y][x] - dualY[y] - dx;\n      if (value >= slackV[y]) {\n        continue;\n      }\n      slackX[y] = x;\n      slackV[y] = value;\n      if (value === zero) {\n        slack[i] = slack[zeros];\n        slack[zeros++] = y;\n      }\n    }\n\n    // Update zeros\n    if (steps >= zeros) {\n      zeros = partitionByMin(slack, slackV, zeros);\n      zero = slackV[slack[steps]];\n    }\n  }\n\n  return steps;\n}\n","// Same algorithm as `../num/munkres.ts`; keep the two in sync.\nimport type { MatrixLike } from \"../../types/matrixLike.ts\";\nimport type { Matching } from \"../../types/matching.ts\";\nimport type { MutableArrayLike } from \"../../types/mutableArrayLike.ts\";\n\nimport { getMin, partitionByMin } from \"./utils.ts\";\n\nimport { step4B } from \"./munkresB.ts\";\nimport { step5 } from \"../shared.ts\";\n\nexport function exec(matrix: MatrixLike<bigint>): Matching<bigint> {\n  // Get dimensions\n  const Y = matrix.length;\n  const X = matrix[0]?.length ?? 0;\n\n  // Check if empty matrix\n  if (Y <= 0 || X <= 0) {\n    return { dualX: [], dualY: [], matrix, starsX: [], starsY: [] };\n  }\n\n  // Step 1: Reduce\n  const dualX = new Array<bigint>(X);\n  const dualY = new Array<bigint>(Y);\n  step1(matrix, dualX, dualY);\n\n  // Steps 2 & 3: Find initial matching\n  const starsX = new Array<number>(X).fill(-1);\n  const starsY = new Array<number>(Y).fill(-1);\n  const stars = steps2To3(matrix, dualX, dualY, starsX, starsY);\n\n  // Step 4: Find complete matching\n  if (Y <= X) {\n    step4(Y - stars, matrix, dualX, dualY, starsX, starsY);\n  } else {\n    step4B(X - stars, matrix, dualX, dualY, starsX, starsY);\n  }\n\n  // Return matching\n  return { dualX, dualY, matrix, starsX, starsY };\n}\n\n/**\n * Initializes the dual variables for the Munkres algorithm.\n *\n * This is a preprocessing step that effectively performs\n * row-wise and column-wise reductions on the cost matrix. This\n * helps find an initial matching and improves the efficiency\n * of subsequent steps.\n *\n * @param matrix - The cost matrix.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n */\nexport function step1(\n  matrix: MatrixLike<bigint>,\n  dualX: MutableArrayLike<bigint>,\n  dualY: MutableArrayLike<bigint>,\n): void {\n  const X = dualX.length;\n  const Y = dualY.length;\n\n  // If matrix is tall, skip row reduction\n  if (Y > X) {\n    dualY.fill(0n);\n  } else {\n    // Reduce rows\n    for (let y = 0; y < Y; ++y) {\n      dualY[y] = getMin(matrix[y])!;\n    }\n  }\n\n  // If matrix is wide, skip column reduction\n  if (Y < X) {\n    dualX.fill(0n);\n    return;\n  }\n\n  // Initialize dualX\n  let dy = dualY[0];\n  let row = matrix[0];\n  for (let x = 0; x < X; ++x) {\n    dualX[x] = row[x] - dy;\n  }\n\n  // Reduce columns\n  for (let y = 1; y < Y; ++y) {\n    dy = dualY[y];\n    row = matrix[y];\n    for (let x = 0; x < X; ++x) {\n      const dx = row[x] - dy;\n      if (dx < dualX[x]) {\n        dualX[x] = dx;\n      }\n    }\n  }\n}\n\n/**\n * Finds an initial matching for the munkres algorithm.\n *\n * @param matrix - The cost matrix.\n * @param dualX - The dual variables for each matrix column.\n * @param dualY - The dual variables for each matrix row.\n * @param starsX - An array mapping star columns to row. Modified in place.\n * @param starsY - An array mapping star rows to columns. Modified in place.\n *\n * @returns The number of matches (stars) found.\n */\nexport function steps2To3(\n  matrix: MatrixLike<bigint>,\n  dualX: ArrayLike<bigint>,\n  dualY: ArrayLike<bigint>,\n  starsX: MutableArrayLike<number>,\n  starsY: MutableArrayLike<number>,\n): number {\n  const X = dualX.length;\n  const Y = dualY.length;\n  const S = Y <= X ? Y : X;\n\n  let stars = 0;\n  for (let y = 0; y < Y && stars < S; ++y) {\n    const dy = dualY[y];\n    const row = matrix[y];\n    for (let x = 0; x < X; ++x) {\n      if (starsX[x] === -1 && dy === row[x] - dualX[x]) {\n        starsX[x] = y;\n        starsY[y] = x;\n        ++stars;\n        break;\n      }\n    }\n  }\n\n  return stars;\n}\n\n/**\n * This step iteratively improves upon an initial matching until a complete\n * matching is found. This involves updating dual variables and managing\n * slack values to uncover new opportunities for optimal assignments.\n *\n * @param unmatched - The number of missing matches.\n * @param mat - An MxN cost matrix.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n * @param starsX - An array mapping star columns to row. Modified in place.\n * @param starsY - An array mapping star rows to columns. Modified in place.\n */\nexport function step4(\n  unmatched: number,\n  matrix: MatrixLike<bigint>,\n  dualX: MutableArrayLike<bigint>,\n  dualY: MutableArrayLike<bigint>,\n  starsX: MutableArrayLike<number>,\n  starsY: MutableArrayLike<number>,\n): void {\n  // If no unmatched row\n  if (unmatched <= 0) {\n    return;\n  }\n\n  const X = dualX.length;\n  const slack = new Uint32Array(X);\n  const slackV = new Array<bigint>(X);\n  const slackY = new Uint32Array(X);\n\n  // Match unmatched rows\n  for (let y = 0; unmatched > 0; ++y) {\n    if (starsY[y] !== -1) {\n      continue;\n    }\n\n    const N = match(y, matrix, dualX, dualY, starsX, slack, slackV, slackY);\n    --unmatched;\n\n    // Update dual variables\n    step6(y, N, dualX, dualY, slack, slackV, starsX);\n\n    // Update matching\n    step5(slack[N - 1], slackY, starsX, starsY);\n  }\n}\n\n/**\n * Adjusts dual variables to uncover more admissible edges.\n *\n * @param y - The starting node's row.\n * @param N - The number of adjustments to make.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n * @param slack - An array of covered column indices.\n * @param slackV - The slack values for each column.\n * @param starsX - An array mapping star columns to row.\n */\nexport function step6(\n  y: number,\n  N: number,\n  dualX: MutableArrayLike<bigint>,\n  dualY: MutableArrayLike<bigint>,\n  slack: ArrayLike<number>,\n  slackV: ArrayLike<bigint>,\n  starsX: ArrayLike<number>,\n): void {\n  const sum = slackV[slack[--N]];\n  dualY[y] += sum;\n\n  for (let i = 0; i < N; ++i) {\n    const x = slack[i];\n    y = starsX[x];\n    const min = sum - slackV[x];\n    dualX[x] -= min;\n    dualY[y] += min;\n  }\n}\n\n/**\n * Matches a given unmatched row to an unmatched column.\n *\n * @param y - An unmatched row.\n * @param matrix - An MxN cost matrix.\n * @param dualX - The dual variables for each matrix column.\n * @param dualY - The dual variables for each matrix row.\n * @param starsX - An array mapping star columns to row.\n * @param slack - An array of covered column indices. Modified in place.\n * @param slackV - The slack values for each column. Modified in place.\n * @param slackY - An array mapping a slack column to row. Modified in place.\n */\nexport function match(\n  y: number,\n  matrix: MatrixLike<bigint>,\n  dualX: ArrayLike<bigint>,\n  dualY: ArrayLike<bigint>,\n  starsX: ArrayLike<number>,\n  slack: MutableArrayLike<number>,\n  slackV: MutableArrayLike<bigint>,\n  slackY: MutableArrayLike<number>,\n): number {\n  const X = slack.length;\n\n  // Initialize slack\n  let dy = dualY[y];\n  let row = matrix[y];\n  for (let x = 0; x < X; ++x) {\n    slack[x] = x;\n    slackV[x] = row[x] - dualX[x] - dy;\n    slackY[x] = y;\n  }\n\n  // Initialize zeros\n  let zeros = partitionByMin(slack, slackV, 0);\n  let zero = slackV[slack[0]];\n\n  // Grow a hungarian tree until an augmenting path is found\n  let steps = 1;\n  for (let x = slack[0]; starsX[x] !== -1; x = slack[steps++]) {\n    // Update slack\n    y = starsX[x];\n    dy = dualY[y] - zero;\n    row = matrix[y];\n    for (let i = zeros; i < X; ++i) {\n      x = slack[i];\n      const value = row[x] - dualX[x] - dy;\n      if (value >= slackV[x]) {\n        continue;\n      }\n      slackY[x] = y;\n      slackV[x] = value;\n      if (value === zero) {\n        slack[i] = slack[zeros];\n        slack[zeros++] = x;\n      }\n    }\n\n    // Update zeros\n    if (steps >= zeros) {\n      zeros = partitionByMin(slack, slackV, zeros);\n      zero = slackV[slack[steps]];\n    }\n  }\n\n  return steps;\n}\n","// Number-typed array helpers for the finite-number (`num`) and\n// Infinity-handling (`inf`) solvers, which are both `number`-typed.\n//\n// These are split from the bigint copies in `../big/utils.ts` so each\n// call site stays monomorphic in V8's type feedback. A single generic\n// shared by the number and bigint solvers would see both element types\n// at its comparison site and emit polymorphic code, measurably slowing\n// the number path once the same process also solves bigint matrices.\n// Same rationale as the solver split (see `../num/munkres.ts`).\n//\n// **Keep in sync with `../big/utils.ts`.** The bodies are identical;\n// only the element type differs.\nimport type { MutableArrayLike } from \"../../types/mutableArrayLike.ts\";\n\n/**\n * Find the minimum value in an array.\n *\n * @param array - An array.\n *\n * @returns The minimum value, or `undefined` if the array is empty.\n */\nexport function getMin(array: ArrayLike<number>): number | undefined {\n  const N = array.length;\n  if (N <= 0) {\n    return undefined;\n  }\n\n  let min = array[0];\n  for (let i = 1; i < N; ++i) {\n    if (min > array[i]) {\n      min = array[i];\n    }\n  }\n\n  return min;\n}\n\n/**\n * Partitions an array of indices based on the minimum value of the\n * indices in another array.\n *\n * @param indices - The array of indices to be partitioned. Modified in place.\n * @param values - The array from which index values are read.\n * @param min - The starting position in `indices` (inclusive). Defaults to 0.\n * @param max - The ending position in `indices` (exclusive). Defaults to `indices.length`.\n *\n * @returns The position one more than the partitioned portion of `indices`.\n */\nexport function partitionByMin(\n  indices: MutableArrayLike<number>,\n  values: ArrayLike<number>,\n  min = 0,\n  max = indices.length,\n): number {\n  let mid = min + 1;\n  let minIndex = indices[min];\n\n  for (let pos = mid; pos < max; ++pos) {\n    const index = indices[pos];\n    if (values[index] > values[minIndex]) {\n      continue;\n    }\n    if (values[index] < values[minIndex]) {\n      minIndex = index;\n      mid = min;\n    }\n    indices[pos] = indices[mid];\n    indices[mid++] = index;\n  }\n\n  return mid;\n}\n","// Same algorithm as `../big/munkresB.ts`; keep the two in sync.\nimport type { MatrixLike } from \"../../types/matrixLike.ts\";\nimport type { MutableArrayLike } from \"../../types/mutableArrayLike.ts\";\n\nimport { partitionByMin } from \"./utils.ts\";\n\nimport { step5B } from \"../shared.ts\";\n\n/**\n * This step iteratively improves upon an initial matching until a complete\n * matching is found. This involves updating dual variables and managing\n * slack values to uncover new opportunities for optimal assignments.\n *\n * @param unmatched - The number of missing matches.\n * @param mat - An MxN cost matrix.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n * @param starsX - An array mapping star columns to row. Modified in place.\n * @param starsY - An array mapping star rows to columns. Modified in place.\n */\nexport function step4B(\n  unmatched: number,\n  matrix: MatrixLike<number>,\n  dualX: MutableArrayLike<number>,\n  dualY: MutableArrayLike<number>,\n  starsX: MutableArrayLike<number>,\n  starsY: MutableArrayLike<number>,\n): void {\n  // If no unmatched column\n  if (unmatched <= 0) {\n    return;\n  }\n\n  const Y = dualY.length;\n  const slack = new Uint32Array(Y);\n  const slackV = new Array<number>(Y);\n  const slackX = new Uint32Array(Y);\n\n  // Match unmatched columns\n  for (let x = 0; unmatched > 0; ++x) {\n    if (starsX[x] !== -1) {\n      continue;\n    }\n\n    const N = matchB(x, matrix, dualX, dualY, starsY, slack, slackV, slackX);\n    --unmatched;\n\n    // Update dual variables\n    step6B(x, N, dualX, dualY, slack, slackV, starsY);\n\n    // Update matching\n    step5B(slack[N - 1], slackX, starsX, starsY);\n  }\n}\n\n/**\n * Adjusts dual variables to uncover more admissible edges.\n *\n * @param x - The starting node's column.\n * @param N - The number of adjustments to make.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n * @param slack - An array of covered row indices.\n * @param slackV - The slack values for each row.\n * @param starsY - An array mapping star rows to columns.\n */\nexport function step6B(\n  x: number,\n  N: number,\n  dualX: MutableArrayLike<number>,\n  dualY: MutableArrayLike<number>,\n  slack: ArrayLike<number>,\n  slackV: ArrayLike<number>,\n  starsY: ArrayLike<number>,\n): void {\n  const sum = slackV[slack[N - 1]];\n\n  let min = sum;\n  for (let i = 0; i < N; ++i) {\n    const y = slack[i];\n    dualX[x] += min;\n    min = sum - slackV[y];\n    dualY[y] -= min;\n    x = starsY[y];\n  }\n}\n\n/**\n * Matches a given unmatched column to an unmatched row.\n *\n * @param x - An unmatched column.\n * @param matrix - An MxN cost matrix.\n * @param dualX - The dual variables for each matrix column.\n * @param dualY - The dual variables for each matrix row.\n * @param starsY - An array mapping star rows to columns.\n * @param slack - An array of covered row indices. Modified in place.\n * @param slackV - The slack values for each row. Modified in place.\n * @param slackX - An array mapping a slack row to column. Modified in place.\n */\nexport function matchB(\n  x: number,\n  matrix: MatrixLike<number>,\n  dualX: ArrayLike<number>,\n  dualY: ArrayLike<number>,\n  starsY: ArrayLike<number>,\n  slack: MutableArrayLike<number>,\n  slackV: MutableArrayLike<number>,\n  slackX: MutableArrayLike<number>,\n): number {\n  const Y = slack.length;\n\n  // Initialize slack\n  let dx = dualX[x];\n  for (let y = 0; y < Y; ++y) {\n    slack[y] = y;\n    slackV[y] = matrix[y][x] - dualY[y] - dx;\n    slackX[y] = x;\n  }\n\n  // Initialize zeros\n  let zeros = partitionByMin(slack, slackV, 0);\n  let zero = slackV[slack[0]];\n\n  // Grow a hungarian tree until an augmenting path is found\n  let steps = 1;\n  for (let y = slack[0]; starsY[y] !== -1; y = slack[steps++]) {\n    // Update slack\n    x = starsY[y];\n    dx = dualX[x] - zero;\n    for (let i = zeros; i < Y; ++i) {\n      y = slack[i];\n      const value = matrix[y][x] - dualY[y] - dx;\n      if (value >= slackV[y]) {\n        continue;\n      }\n      slackX[y] = x;\n      slackV[y] = value;\n      if (value === zero) {\n        slack[i] = slack[zeros];\n        slack[zeros++] = y;\n      }\n    }\n\n    // Update zeros\n    if (steps >= zeros) {\n      zeros = partitionByMin(slack, slackV, zeros);\n      zero = slackV[slack[steps]];\n    }\n  }\n\n  return steps;\n}\n","// Same algorithm as `../big/munkres.ts`; keep the two in sync.\nimport type { MatrixLike } from \"../../types/matrixLike.ts\";\nimport type { Matching } from \"../../types/matching.ts\";\nimport type { MutableArrayLike } from \"../../types/mutableArrayLike.ts\";\n\nimport { getMin, partitionByMin } from \"./utils.ts\";\n\nimport { step4B } from \"./munkresB.ts\";\nimport { step5 } from \"../shared.ts\";\n\nexport function exec(matrix: MatrixLike<number>): Matching<number> {\n  // Get dimensions\n  const Y = matrix.length;\n  const X = matrix[0]?.length ?? 0;\n\n  // Check if empty matrix\n  if (Y <= 0 || X <= 0) {\n    return { dualX: [], dualY: [], matrix, starsX: [], starsY: [] };\n  }\n\n  // Step 1: Reduce\n  const dualX = new Array<number>(X);\n  const dualY = new Array<number>(Y);\n  step1(matrix, dualX, dualY);\n\n  // Steps 2 & 3: Find initial matching\n  const starsX = new Array<number>(X).fill(-1);\n  const starsY = new Array<number>(Y).fill(-1);\n  const stars = steps2To3(matrix, dualX, dualY, starsX, starsY);\n\n  // Step 4: Find complete matching\n  if (Y <= X) {\n    step4(Y - stars, matrix, dualX, dualY, starsX, starsY);\n  } else {\n    step4B(X - stars, matrix, dualX, dualY, starsX, starsY);\n  }\n\n  // Return matching\n  return { dualX, dualY, matrix, starsX, starsY };\n}\n\n/**\n * Initializes the dual variables for the Munkres algorithm.\n *\n * This is a preprocessing step that effectively performs\n * row-wise and column-wise reductions on the cost matrix. This\n * helps find an initial matching and improves the efficiency\n * of subsequent steps.\n *\n * @param matrix - The cost matrix.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n */\nexport function step1(\n  matrix: MatrixLike<number>,\n  dualX: MutableArrayLike<number>,\n  dualY: MutableArrayLike<number>,\n): void {\n  const X = dualX.length;\n  const Y = dualY.length;\n\n  // If matrix is tall, skip row reduction\n  if (Y > X) {\n    dualY.fill(0);\n  } else {\n    // Reduce rows\n    for (let y = 0; y < Y; ++y) {\n      dualY[y] = getMin(matrix[y])!;\n    }\n  }\n\n  // If matrix is wide, skip column reduction\n  if (Y < X) {\n    dualX.fill(0);\n    return;\n  }\n\n  // Initialize dualX\n  let dy = dualY[0];\n  let row = matrix[0];\n  for (let x = 0; x < X; ++x) {\n    dualX[x] = row[x] - dy;\n  }\n\n  // Reduce columns\n  for (let y = 1; y < Y; ++y) {\n    dy = dualY[y];\n    row = matrix[y];\n    for (let x = 0; x < X; ++x) {\n      const dx = row[x] - dy;\n      if (dx < dualX[x]) {\n        dualX[x] = dx;\n      }\n    }\n  }\n}\n\n/**\n * Finds an initial matching for the munkres algorithm.\n *\n * @param matrix - The cost matrix.\n * @param dualX - The dual variables for each matrix column.\n * @param dualY - The dual variables for each matrix row.\n * @param starsX - An array mapping star columns to row. Modified in place.\n * @param starsY - An array mapping star rows to columns. Modified in place.\n *\n * @returns The number of matches (stars) found.\n */\nexport function steps2To3(\n  matrix: MatrixLike<number>,\n  dualX: ArrayLike<number>,\n  dualY: ArrayLike<number>,\n  starsX: MutableArrayLike<number>,\n  starsY: MutableArrayLike<number>,\n): number {\n  const X = dualX.length;\n  const Y = dualY.length;\n  const S = Y <= X ? Y : X;\n\n  let stars = 0;\n  for (let y = 0; y < Y && stars < S; ++y) {\n    const dy = dualY[y];\n    const row = matrix[y];\n    for (let x = 0; x < X; ++x) {\n      if (starsX[x] === -1 && dy === row[x] - dualX[x]) {\n        starsX[x] = y;\n        starsY[y] = x;\n        ++stars;\n        break;\n      }\n    }\n  }\n\n  return stars;\n}\n\n/**\n * This step iteratively improves upon an initial matching until a complete\n * matching is found. This involves updating dual variables and managing\n * slack values to uncover new opportunities for optimal assignments.\n *\n * @param unmatched - The number of missing matches.\n * @param mat - An MxN cost matrix.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n * @param starsX - An array mapping star columns to row. Modified in place.\n * @param starsY - An array mapping star rows to columns. Modified in place.\n */\nexport function step4(\n  unmatched: number,\n  matrix: MatrixLike<number>,\n  dualX: MutableArrayLike<number>,\n  dualY: MutableArrayLike<number>,\n  starsX: MutableArrayLike<number>,\n  starsY: MutableArrayLike<number>,\n): void {\n  // If no unmatched row\n  if (unmatched <= 0) {\n    return;\n  }\n\n  const X = dualX.length;\n  const slack = new Uint32Array(X);\n  const slackV = new Array<number>(X);\n  const slackY = new Uint32Array(X);\n\n  // Match unmatched rows\n  for (let y = 0; unmatched > 0; ++y) {\n    if (starsY[y] !== -1) {\n      continue;\n    }\n\n    const N = match(y, matrix, dualX, dualY, starsX, slack, slackV, slackY);\n    --unmatched;\n\n    // Update dual variables\n    step6(y, N, dualX, dualY, slack, slackV, starsX);\n\n    // Update matching\n    step5(slack[N - 1], slackY, starsX, starsY);\n  }\n}\n\n/**\n * Adjusts dual variables to uncover more admissible edges.\n *\n * @param y - The starting node's row.\n * @param N - The number of adjustments to make.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n * @param slack - An array of covered column indices.\n * @param slackV - The slack values for each column.\n * @param starsX - An array mapping star columns to row.\n */\nexport function step6(\n  y: number,\n  N: number,\n  dualX: MutableArrayLike<number>,\n  dualY: MutableArrayLike<number>,\n  slack: ArrayLike<number>,\n  slackV: ArrayLike<number>,\n  starsX: ArrayLike<number>,\n): void {\n  const sum = slackV[slack[--N]];\n  dualY[y] += sum;\n\n  for (let i = 0; i < N; ++i) {\n    const x = slack[i];\n    y = starsX[x];\n    const min = sum - slackV[x];\n    dualX[x] -= min;\n    dualY[y] += min;\n  }\n}\n\n/**\n * Matches a given unmatched row to an unmatched column.\n *\n * @param y - An unmatched row.\n * @param matrix - An MxN cost matrix.\n * @param dualX - The dual variables for each matrix column.\n * @param dualY - The dual variables for each matrix row.\n * @param starsX - An array mapping star columns to row.\n * @param slack - An array of covered column indices. Modified in place.\n * @param slackV - The slack values for each column. Modified in place.\n * @param slackY - An array mapping a slack column to row. Modified in place.\n */\nexport function match(\n  y: number,\n  matrix: MatrixLike<number>,\n  dualX: ArrayLike<number>,\n  dualY: ArrayLike<number>,\n  starsX: ArrayLike<number>,\n  slack: MutableArrayLike<number>,\n  slackV: MutableArrayLike<number>,\n  slackY: MutableArrayLike<number>,\n): number {\n  const X = slack.length;\n\n  // Initialize slack\n  let dy = dualY[y];\n  let row = matrix[y];\n  for (let x = 0; x < X; ++x) {\n    slack[x] = x;\n    slackV[x] = row[x] - dualX[x] - dy;\n    slackY[x] = y;\n  }\n\n  // Initialize zeros\n  let zeros = partitionByMin(slack, slackV, 0);\n  let zero = slackV[slack[0]];\n\n  // Grow a hungarian tree until an augmenting path is found\n  let steps = 1;\n  for (let x = slack[0]; starsX[x] !== -1; x = slack[steps++]) {\n    // Update slack\n    y = starsX[x];\n    dy = dualY[y] - zero;\n    row = matrix[y];\n    for (let i = zeros; i < X; ++i) {\n      x = slack[i];\n      const value = row[x] - dualX[x] - dy;\n      if (value >= slackV[x]) {\n        continue;\n      }\n      slackY[x] = y;\n      slackV[x] = value;\n      if (value === zero) {\n        slack[i] = slack[zeros];\n        slack[zeros++] = x;\n      }\n    }\n\n    // Update zeros\n    if (steps >= zeros) {\n      zeros = partitionByMin(slack, slackV, zeros);\n      zero = slackV[slack[steps]];\n    }\n  }\n\n  return steps;\n}\n","import type { MatrixLike } from \"../../types/matrixLike.ts\";\nimport type { MutableArrayLike } from \"../../types/mutableArrayLike.ts\";\n\nimport { partitionByMin } from \"../num/utils.ts\";\n\nimport { step5B } from \"../shared.ts\";\n\n/**\n * This step iteratively improves upon an initial matching until a complete\n * matching is found. This involves updating dual variables and managing\n * slack values to uncover new opportunities for optimal assignments.\n *\n * @param unmatched - The number of missing matches.\n * @param mat - An MxN cost matrix.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n * @param starsX - An array mapping star columns to row. Modified in place.\n * @param starsY - An array mapping star rows to columns. Modified in place.\n */\nexport function step4B(\n  unmatched: number,\n  matrix: MatrixLike<number>,\n  dualX: number[],\n  dualY: number[],\n  starsX: number[],\n  starsY: number[],\n): void {\n  // If no unmatched column\n  if (unmatched <= 0) {\n    return;\n  }\n\n  const Y = dualY.length;\n  const slack = new Uint32Array(Y);\n  const slackV = new Array<number>(Y);\n  const slackX = new Uint32Array(Y);\n\n  // Match unmatched columns\n  for (let x = 0; unmatched > 0; ++x) {\n    if (starsX[x] !== -1) {\n      continue;\n    }\n\n    const N = matchB(x, matrix, dualX, dualY, starsY, slack, slackV, slackX);\n    --unmatched;\n\n    // Update dual variables\n    step6B(x, N, dualX, dualY, slack, slackV, starsY);\n\n    // Update matching\n    step5B(slack[N - 1], slackX, starsX, starsY);\n  }\n}\n\n/**\n * Adjusts dual variables to uncover more admissible edges.\n *\n * @param x - The starting node's column.\n * @param N - The number of adjustments to make.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n * @param slack - An array of covered row indices.\n * @param slackV - The slack values for each row.\n * @param starsY - An array mapping star rows to columns.\n */\nexport function step6B(\n  x: number,\n  N: number,\n  dualX: number[],\n  dualY: number[],\n  slack: ArrayLike<number>,\n  slackV: ArrayLike<number>,\n  starsY: ArrayLike<number>,\n): void {\n  const sum = slackV[slack[N - 1]];\n\n  let min = sum;\n  for (let i = 0; i < N; ++i) {\n    const y = slack[i];\n    dualX[x] = dualX[x] + min || 0;\n    min = sum - slackV[y] || 0;\n    dualY[y] = dualY[y] - min || 0;\n    x = starsY[y];\n  }\n}\n\n/**\n * Matches a given unmatched column to an unmatched row.\n *\n * @param x - An unmatched column.\n * @param matrix - An MxN cost matrix.\n * @param dualX - The dual variables for each matrix column.\n * @param dualY - The dual variables for each matrix row.\n * @param starsY - An array mapping star rows to columns.\n * @param slack - An array of covered row indices. Modified in place.\n * @param slackV - The slack values for each row. Modified in place.\n * @param slackX - An array mapping a slack row to column. Modified in place.\n */\nexport function matchB(\n  x: number,\n  matrix: MatrixLike<number>,\n  dualX: number[],\n  dualY: number[],\n  starsY: number[],\n  slack: MutableArrayLike<number>,\n  slackV: MutableArrayLike<number>,\n  slackX: MutableArrayLike<number>,\n): number {\n  const Y = slack.length;\n\n  // Initialize slack\n  let dx = dualX[x];\n  for (let y = 0; y < Y; ++y) {\n    slack[y] = y;\n    slackV[y] = matrix[y][x] - (dx + dualY[y] || 0) || 0;\n    slackX[y] = x;\n  }\n\n  // Initialize zeros\n  let zeros = partitionByMin(slack, slackV, 0);\n  let zero = slackV[slack[0]];\n\n  // Grow a hungarian tree until an augmenting path is found\n  let steps = 1;\n  for (let y = slack[0]; starsY[y] !== -1; y = slack[steps++]) {\n    // Update slack\n    x = starsY[y];\n    dx = dualX[x];\n    for (let i = zeros; i < Y; ++i) {\n      y = slack[i];\n      const value = (matrix[y][x] - (dx + dualY[y] || 0) || 0) + zero || 0;\n      if (value >= slackV[y]) {\n        continue;\n      }\n      slackX[y] = x;\n      slackV[y] = value;\n      if (value === zero) {\n        slack[i] = slack[zeros];\n        slack[zeros++] = y;\n      }\n    }\n\n    // Update zeros\n    if (steps >= zeros) {\n      zeros = partitionByMin(slack, slackV, zeros);\n      zero = slackV[slack[steps]];\n    }\n  }\n\n  return steps;\n}\n","import type { MatrixLike } from \"../../types/matrixLike.ts\";\nimport type { Matching } from \"../../types/matching.ts\";\nimport type { MutableArrayLike } from \"../../types/mutableArrayLike.ts\";\n\nimport { getMin, partitionByMin } from \"../num/utils.ts\";\n\nimport { step4B } from \"./munkresB.ts\";\nimport { step5 } from \"../shared.ts\";\n\nexport function exec(matrix: MatrixLike<number>): Matching<number> {\n  // Get dimensions\n  const Y = matrix.length;\n  const X = matrix[0]?.length ?? 0;\n\n  // Check if empty matrix\n  if (Y <= 0 || X <= 0) {\n    return { dualX: [], dualY: [], matrix, starsX: [], starsY: [] };\n  }\n\n  // Step 1: Reduce\n  const dualX = new Array<number>(X);\n  const dualY = new Array<number>(Y);\n  step1(matrix, dualX, dualY);\n\n  // Steps 2 & 3: Find initial matching\n  const starsX = new Array<number>(X).fill(-1);\n  const starsY = new Array<number>(Y).fill(-1);\n  const stars = steps2To3(matrix, dualX, dualY, starsX, starsY);\n\n  // Step 4: Find complete matching\n  if (Y <= X) {\n    step4(Y - stars, matrix, dualX, dualY, starsX, starsY);\n  } else {\n    step4B(X - stars, matrix, dualX, dualY, starsX, starsY);\n  }\n\n  // Return matching\n  return { dualX, dualY, matrix, starsX, starsY };\n}\n\n/**\n * Initializes the dual variables for the Munkres algorithm.\n *\n * This is a preprocessing step that effectively performs\n * row-wise and column-wise reductions on the cost matrix. This\n * helps find an initial matching and improves the efficiency\n * of subsequent steps.\n *\n * @param matrix - The cost matrix.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n */\nexport function step1(\n  matrix: MatrixLike<number>,\n  dualX: number[],\n  dualY: number[],\n): void {\n  const X = dualX.length;\n  const Y = dualY.length;\n\n  // If matrix is tall, skip row reduction\n  if (Y > X) {\n    dualY.fill(0);\n  } else {\n    // Reduce rows\n    for (let y = 0; y < Y; ++y) {\n      dualY[y] = getMin(matrix[y])!;\n    }\n  }\n\n  // If matrix is wide, skip column reduction\n  if (Y < X) {\n    dualX.fill(0);\n    return;\n  }\n\n  // Initialize dualX\n  let dy = dualY[0];\n  let row = matrix[0];\n  for (let x = 0; x < X; ++x) {\n    dualX[x] = row[x] - dy || 0;\n  }\n\n  // Reduce columns\n  for (let y = 1; y < Y; ++y) {\n    dy = dualY[y];\n    row = matrix[y];\n    for (let x = 0; x < X; ++x) {\n      const dx = row[x] - dy || 0;\n      if (dx < dualX[x]) {\n        dualX[x] = dx;\n      }\n    }\n  }\n}\n\n/**\n * Finds an initial matching for the munkres algorithm.\n *\n * @param matrix - The cost matrix.\n * @param dualX - The dual variables for each matrix column.\n * @param dualY - The dual variables for each matrix row.\n * @param starsX - An array mapping star columns to row. Modified in place.\n * @param starsY - An array mapping star rows to columns. Modified in place.\n *\n * @returns The number of matches (stars) found.\n */\nexport function steps2To3(\n  matrix: MatrixLike<number>,\n  dualX: number[],\n  dualY: number[],\n  starsX: number[],\n  starsY: number[],\n): number {\n  const X = dualX.length;\n  const Y = dualY.length;\n  const S = Y <= X ? Y : X;\n\n  let stars = 0;\n  for (let y = 0; y < Y && stars < S; ++y) {\n    const dy = dualY[y];\n    const row = matrix[y];\n    for (let x = 0; x < X; ++x) {\n      if (starsX[x] === -1 && row[x] === (dualX[x] + dy || 0)) {\n        starsX[x] = y;\n        starsY[y] = x;\n        ++stars;\n        break;\n      }\n    }\n  }\n\n  return stars;\n}\n\n/**\n * This step iteratively improves upon an initial matching until a complete\n * matching is found. This involves updating dual variables and managing\n * slack values to uncover new opportunities for optimal assignments.\n *\n * @param unmatched - The number of missing matches.\n * @param mat - An MxN cost matrix.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n * @param starsX - An array mapping star columns to row. Modified in place.\n * @param starsY - An array mapping star rows to columns. Modified in place.\n */\nexport function step4(\n  unmatched: number,\n  matrix: MatrixLike<number>,\n  dualX: number[],\n  dualY: number[],\n  starsX: number[],\n  starsY: number[],\n): void {\n  // If no unmatched row\n  if (unmatched <= 0) {\n    return;\n  }\n\n  const X = dualX.length;\n  const slack = new Uint32Array(X);\n  const slackV = new Array<number>(X);\n  const slackY = new Uint32Array(X);\n\n  // Match unmatched rows\n  for (let y = 0; unmatched > 0; ++y) {\n    if (starsY[y] !== -1) {\n      continue;\n    }\n\n    const N = match(y, matrix, dualX, dualY, starsX, slack, slackV, slackY);\n    --unmatched;\n\n    // Update dual variables\n    step6(y, N, dualX, dualY, slack, slackV, starsX);\n\n    // Update matching\n    step5(slack[N - 1], slackY, starsX, starsY);\n  }\n}\n\n/**\n * Adjusts dual variables to uncover more admissible edges.\n *\n * @param y - The starting node's row.\n * @param N - The number of adjustments to make.\n * @param dualX - The dual variables for each matrix column. Modified in place.\n * @param dualY - The dual variables for each matrix row. Modified in place.\n * @param slack - An array of covered column indices.\n * @param slackV - The slack values for each column.\n * @param starsX - An array mapping star columns to row.\n */\nexport function step6(\n  y: number,\n  N: number,\n  dualX: number[],\n  dualY: number[],\n  slack: ArrayLike<number>,\n  slackV: ArrayLike<number>,\n  starsX: ArrayLike<number>,\n): void {\n  const sum = slackV[slack[--N]];\n  dualY[y] = dualY[y] + sum || 0;\n\n  for (let i = 0; i < N; ++i) {\n    const x = slack[i];\n    y = starsX[x];\n    const min = sum - slackV[x] || 0;\n    dualX[x] = dualX[x] - min || 0;\n    dualY[y] = dualY[y] + min || 0;\n  }\n}\n\n/**\n * Matches a given unmatched row to an unmatched column.\n *\n * @param y - An unmatched row.\n * @param matrix - An MxN cost matrix.\n * @param dualX - The dual variables for each matrix column.\n * @param dualY - The dual variables for each matrix row.\n * @param starsX - An array mapping star columns to row.\n * @param slack - An array of covered column indices. Modified in place.\n * @param slackV - The slack values for each column. Modified in place.\n * @param slackY - An array mapping a slack column to row. Modified in place.\n */\nexport function match(\n  y: number,\n  matrix: MatrixLike<number>,\n  dualX: number[],\n  dualY: number[],\n  starsX: number[],\n  slack: MutableArrayLike<number>,\n  slackV: MutableArrayLike<number>,\n  slackY: MutableArrayLike<number>,\n): number {\n  const X = slack.length;\n\n  // Initialize slack\n  let dy = dualY[y];\n  let row = matrix[y];\n  for (let x = 0; x < X; ++x) {\n    slack[x] = x;\n    slackV[x] = row[x] - (dualX[x] + dy || 0) || 0;\n    slackY[x] = y;\n  }\n\n  // Initialize zeros\n  let zeros = partitionByMin(slack, slackV, 0);\n  let zero = slackV[slack[0]];\n\n  // Grow a hungarian tree until an augmenting path is found\n  let steps = 1;\n  for (let x = slack[0]; starsX[x] !== -1; x = slack[steps++]) {\n    // Update slack\n    y = starsX[x];\n    dy = dualY[y];\n    row = matrix[y];\n    for (let i = zeros; i < X; ++i) {\n      x = slack[i];\n      const value = (row[x] - (dualX[x] + dy || 0) || 0) + zero || 0;\n      if (value >= slackV[x]) {\n        continue;\n      }\n      slackY[x] = y;\n      slackV[x] = value;\n      if (value === zero) {\n        slack[i] = slack[zeros];\n        slack[zeros++] = x;\n      }\n    }\n\n    // Update zeros\n    if (steps >= zeros) {\n      zeros = partitionByMin(slack, slackV, zeros);\n      zero = slackV[slack[steps]];\n    }\n  }\n\n  return steps;\n}\n","import type { MatrixLike } from \"../types/matrixLike.ts\";\nimport type { Matching } from \"../types/matching.ts\";\n\nimport { isBigInt } from \"../utils/is.ts\";\nimport { inspectNumeric } from \"../utils/inspectNumeric.ts\";\n\nimport { exec as bigExec } from \"./big/munkres.ts\";\nimport { exec as numFiniteExec } from \"./num/munkres.ts\";\nimport { exec as numExec } from \"./inf/munkres.ts\";\n\n/**\n * Internal options for the dispatcher. The public-facing\n * `MunkresOptions` (in `src/types/munkresOptions.ts`) is shaped to match.\n */\ninterface ExecOptions {\n  finite?: boolean;\n}\n\n/**\n * Find the optimal assignments of `y` workers to `x` jobs to\n * minimize total cost.\n *\n * @param costMatrix - The cost matrix, where `mat[y][x]` represents the cost\n * of assigning worker `y` to job `x`.\n * @param options - Internal dispatch options. See {@link ExecOptions}.\n *\n * @returns An array of pairs `[y, x]` representing the optimal assignment\n * of workers to jobs. Each pair consists of a worker index `y` and a job\n * index `x`, indicating that worker `y` is assigned to job `x`.\n *\n * @privateRemarks\n * Citations:\n * 1. {@link https://users.cs.duke.edu/~brd/Teaching/Bio/asmb/current/Handouts/munkres.html | Munkres' Assignment Algorithm, Modified for Rectangular Matrices}\n *     - Used as the foundation and enhanced with custom optimizations.\n *\n * 1. {@link https://www.ri.cmu.edu/pub_files/pub4/mills_tettey_g_ayorkor_2007_3/mills_tettey_g_ayorkor_2007_3.pdf | Mills-Tettey, Ayorkor & Stent, Anthony & Dias, M.. (2007). The Dynamic Hungarian Algorithm for the Assignment Problem with Changing Costs.}\n *     - Used to implement primal-dual variables and dynamic updates.\n *\n * 1. {@link https://public.websites.umich.edu/~murty/612/612slides4.pdf | Murty, K. G.. Primal-Dual Algorithms. [IOE 612, Lecture slides 4]. Department of Industrial and Operations Engineering, University of Michigan.}\n *     - Used to implement primal-dual and slack variables.\n */\nexport function exec(\n  costMatrix: MatrixLike<number>,\n  options?: ExecOptions,\n): Matching<number>;\nexport function exec(\n  costMatrix: MatrixLike<bigint>,\n  options?: ExecOptions,\n): Matching<bigint>;\nexport function exec<T extends number | bigint>(\n  costMatrix: MatrixLike<T>,\n  options?: ExecOptions,\n): Matching<T> {\n  // If bigint matrix, route to the bigint-specialized core. `bigExec` is\n  // type-monomorphic over bigint, which lets V8 fully specialize its hot\n  // inner loops. Finite number matrices go through `numFiniteExec`\n  // (same algorithm, type-monomorphic over number) — keeping the two\n  // type domains in separate function instances avoids polluting V8's\n  // type feedback on either side.\n  if (isBigInt((costMatrix[0] ?? [])[0])) {\n    return bigExec(costMatrix as MatrixLike<bigint>) as Matching<T>;\n  }\n\n  // If caller promises finite values\n  const numMatrix = costMatrix as MatrixLike<number>;\n  if (options?.finite) {\n    return numFiniteExec(numMatrix) as Matching<T>;\n  }\n\n  // Inspect the matrix\n  const inspection = inspectNumeric(numMatrix);\n\n  // If the matrix contains NaN\n  if (inspection.nanAt) {\n    throw new TypeError(\n      `munkres: cost matrix contains NaN at ` +\n        `[${inspection.nanAt[0]}][${inspection.nanAt[1]}]. ` +\n        `Use Infinity to avoid an assignment.`,\n    );\n  }\n\n  // If the matrix contains ±Infinity\n  if (inspection.infinityAt) {\n    // Use route with Infinity-handling logic\n    return numExec(numMatrix) as Matching<T>;\n  }\n\n  // INVARIANT: this point is reached only for all-finite matrices.\n  // `inspectNumeric` computes rangeMin/rangeMax over finite cells only,\n  // so for an all-Infinity matrix it returns rangeMin=Infinity,\n  // rangeMax=-Infinity and `rangeMax - rangeMin = -Infinity` — which is\n  // NOT > MAX_VALUE/2 and would slip past this guard. The `infinityAt`\n  // short-circuit above is what keeps that case out; do not reorder or\n  // remove it without making rangeMin/rangeMax robust to the empty-finite\n  // set on their own.\n  //\n  // Check the input range is safe. The algorithm's worst-case intermediate\n  // values is 2 * (max - min). If 2 * (max - min) > MAX_VALUE, overflow\n  // may occur. Enforcement ensures safe inputs and representable values.\n  if (\n    inspection.rangeMin != null &&\n    inspection.rangeMax != null &&\n    inspection.rangeMax - inspection.rangeMin > Number.MAX_VALUE / 2\n  ) {\n    throw new RangeError(\n      `munkres: cost matrix range (max - min = ${\n        inspection.rangeMax - inspection.rangeMin\n      }) exceeds Number.MAX_VALUE / 2; intermediate arithmetic may overflow. ` +\n        `Scale your cost matrix down, or use a bigint cost matrix.`,\n    );\n  }\n\n  return numFiniteExec(numMatrix) as Matching<T>;\n}\n","/**\n * Transforms the given array into an array of key, value pairs\n * for every entry in the array.\n *\n * @param array - The array to transform into entries.\n *\n * @returns An array of key, value pairs for every entry in the array.\n *\n * @example\n * entries(['a', 'b', 'c']);\n * // Returns [[0, 'a'], [1, 'b'], [2, 'c']]\n */\nexport function entries<T>(array: ArrayLike<T>): [number, T][] {\n  const N = array.length;\n  const out = new Array(N);\n  for (let i = 0; i < N; ++i) {\n    out[i] = [i, array[i]];\n  }\n  return out;\n}\n","import type { Matching } from \"../types/matching.ts\";\nimport type { Pair } from \"../types/pair.ts\";\n\nimport { entries } from \"./arrayLike.ts\";\nimport { flipH } from \"./matrix.ts\";\n\n/**\n * Converts a matching object into an array of matched indices.\n *\n * @param matching - The matching to convert.\n *\n * @returns An array of pairs where each pair\n * `[r, c]` indicates a match between row `r` and column `c`.\n *\n * @example\n * ```typescript\n * const matching = {\n *   // ...\n *   starsY: [2, 0],\n *   starsX: [2, -1, 0]\n * };\n *\n * const pairs = toPairs(matching);\n * // pairs: [[0, 2], [1, 0]]\n * ```\n */\nexport function toPairs<T>(matching: Matching<T>): Pair<number>[] {\n  // If Y <= X\n  if (matching.starsY.length <= matching.starsX.length) {\n    return entries(matching.starsY);\n  }\n\n  // If Y > X\n  const pairs = entries(matching.starsX);\n  flipH(pairs);\n  return pairs;\n}\n","import type { MatrixLike } from \"./types/matrixLike.ts\";\nimport type { Pair } from \"./types/pair.ts\";\n\nimport { exec } from \"./core/munkres.ts\";\nimport { toPairs } from \"./utils/matching.ts\";\n\nimport type { MunkresOptions } from \"./types/munkresOptions.ts\";\n\n/**\n * Find the optimal assignments of `y` workers to `x` jobs to\n * minimize total cost.\n *\n * @param costMatrix - The cost matrix, where `mat[y][x]` represents the cost\n * of assigning worker `y` to job `x`. Treated as an `mat.length` by\n * `mat[0].length` rectangle; cells beyond row 0's width are ignored.\n * @param options - Optional behavior modifiers. See {@link MunkresOptions}.\n *\n * @returns An array of pairs `[y, x]` representing the optimal assignment\n * of workers to jobs. The result has length `min(rows, cols)` and pairs\n * are always `[y, x]` (row, then column) regardless of matrix shape.\n * When `rows > cols`, the unmatched rows are simply absent from the\n * result; when `cols > rows`, the unmatched columns are absent.\n *\n * @throws TypeError if a `number` cost matrix contains `NaN`. Pass\n *   `Infinity` to avoid an assignment instead.\n * @throws RangeError if a `number` cost matrix's range\n *   `max(c) - min(c)` exceeds `Number.MAX_VALUE / 2`, the algorithm's\n *   worst-case intermediate magnitude is `2 * range`, and this guard\n *   keeps all intermediate arithmetic representable. Scale your cost\n *   matrix down or use `bigint`. Typical assignment-problem inputs\n *   have ranges well below this threshold.\n *\n *   The range check applies only to all-finite matrices. A `number`\n *   matrix containing `Infinity` / `-Infinity` routes to a separate\n *   Infinity-handling path *before* the range check and is therefore\n *   never range-checked. Those inputs cannot overflow the same way,\n *   since the `±Infinity` cells are saturated rather than summed.\n *\n *   Pass `{ finite: true }` to skip BOTH the finiteness scan AND this\n *   range check, when the caller has already established the input is\n *   well-formed; mis-using that option can produce undefined output but\n *   never throws.\n *\n * @remarks\n * The `number` path uses IEEE 754 double-precision arithmetic. For\n * matrices of *integer* costs where exact optima are required (e.g.\n * values approaching or exceeding `Number.MAX_SAFE_INTEGER`), pass a\n * `bigint` cost matrix to use the arbitrary-precision path. Floating\n * point inputs are inherently approximate; the `number` path may\n * return a valid but suboptimal assignment when precision is lost in\n * slack comparisons.\n *\n * @example\n *   munkres([[1, 2], [3, 4]]);\n *   // → [[0, 0], [1, 1]]\n *\n * @example\n *   // Skip the O(Y*X) finiteness scan when you know your matrix is\n *   // all-finite (no Infinity, no NaN). Faster for large matrices.\n *   munkres(largeFiniteMatrix, { finite: true });\n */\nexport function munkres(\n  costMatrix: MatrixLike<number>,\n  options?: MunkresOptions,\n): Pair<number>[];\nexport function munkres(\n  costMatrix: MatrixLike<bigint>,\n  options?: MunkresOptions,\n): Pair<number>[];\nexport function munkres<T extends number | bigint>(\n  costMatrix: MatrixLike<T>,\n  options?: MunkresOptions,\n): Pair<number>[] {\n  return toPairs(exec(costMatrix as MatrixLike<number>, options));\n}\n"],"mappings":"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","names":["getMin","getMin","getMin","partitionByMin","step4B","matchB","step6B","partitionByMin","exec","step1","steps2To3","step4","step4B","getMin","match","step6","partitionByMin","step4B","matchB","step6B","partitionByMin","exec","step1","steps2To3","step4","step4B","getMin","match","step6","partitionByMin","exec","exec"]}