@jbrowse/core 4.2.1 → 5.0.0-beta.1

package/esm/util/crypto.js

@@ -1,7 +1,12 @@
+// Crypto utilities using Web Crypto API with pure JS fallback for non-secure contexts
+// Compatible with crypto-js OpenSSL format for AES encryption
 const SALT_PREFIX = 'Salted__';
+// Check if Web Crypto API is available (only in secure contexts)
 function isWebCryptoAvailable() {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     return typeof crypto !== 'undefined' && crypto.subtle !== undefined;
 }
+// AES S-box
 const SBOX = new Uint8Array([
     0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe,
     0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4,
@@ -24,6 +29,7 @@ const SBOX = new Uint8Array([
     0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42,
     0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16,
 ]);
+// AES inverse S-box
 const SBOX_INV = new Uint8Array([
     0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81,
     0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e,
@@ -46,9 +52,11 @@ const SBOX_INV = new Uint8Array([
     0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6,
     0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d,
 ]);
+// Round constants for key expansion
 const RCON = new Uint8Array([
     0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36,
 ]);
+// Galois field multiplication
 function gmul(a, b) {
     let p = 0;
     for (let i = 0; i < 8; i++) {
@@ -64,21 +72,25 @@ function gmul(a, b) {
     }
     return p;
 }
+// AES key expansion for 256-bit key
 function aesKeyExpansion(key) {
-    const Nk = 8;
-    const Nr = 14;
+    const Nk = 8; // 256-bit key = 8 words
+    const Nr = 14; // 14 rounds for 256-bit
     const expandedKey = new Uint8Array(16 * (Nr + 1));
     expandedKey.set(key);
     for (let i = Nk; i < 4 * (Nr + 1); i++) {
         const temp = expandedKey.slice((i - 1) * 4, i * 4);
         if (i % Nk === 0) {
+            // RotWord + SubWord + Rcon
             const t = temp[0];
             temp[0] = SBOX[temp[1]] ^ RCON[i / Nk - 1];
             temp[1] = SBOX[temp[2]];
             temp[2] = SBOX[temp[3]];
             temp[3] = SBOX[t];
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         }
         else if (Nk > 6 && i % Nk === 4) {
+            // SubWord for 256-bit keys
             for (let j = 0; j < 4; j++) {
                 temp[j] = SBOX[temp[j]];
             }
@@ -89,17 +101,21 @@ function aesKeyExpansion(key) {
     }
     return expandedKey;
 }
+// AES encrypt single block (pure JS)
 function aesEncryptBlock(block, expandedKey) {
     const Nr = 14;
     const state = new Uint8Array(16);
     state.set(block);
+    // AddRoundKey
     for (let i = 0; i < 16; i++) {
         state[i] ^= expandedKey[i];
     }
     for (let round = 1; round <= Nr; round++) {
+        // SubBytes
         for (let i = 0; i < 16; i++) {
             state[i] = SBOX[state[i]];
         }
+        // ShiftRows
         const t1 = state[1];
         state[1] = state[5];
         state[5] = state[9];
@@ -116,6 +132,7 @@ function aesEncryptBlock(block, expandedKey) {
         state[11] = state[7];
         state[7] = state[3];
         state[3] = t3;
+        // MixColumns (skip in last round)
         if (round < Nr) {
             for (let c = 0; c < 4; c++) {
                 const i = c * 4;
@@ -129,6 +146,7 @@ function aesEncryptBlock(block, expandedKey) {
                 state[i + 3] = gmul(s0, 3) ^ s1 ^ s2 ^ gmul(s3, 2);
             }
         }
+        // AddRoundKey
         const roundKey = expandedKey.subarray(round * 16, (round + 1) * 16);
         for (let i = 0; i < 16; i++) {
             state[i] ^= roundKey[i];
@@ -136,14 +154,17 @@ function aesEncryptBlock(block, expandedKey) {
     }
     return state;
 }
+// AES decrypt single block (pure JS)
 function aesDecryptBlock(block, expandedKey) {
     const Nr = 14;
     const state = new Uint8Array(16);
     state.set(block);
+    // AddRoundKey
     for (let i = 0; i < 16; i++) {
         state[i] ^= expandedKey[Nr * 16 + i];
     }
     for (let round = Nr - 1; round >= 0; round--) {
+        // InvShiftRows
         const t1 = state[13];
         state[13] = state[9];
         state[9] = state[5];
@@ -160,13 +181,16 @@ function aesDecryptBlock(block, expandedKey) {
         state[7] = state[11];
         state[11] = state[15];
         state[15] = t3;
+        // InvSubBytes
         for (let i = 0; i < 16; i++) {
             state[i] = SBOX_INV[state[i]];
         }
+        // AddRoundKey
         const roundKey = expandedKey.subarray(round * 16, (round + 1) * 16);
         for (let i = 0; i < 16; i++) {
             state[i] ^= roundKey[i];
         }
+        // InvMixColumns (skip in last round)
         if (round > 0) {
             for (let c = 0; c < 4; c++) {
                 const i = c * 4;
@@ -183,6 +207,7 @@ function aesDecryptBlock(block, expandedKey) {
     }
     return state;
 }
+// PKCS7 padding
 function pkcs7Pad(data, blockSize) {
     const padding = blockSize - (data.length % blockSize);
     const padded = new Uint8Array(data.length + padding);
@@ -202,6 +227,7 @@ function pkcs7Unpad(data) {
     }
     return data.subarray(0, data.length - padding);
 }
+// AES-CBC encrypt (pure JS fallback)
 function aesCbcEncryptFallback(plaintext, key, iv) {
     const expandedKey = aesKeyExpansion(key);
     const padded = pkcs7Pad(plaintext, 16);
@@ -209,6 +235,7 @@ function aesCbcEncryptFallback(plaintext, key, iv) {
     let prevBlock = iv;
     for (let i = 0; i < padded.length; i += 16) {
         const block = padded.slice(i, i + 16);
+        // XOR with previous ciphertext block (or IV for first block)
         for (let j = 0; j < 16; j++) {
             block[j] ^= prevBlock[j];
         }
@@ -218,6 +245,7 @@ function aesCbcEncryptFallback(plaintext, key, iv) {
     }
     return ciphertext;
 }
+// AES-CBC decrypt (pure JS fallback)
 function aesCbcDecryptFallback(ciphertext, key, iv) {
     const expandedKey = aesKeyExpansion(key);
     const plaintext = new Uint8Array(ciphertext.length);
@@ -225,6 +253,7 @@ function aesCbcDecryptFallback(ciphertext, key, iv) {
     for (let i = 0; i < ciphertext.length; i += 16) {
         const block = ciphertext.slice(i, i + 16);
         const decrypted = aesDecryptBlock(block, expandedKey);
+        // XOR with previous ciphertext block (or IV for first block)
         for (let j = 0; j < 16; j++) {
             decrypted[j] ^= prevBlock[j];
         }
@@ -233,16 +262,20 @@ function aesCbcDecryptFallback(ciphertext, key, iv) {
     }
     return pkcs7Unpad(plaintext);
 }
+// Generate random bytes (works in both secure and non-secure contexts)
 function getRandomBytes(length) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
         return crypto.getRandomValues(new Uint8Array(length));
     }
+    // Fallback for environments without crypto.getRandomValues
     const bytes = new Uint8Array(length);
     for (let i = 0; i < length; i++) {
         bytes[i] = Math.floor(Math.random() * 256);
     }
     return bytes;
 }
+// SHA256 constants
 const SHA256_K = new Uint32Array([
     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
     0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
@@ -256,6 +289,7 @@ const SHA256_K = new Uint32Array([
     0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
     0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
 ]);
+// SHA256 pure JS implementation
 function sha256Fallback(data) {
     function rotr(x, n) {
         return (x >>> n) | (x << (32 - n));
@@ -278,15 +312,19 @@ function sha256Fallback(data) {
     function gamma1(x) {
         return rotr(x, 17) ^ rotr(x, 19) ^ (x >>> 10);
     }
+    // Pre-processing
     const originalLength = data.length;
     const bitLength = originalLength * 8;
+    // Padding: append 1 bit, then zeros, then 64-bit length (big-endian)
     const paddingLength = (64 - ((originalLength + 9) % 64)) % 64;
     const padded = new Uint8Array(originalLength + 1 + paddingLength + 8);
     padded.set(data);
     padded[originalLength] = 0x80;
+    // Append length as big-endian 64-bit
     const view = new DataView(padded.buffer);
     view.setUint32(padded.length - 4, bitLength >>> 0, false);
     view.setUint32(padded.length - 8, Math.floor(bitLength / 0x100000000), false);
+    // Initialize hash values
     let h0 = 0x6a09e667;
     let h1 = 0xbb67ae85;
     let h2 = 0x3c6ef372;
@@ -295,8 +333,10 @@ function sha256Fallback(data) {
     let h5 = 0x9b05688c;
     let h6 = 0x1f83d9ab;
     let h7 = 0x5be0cd19;
+    // Process each 512-bit chunk
     const W = new Uint32Array(64);
     for (let i = 0; i < padded.length; i += 64) {
+        // Prepare message schedule
         for (let t = 0; t < 16; t++) {
             W[t] = view.getUint32(i + t * 4, false);
         }
@@ -345,7 +385,9 @@ function sha256Fallback(data) {
     resultView.setUint32(28, h7, false);
     return result;
 }
+// MD5 implementation for EVP_BytesToKey (required for crypto-js compatibility)
 function md5(data) {
+    // MD5 constants
     const S = [
         7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5,
         9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11,
@@ -368,19 +410,24 @@ function md5(data) {
     function leftRotate(x, c) {
         return (x << c) | (x >>> (32 - c));
     }
+    // Pre-processing: adding padding bits
     const originalLength = data.length;
     const bitLength = originalLength * 8;
+    // Append "1" bit and padding zeros
     const paddingLength = (56 - ((originalLength + 1) % 64) + 64) % 64;
     const padded = new Uint8Array(originalLength + 1 + paddingLength + 8);
     padded.set(data);
     padded[originalLength] = 0x80;
+    // Append original length in bits as 64-bit little-endian
     const view = new DataView(padded.buffer);
     view.setUint32(padded.length - 8, bitLength >>> 0, true);
     view.setUint32(padded.length - 4, Math.floor(bitLength / 0x100000000), true);
+    // Initialize hash values
     let a0 = 0x67452301;
     let b0 = 0xefcdab89;
     let c0 = 0x98badcfe;
     let d0 = 0x10325476;
+    // Process each 512-bit chunk
     for (let i = 0; i < padded.length; i += 64) {
         const M = new Uint32Array(16);
         for (let j = 0; j < 16; j++) {
@@ -428,6 +475,7 @@ function md5(data) {
     resultView.setUint32(12, d0, true);
     return result;
 }
+// EVP_BytesToKey - OpenSSL key derivation function used by crypto-js
 function evpBytesToKey(password, salt, keyLen, ivLen) {
     const result = new Uint8Array(keyLen + ivLen);
     let offset = 0;
@@ -446,13 +494,17 @@ function evpBytesToKey(password, salt, keyLen, ivLen) {
         iv: result.slice(keyLen, keyLen + ivLen),
     };
 }
+// Convert string to Uint8Array (UTF-8)
 function stringToBytes(str) {
     const encoded = new TextEncoder().encode(str);
+    // Return a copy with a fresh ArrayBuffer to satisfy TypeScript's strict typing
     return encoded.slice();
 }
+// Convert Uint8Array to string (UTF-8)
 function bytesToString(bytes) {
     return new TextDecoder().decode(bytes);
 }
+// Base64 encode
 function base64Encode(data) {
     let binary = '';
     for (const byte of data) {
@@ -460,6 +512,7 @@ function base64Encode(data) {
     }
     return btoa(binary);
 }
+// Base64 decode
 function base64Decode(str) {
     const binary = atob(str);
     const bytes = new Uint8Array(binary.length);
@@ -468,18 +521,25 @@ function base64Decode(str) {
     }
     return bytes;
 }
+/**
+ * AES encrypt compatible with crypto-js OpenSSL format
+ * Uses Web Crypto API when available, falls back to pure JS in non-secure contexts
+ */
 export async function aesEncrypt(plaintext, password) {
     const salt = getRandomBytes(8);
     const { key, iv } = evpBytesToKey(stringToBytes(password), salt, 32, 16);
     let encrypted;
     if (isWebCryptoAvailable()) {
         const cryptoKey = await crypto.subtle.importKey('raw', key, { name: 'AES-CBC' }, false, ['encrypt']);
+        // Web Crypto API handles PKCS7 padding automatically
         const encryptedBuffer = await crypto.subtle.encrypt({ name: 'AES-CBC', iv }, cryptoKey, stringToBytes(plaintext));
         encrypted = new Uint8Array(encryptedBuffer);
     }
     else {
+        // Fallback to pure JS implementation
         encrypted = aesCbcEncryptFallback(stringToBytes(plaintext), key, iv);
     }
+    // Format: "Salted__" + salt + ciphertext, then Base64
     const saltPrefix = stringToBytes(SALT_PREFIX);
     const result = new Uint8Array(saltPrefix.length + salt.length + encrypted.byteLength);
     result.set(saltPrefix);
@@ -487,8 +547,13 @@ export async function aesEncrypt(plaintext, password) {
     result.set(encrypted, saltPrefix.length + salt.length);
     return base64Encode(result);
 }
+/**
+ * AES decrypt compatible with crypto-js OpenSSL format
+ * Uses Web Crypto API when available, falls back to pure JS in non-secure contexts
+ */
 export async function aesDecrypt(ciphertext, password) {
     const data = base64Decode(ciphertext);
+    // Check for "Salted__" prefix
     const saltPrefix = stringToBytes(SALT_PREFIX);
     const hasSalt = data.length > saltPrefix.length &&
         bytesToString(data.subarray(0, saltPrefix.length)) === SALT_PREFIX;
@@ -501,14 +566,20 @@ export async function aesDecrypt(ciphertext, password) {
     let decrypted;
     if (isWebCryptoAvailable()) {
         const cryptoKey = await crypto.subtle.importKey('raw', key, { name: 'AES-CBC' }, false, ['decrypt']);
+        // Web Crypto API handles PKCS7 padding automatically
         const decryptedBuffer = await crypto.subtle.decrypt({ name: 'AES-CBC', iv }, cryptoKey, encrypted);
         decrypted = new Uint8Array(decryptedBuffer);
     }
     else {
+        // Fallback to pure JS implementation
         decrypted = aesCbcDecryptFallback(encrypted, key, iv);
     }
     return bytesToString(decrypted);
 }
+/**
+ * SHA256 hash
+ * Uses Web Crypto API when available, falls back to pure JS in non-secure contexts
+ */
 export async function sha256(data) {
     const encoded = stringToBytes(data);
     if (isWebCryptoAvailable()) {
@@ -517,19 +588,31 @@ export async function sha256(data) {
     }
     return sha256Fallback(encoded);
 }
+/**
+ * Base64 encode a Uint8Array
+ */
 export function toBase64(data) {
     return base64Encode(data);
 }
+/**
+ * URL-safe Base64 encode (for OAuth PKCE)
+ */
 export function toBase64Url(data) {
     return base64Encode(data)
         .replaceAll('+', '-')
         .replaceAll('/', '_')
         .replaceAll('=', '');
 }
+/**
+ * SHA256 hash and return as Base64 (for OAuth PKCE code challenge)
+ */
 export async function sha256Base64(data) {
     const hash = await sha256(data);
     return toBase64(hash);
 }
+/**
+ * SHA256 hash and return as URL-safe Base64 (for OAuth PKCE code challenge)
+ */
 export async function sha256Base64Url(data) {
     const hash = await sha256(data);
     return toBase64Url(hash);

package/esm/util/dataGridUtils.d.ts

@@ -0,0 +1,9 @@
+import type { GridRowId, GridRowSelectionModel } from '@mui/x-data-grid';
+export declare function measureGridWidth(elements: unknown[], args?: {
+    minWidth?: number;
+    fontSize?: number;
+    maxWidth?: number;
+    padding?: number;
+    stripHTML?: boolean;
+}): number;
+export declare function resolveSelectedIds(model: GridRowSelectionModel, allIds: Iterable<GridRowId>): Set<GridRowId>;

package/esm/util/dataGridUtils.js

@@ -0,0 +1,36 @@
+import { coarseStripHTML } from './coarseStripHTML.js';
+import { getStr } from './getStr.js';
+import { measureText } from './measureText.js';
+import { max } from './numericUtils.js';
+// The @mui/x-data-grid helpers, kept out of the `util` barrel: they are the
+// barrel's only reason to reach @mui/x-data-grid, and the barrel is imported by
+// worker-side adapter code that renders no grid.
+// heuristic measurement for a column of a @mui/x-data-grid, pass in
+// values from a column
+export function measureGridWidth(elements, args) {
+    const { padding = 30, minWidth = 80, fontSize = 12, maxWidth = 1000, stripHTML = false, } = args ?? {};
+    return max(elements.map(element => {
+        const str = getStr(element);
+        const n = measureText(stripHTML ? coarseStripHTML(str) : str, fontSize);
+        return Math.min(Math.max(n + padding, minWidth), maxWidth);
+    }));
+}
+// Resolve a @mui/x-data-grid v9 selection model into the concrete set of
+// selected row ids. The model is either an explicit include-set or an
+// exclude-set (the header "select all" checkbox produces the latter, e.g.
+// {type:'exclude', ids:{}} meaning "everything selected"), so reading model.ids
+// directly silently drops select-all and inverts a select-all-then-deselect.
+export function resolveSelectedIds(model, allIds) {
+    if (model.type === 'exclude') {
+        const result = new Set();
+        for (const id of allIds) {
+            if (!model.ids.has(id)) {
+                result.add(id);
+            }
+        }
+        return result;
+    }
+    else {
+        return new Set(model.ids);
+    }
+}

package/esm/util/dedupe.js

@@ -1,3 +1,4 @@
+// from https://github.com/seriousManual/dedupe/blob/master/LICENSE
 export function dedupe(list, hasher = JSON.stringify) {
     const clone = [];
     const lookup = new Set();

package/esm/util/deepEqual.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Structural equality: identity for primitives, recursive comparison for
+ * arrays/objects. Key order doesn't matter, unlike a `JSON.stringify`
+ * compare — which also can't tell `NaN` from `null` and silently drops
+ * `undefined`-valued keys, so `{ a: 1, b: undefined }` and `{ a: 1 }` would
+ * read as equal.
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;

package/esm/util/deepEqual.js

@@ -0,0 +1,22 @@
+import { isPlainObject } from './objectUtils.js';
+/**
+ * Structural equality: identity for primitives, recursive comparison for
+ * arrays/objects. Key order doesn't matter, unlike a `JSON.stringify`
+ * compare — which also can't tell `NaN` from `null` and silently drops
+ * `undefined`-valued keys, so `{ a: 1, b: undefined }` and `{ a: 1 }` would
+ * read as equal.
+ */
+export function deepEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((x, i) => deepEqual(x, b[i]));
+    }
+    if (isPlainObject(a) && isPlainObject(b)) {
+        const ak = Object.keys(a);
+        const bk = Object.keys(b);
+        return (ak.length === bk.length && ak.every(k => k in b && deepEqual(a[k], b[k])));
+    }
+    return false;
+}

package/esm/util/deepMerge.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Recursive merge of `override` onto `base`, where a nested plain object merges
+ * key by key and **an array replaces rather than concatenates**. Both operands
+ * are deep-cloned, so neither is aliased by the result — the theme defaults are
+ * a module-level constant and a shared nested reference would let one caller's
+ * merge corrupt every later one.
+ *
+ * Replacing arrays is the only behaviour any caller here wanted: `assemblyNames`
+ * on a multi-genome track has to become the contributed list, not
+ * `[thisAssembly, ...allAssemblies]`, and a theme that names its own array of
+ * anything means that array instead of the base's. It is also the reason this
+ * exists rather than calling `deepmerge`, whose first overload is
+ * `<T>(x: Partial<T>, y: Partial<T>) => T`: passed a `Record<string, unknown>`
+ * it inferred `T` from the index signature, erased the shape of the object
+ * literal being merged, and handed back something every caller re-narrowed by
+ * hand.
+ *
+ * Objects only — an array as `base` or `override` is not a case any caller has.
+ */
+export declare function deepMerge<T extends object>(base: T, override: object): T;

package/esm/util/deepMerge.js

@@ -0,0 +1,44 @@
+import { isPlainObject } from './objectUtils.js';
+function cloneValue(value) {
+    return Array.isArray(value)
+        ? value.map(cloneValue)
+        : isPlainObject(value)
+            ? Object.fromEntries(Object.entries(value).map(([k, v]) => [k, cloneValue(v)]))
+            : value;
+}
+/**
+ * Recursive merge of `override` onto `base`, where a nested plain object merges
+ * key by key and **an array replaces rather than concatenates**. Both operands
+ * are deep-cloned, so neither is aliased by the result — the theme defaults are
+ * a module-level constant and a shared nested reference would let one caller's
+ * merge corrupt every later one.
+ *
+ * Replacing arrays is the only behaviour any caller here wanted: `assemblyNames`
+ * on a multi-genome track has to become the contributed list, not
+ * `[thisAssembly, ...allAssemblies]`, and a theme that names its own array of
+ * anything means that array instead of the base's. It is also the reason this
+ * exists rather than calling `deepmerge`, whose first overload is
+ * `<T>(x: Partial<T>, y: Partial<T>) => T`: passed a `Record<string, unknown>`
+ * it inferred `T` from the index signature, erased the shape of the object
+ * literal being merged, and handed back something every caller re-narrowed by
+ * hand.
+ *
+ * Objects only — an array as `base` or `override` is not a case any caller has.
+ */
+export function deepMerge(base, override) {
+    const merged = {};
+    for (const [key, value] of Object.entries(base)) {
+        merged[key] = cloneValue(value);
+    }
+    for (const [key, value] of Object.entries(override)) {
+        const existing = merged[key];
+        merged[key] =
+            isPlainObject(existing) && isPlainObject(value)
+                ? deepMerge(existing, value)
+                : cloneValue(value);
+    }
+    // `merged` already holds a cloned copy of every string key `base` has, so the
+    // base spread is what keeps the result typed as `T` without a cast — the one
+    // thing it contributes at runtime is any symbol key, which neither loop sees.
+    return { ...base, ...merged };
+}

package/esm/util/diagonalizeRegions.d.ts

@@ -0,0 +1,23 @@
+import type { StatusCallback } from './progress.ts';
+import type { StopToken } from './stopToken.ts';
+import type { Region } from './types/data.ts';
+export interface AlignmentData {
+    refRefName: string;
+    queryRefName: string;
+    refStart: number;
+    refEnd: number;
+    queryStart: number;
+    queryEnd: number;
+    strand: number;
+}
+export interface DiagonalizationResult {
+    newRegions: Region[];
+    stats: {
+        regionsReordered: number;
+        regionsReversed: number;
+    };
+}
+export declare function diagonalizeRegions(alignments: AlignmentData[], referenceRegions: Region[], currentRegions: Region[], { stopToken, statusCallback, }?: {
+    stopToken?: StopToken;
+    statusCallback?: StatusCallback;
+}): Promise<DiagonalizationResult>;