@databio/gtars 0.7.0 → 0.8.0

package/gtars_js.js

@@ -143,6 +143,247 @@ export class ChromosomeStatistics {
 }
 if (Symbol.dispose) ChromosomeStatistics.prototype[Symbol.dispose] = ChromosomeStatistics.prototype.free;
 
+/**
+ * Builder for computing consensus regions from multiple RegionSet objects.
+ *
+ * Usage from JS:
+ * ```js
+ * const cb = new ConsensusBuilder();
+ * cb.add(rs1);
+ * cb.add(rs2);
+ * cb.add(rs3);
+ * const result = cb.compute(); // [{chr, start, end, count}, ...]
+ * ```
+ */
+export class ConsensusBuilder {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ConsensusBuilderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_consensusbuilder_free(ptr, 0);
+    }
+    /**
+     * @param {RegionSet} set
+     */
+    add(set) {
+        _assertClass(set, RegionSet);
+        wasm.consensusbuilder_add(this.__wbg_ptr, set.__wbg_ptr);
+    }
+    /**
+     * @returns {any}
+     */
+    compute() {
+        const ret = wasm.consensusbuilder_compute(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    constructor() {
+        const ret = wasm.consensusbuilder_new();
+        this.__wbg_ptr = ret >>> 0;
+        ConsensusBuilderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) ConsensusBuilder.prototype[Symbol.dispose] = ConsensusBuilder.prototype.free;
+
+export class GeneModel {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GeneModel.prototype);
+        obj.__wbg_ptr = ptr;
+        GeneModelFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GeneModelFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_genemodel_free(ptr, 0);
+    }
+    /**
+     * Construct a GeneModel from JS arrays of region tuples.
+     *
+     * Each array contains `[chr, start, end]` or `[chr, start, end, strand]` tuples.
+     * `threeUtr` and `fiveUtr` are optional (pass `null`/`undefined`).
+     * @param {any} genes
+     * @param {any} exons
+     * @param {any} three_utr
+     * @param {any} five_utr
+     */
+    constructor(genes, exons, three_utr, five_utr) {
+        const ret = wasm.genemodel_new(genes, exons, three_utr, five_utr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        GeneModelFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) GeneModel.prototype[Symbol.dispose] = GeneModel.prototype.free;
+
+export class GenomicDistAnnotation {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GenomicDistAnnotation.prototype);
+        obj.__wbg_ptr = ptr;
+        GenomicDistAnnotationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GenomicDistAnnotationFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_genomicdistannotation_free(ptr, 0);
+    }
+    /**
+     * Load a GenomicDistAnnotation from GDA binary bytes.
+     * @param {Uint8Array} bytes
+     * @returns {GenomicDistAnnotation}
+     */
+    static fromBin(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.genomicdistannotation_fromBin(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return GenomicDistAnnotation.__wrap(ret[0]);
+    }
+    /**
+     * Get the gene model as a JsGeneModel.
+     *
+     * Note: this clones the gene model data since WASM ownership requires it.
+     * @returns {GeneModel}
+     */
+    geneModel() {
+        const ret = wasm.genomicdistannotation_geneModel(this.__wbg_ptr);
+        return GeneModel.__wrap(ret);
+    }
+    /**
+     * Build a PartitionList from the gene model and provided chrom sizes.
+     *
+     * `chrom_sizes` should be a JS object like `{"chr1": 249250621, ...}`.
+     * @param {number} core_prom_size
+     * @param {number} prox_prom_size
+     * @param {any} chrom_sizes
+     * @returns {PartitionList}
+     */
+    partitionList(core_prom_size, prox_prom_size, chrom_sizes) {
+        const ret = wasm.genomicdistannotation_partitionList(this.__wbg_ptr, core_prom_size, prox_prom_size, chrom_sizes);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return PartitionList.__wrap(ret[0]);
+    }
+    /**
+     * Derive a TssIndex from gene starts + strand.
+     *
+     * Plus/Unstranded genes → TSS at start, Minus genes → TSS at end.
+     * @returns {TssIndex}
+     */
+    tssIndex() {
+        const ret = wasm.genomicdistannotation_tssIndex(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TssIndex.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) GenomicDistAnnotation.prototype[Symbol.dispose] = GenomicDistAnnotation.prototype.free;
+
+/**
+ * A LOLA region database for enrichment testing.
+ *
+ * Built in-memory from region data — no filesystem needed.
+ */
+export class LolaRegionDB {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LolaRegionDBFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_lolaregiondb_free(ptr, 0);
+    }
+    /**
+     * Collection-level annotations from the RegionDB.
+     *
+     * @returns Array of objects with keys: collectionname, collector, date, source, description
+     * @returns {any}
+     */
+    get collectionAnno() {
+        const ret = wasm.lolaregiondb_collectionAnno(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Extract region sets by 0-based indices as a RegionSetList.
+     *
+     * @param indices - Optional array of 0-based indices. If omitted, returns all.
+     * @param {Uint32Array | null} [indices]
+     * @returns {RegionSetList}
+     */
+    getRegionSets(indices) {
+        var ptr0 = isLikeNone(indices) ? 0 : passArray32ToWasm0(indices, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.lolaregiondb_getRegionSets(this.__wbg_ptr, ptr0, len0);
+        return RegionSetList.__wrap(ret);
+    }
+    /**
+     * List region set filenames.
+     * @returns {string[]}
+     */
+    listRegionSets() {
+        const ret = wasm.lolaregiondb_listRegionSets(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Create a LolaRegionDB from an array of {regions, name} objects.
+     *
+     * @param entries - Array of { regions: [["chr1", 100, 200], ...], name: "filename.bed" }
+     * @param {any} entries
+     */
+    constructor(entries) {
+        const ret = wasm.lolaregiondb_new(entries);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        LolaRegionDBFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Number of region sets in this database.
+     * @returns {number}
+     */
+    get numRegionSets() {
+        const ret = wasm.lolaregiondb_numRegionSets(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) LolaRegionDB.prototype[Symbol.dispose] = LolaRegionDB.prototype.free;
+
 export class Overlapper {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -198,6 +439,46 @@ export class Overlapper {
 }
 if (Symbol.dispose) Overlapper.prototype[Symbol.dispose] = Overlapper.prototype.free;
 
+export class PartitionList {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PartitionList.prototype);
+        obj.__wbg_ptr = ptr;
+        PartitionListFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PartitionListFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_partitionlist_free(ptr, 0);
+    }
+    /**
+     * Build a PartitionList from a GeneModel.
+     *
+     * `chromSizes` is an optional JS object `{"chr1": 249250621, ...}` for
+     * trimming promoters at chromosome boundaries.
+     * @param {GeneModel} model
+     * @param {number} core_prom_size
+     * @param {number} prox_prom_size
+     * @param {any} chrom_sizes
+     * @returns {PartitionList}
+     */
+    static fromGeneModel(model, core_prom_size, prox_prom_size, chrom_sizes) {
+        _assertClass(model, GeneModel);
+        const ret = wasm.partitionlist_fromGeneModel(model.__wbg_ptr, core_prom_size, prox_prom_size, chrom_sizes);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return PartitionList.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) PartitionList.prototype[Symbol.dispose] = PartitionList.prototype.free;
+
 export class RegionDistribution {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -213,6 +494,13 @@ export class RegionDistribution {
 if (Symbol.dispose) RegionDistribution.prototype[Symbol.dispose] = RegionDistribution.prototype.free;
 
 export class RegionSet {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RegionSet.prototype);
+        obj.__wbg_ptr = ptr;
+        RegionSetFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -223,6 +511,35 @@ export class RegionSet {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_regionset_free(ptr, 0);
     }
+    /**
+     * @returns {any}
+     */
+    calcNearestNeighbors() {
+        const ret = wasm.regionset_calcNearestNeighbors(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    calcNeighborDistances() {
+        const ret = wasm.regionset_calcNeighborDistances(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    calcWidths() {
+        const ret = wasm.regionset_calcWidths(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * @returns {any}
      */
@@ -238,7 +555,26 @@ export class RegionSet {
      */
     get classify() {
         const ret = wasm.regionset_classify(this.__wbg_ptr);
-        return BedClassificationOutput.__wrap(ret);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BedClassificationOutput.__wrap(ret[0]);
+    }
+    /**
+     * @param {RegionSet} other
+     * @returns {RegionSet}
+     */
+    concat(other) {
+        _assertClass(other, RegionSet);
+        const ret = wasm.regionset_concat(this.__wbg_ptr, other.__wbg_ptr);
+        return RegionSet.__wrap(ret);
+    }
+    /**
+     * @returns {RegionSet}
+     */
+    disjoin() {
+        const ret = wasm.regionset_disjoin(this.__wbg_ptr);
+        return RegionSet.__wrap(ret);
     }
     /**
      * @returns {string}
@@ -255,6 +591,23 @@ export class RegionSet {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @param {number} width
+     * @param {boolean} use_start
+     * @param {boolean} both
+     * @returns {RegionSet}
+     */
+    flank(width, use_start, both) {
+        const ret = wasm.regionset_flank(this.__wbg_ptr, width, use_start, both);
+        return RegionSet.__wrap(ret);
+    }
+    /**
+     * @returns {RegionSet}
+     */
+    gaps() {
+        const ret = wasm.regionset_gaps(this.__wbg_ptr);
+        return RegionSet.__wrap(ret);
+    }
     /**
      * @returns {string}
      */
@@ -270,6 +623,24 @@ export class RegionSet {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @param {RegionSet} other
+     * @returns {RegionSet}
+     */
+    intersect(other) {
+        _assertClass(other, RegionSet);
+        const ret = wasm.regionset_intersect(this.__wbg_ptr, other.__wbg_ptr);
+        return RegionSet.__wrap(ret);
+    }
+    /**
+     * @param {RegionSet} other
+     * @returns {number}
+     */
+    jaccard(other) {
+        _assertClass(other, RegionSet);
+        const ret = wasm.regionset_jaccard(this.__wbg_ptr, other.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {number}
      */
@@ -277,6 +648,16 @@ export class RegionSet {
         const ret = wasm.regionset_meanRegionWidth(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @param {number | null} [start]
+     * @param {number | null} [end]
+     * @param {number | null} [width]
+     * @returns {RegionSet}
+     */
+    narrow(start, end, width) {
+        const ret = wasm.regionset_narrow(this.__wbg_ptr, isLikeNone(start) ? 0x100000001 : (start) >>> 0, isLikeNone(end) ? 0x100000001 : (end) >>> 0, isLikeNone(width) ? 0x100000001 : (width) >>> 0);
+        return RegionSet.__wrap(ret);
+    }
     /**
      * @param {any} regions
      */
@@ -303,6 +684,31 @@ export class RegionSet {
         const ret = wasm.regionset_numberOfRegions(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @param {RegionSet} other
+     * @returns {RegionSet}
+     */
+    pintersect(other) {
+        _assertClass(other, RegionSet);
+        const ret = wasm.regionset_pintersect(this.__wbg_ptr, other.__wbg_ptr);
+        return RegionSet.__wrap(ret);
+    }
+    /**
+     * @param {number} upstream
+     * @param {number} downstream
+     * @returns {RegionSet}
+     */
+    promoters(upstream, downstream) {
+        const ret = wasm.regionset_promoters(this.__wbg_ptr, upstream, downstream);
+        return RegionSet.__wrap(ret);
+    }
+    /**
+     * @returns {RegionSet}
+     */
+    reduce() {
+        const ret = wasm.regionset_reduce(this.__wbg_ptr);
+        return RegionSet.__wrap(ret);
+    }
     /**
      * @param {number} n_bins
      * @returns {any}
@@ -314,9 +720,190 @@ export class RegionSet {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * @param {number} width
+     * @param {string} fix
+     * @returns {RegionSet}
+     */
+    resize(width, fix) {
+        const ptr0 = passStringToWasm0(fix, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.regionset_resize(this.__wbg_ptr, width, ptr0, len0);
+        return RegionSet.__wrap(ret);
+    }
+    /**
+     * @param {RegionSet} other
+     * @returns {RegionSet}
+     */
+    setdiff(other) {
+        _assertClass(other, RegionSet);
+        const ret = wasm.regionset_setdiff(this.__wbg_ptr, other.__wbg_ptr);
+        return RegionSet.__wrap(ret);
+    }
+    /**
+     * @param {bigint} offset
+     * @returns {RegionSet}
+     */
+    shift(offset) {
+        const ret = wasm.regionset_shift(this.__wbg_ptr, offset);
+        return RegionSet.__wrap(ret);
+    }
+    /**
+     * @param {any} chrom_sizes
+     * @returns {RegionSet}
+     */
+    trim(chrom_sizes) {
+        const ret = wasm.regionset_trim(this.__wbg_ptr, chrom_sizes);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RegionSet.__wrap(ret[0]);
+    }
+    /**
+     * @param {RegionSet} other
+     * @returns {RegionSet}
+     */
+    union(other) {
+        _assertClass(other, RegionSet);
+        const ret = wasm.regionset_union(this.__wbg_ptr, other.__wbg_ptr);
+        return RegionSet.__wrap(ret);
+    }
 }
 if (Symbol.dispose) RegionSet.prototype[Symbol.dispose] = RegionSet.prototype.free;
 
+/**
+ * A collection of RegionSets — the gtars equivalent of GRangesList.
+ */
+export class RegionSetList {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RegionSetList.prototype);
+        obj.__wbg_ptr = ptr;
+        RegionSetListFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RegionSetListFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_regionsetlist_free(ptr, 0);
+    }
+    /**
+     * Flatten all region sets into a single RegionSet (no merging).
+     * @returns {RegionSet}
+     */
+    concat() {
+        const ret = wasm.regionsetlist_concat(this.__wbg_ptr);
+        return RegionSet.__wrap(ret);
+    }
+    /**
+     * Get a region set by 0-based index.
+     * @param {number} index
+     * @returns {RegionSet}
+     */
+    get(index) {
+        const ret = wasm.regionsetlist_get(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RegionSet.__wrap(ret[0]);
+    }
+    /**
+     * Number of region sets in this list.
+     * @returns {number}
+     */
+    get length() {
+        const ret = wasm.regionsetlist_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the names of the region sets, or null if unnamed.
+     * @returns {any}
+     */
+    get names() {
+        const ret = wasm.regionsetlist_names(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Compute pairwise Jaccard similarity for all pairs of region sets.
+     *
+     * Returns { matrix: number[][], names: string[] | null }.
+     * @returns {any}
+     */
+    pairwiseJaccard() {
+        const ret = wasm.regionsetlist_pairwiseJaccard(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) RegionSetList.prototype[Symbol.dispose] = RegionSetList.prototype.free;
+
+export class SignalMatrix {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SignalMatrix.prototype);
+        obj.__wbg_ptr = ptr;
+        SignalMatrixFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignalMatrixFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signalmatrix_free(ptr, 0);
+    }
+    /**
+     * Load a SignalMatrix from packed binary bytes.
+     * @param {Uint8Array} bytes
+     * @returns {SignalMatrix}
+     */
+    static fromBin(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signalmatrix_fromBin(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SignalMatrix.__wrap(ret[0]);
+    }
+    /**
+     * Construct a SignalMatrix from JS data.
+     *
+     * - `regionIds`: array of strings in `"chr_start_end"` format
+     * - `conditionNames`: array of condition/cell-type names
+     * - `values`: flat row-major array of signal values
+     * - `nRegions`: number of rows (regions)
+     * - `nConditions`: number of columns (conditions)
+     * @param {any} region_ids
+     * @param {any} condition_names
+     * @param {Float64Array} values
+     * @param {number} n_regions
+     * @param {number} n_conditions
+     */
+    constructor(region_ids, condition_names, values, n_regions, n_conditions) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signalmatrix_new(region_ids, condition_names, ptr0, len0, n_regions, n_conditions);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        SignalMatrixFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) SignalMatrix.prototype[Symbol.dispose] = SignalMatrix.prototype.free;
+
 export class Tokenizer {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -567,6 +1154,128 @@ export class Tokenizer {
 }
 if (Symbol.dispose) Tokenizer.prototype[Symbol.dispose] = Tokenizer.prototype.free;
 
+export class TssIndex {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TssIndex.prototype);
+        obj.__wbg_ptr = ptr;
+        TssIndexFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TssIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tssindex_free(ptr, 0);
+    }
+    /**
+     * Calculate signed distance from each query region to its nearest feature.
+     *
+     * Positive = feature is downstream, negative = feature is upstream.
+     * Returns an array where `null` indicates no features on that chromosome
+     * (sentinel `i64::MAX` in Rust → `null` in JS).
+     * @param {RegionSet} query
+     * @returns {any}
+     */
+    calcFeatureDistances(query) {
+        _assertClass(query, RegionSet);
+        const ret = wasm.tssindex_calcFeatureDistances(this.__wbg_ptr, query.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Calculate unsigned distance from each query region to its nearest feature midpoint.
+     *
+     * Returns an array where `null` indicates no features on that chromosome
+     * (sentinel `u32::MAX` in Rust → `null` in JS).
+     * @param {RegionSet} query
+     * @returns {any}
+     */
+    calcTssDistances(query) {
+        _assertClass(query, RegionSet);
+        const ret = wasm.tssindex_calcTssDistances(this.__wbg_ptr, query.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Build a TssIndex from a RegionSet of features (e.g. TSS sites).
+     *
+     * Clones the inner RegionSet and computes sorted midpoints per chromosome.
+     * @param {RegionSet} features
+     */
+    constructor(features) {
+        _assertClass(features, RegionSet);
+        const ret = wasm.tssindex_new(features.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        TssIndexFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) TssIndex.prototype[Symbol.dispose] = TssIndex.prototype.free;
+
+/**
+ * Compute observed vs expected partition enrichment.
+ * @param {RegionSet} region_set
+ * @param {PartitionList} partition_list
+ * @param {any} chrom_sizes
+ * @param {boolean} bp_proportion
+ * @returns {any}
+ */
+export function calcExpectedPartitions(region_set, partition_list, chrom_sizes, bp_proportion) {
+    _assertClass(region_set, RegionSet);
+    _assertClass(partition_list, PartitionList);
+    const ret = wasm.calcExpectedPartitions(region_set.__wbg_ptr, partition_list.__wbg_ptr, chrom_sizes, bp_proportion);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Classify query regions into partitions.
+ * @param {RegionSet} region_set
+ * @param {PartitionList} partition_list
+ * @param {boolean} bp_proportion
+ * @returns {any}
+ */
+export function calcPartitions(region_set, partition_list, bp_proportion) {
+    _assertClass(region_set, RegionSet);
+    _assertClass(partition_list, PartitionList);
+    const ret = wasm.calcPartitions(region_set.__wbg_ptr, partition_list.__wbg_ptr, bp_proportion);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Compute summary signal: overlap query regions with a signal matrix,
+ * take MAX per condition, and compute boxplot statistics.
+ * @param {RegionSet} region_set
+ * @param {SignalMatrix} signal_matrix
+ * @returns {any}
+ */
+export function calcSummarySignal(region_set, signal_matrix) {
+    _assertClass(region_set, RegionSet);
+    _assertClass(signal_matrix, SignalMatrix);
+    const ret = wasm.calcSummarySignal(region_set.__wbg_ptr, signal_matrix.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Canonicalize a JSON string according to RFC-8785.
  *
@@ -601,6 +1310,24 @@ export function canonicalizeJsonString(json_str) {
     }
 }
 
+/**
+ * Check whether the universe is appropriate for the given user sets.
+ *
+ * @param userSets - Array of arrays of [chr, start, end] tuples
+ * @param universe - Array of [chr, start, end] tuples
+ * @returns Object with column arrays: userSet, totalRegions, regionsInUniverse, coverage, manyToMany, warnings
+ * @param {any} user_sets
+ * @param {any} universe_regions
+ * @returns {any}
+ */
+export function checkUniverseAppropriateness(user_sets, universe_regions) {
+    const ret = wasm.checkUniverseAppropriateness(user_sets, universe_regions);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Compute the MD5 digest of a string.
  *
@@ -832,6 +1559,33 @@ export function greet(name) {
     wasm.greet(ptr0, len0);
 }
 
+/**
+ * Run LOLA enrichment analysis.
+ *
+ * @param userSets - Array of arrays of [chr, start, end] tuples
+ * @param universe - Array of [chr, start, end] tuples
+ * @param regionDb - A LolaRegionDB object
+ * @param minOverlap - Minimum bp overlap (default 1)
+ * @param direction - "enrichment" or "depletion" (default "enrichment")
+ * @returns Object with column arrays: userSet, dbSet, pValueLog, oddsRatio, support, etc.
+ * @param {any} user_sets
+ * @param {any} universe_regions
+ * @param {LolaRegionDB} region_db
+ * @param {number | null} [min_overlap]
+ * @param {string | null} [direction]
+ * @returns {any}
+ */
+export function runLOLA(user_sets, universe_regions, region_db, min_overlap, direction) {
+    _assertClass(region_db, LolaRegionDB);
+    var ptr0 = isLikeNone(direction) ? 0 : passStringToWasm0(direction, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.runLOLA(user_sets, universe_regions, region_db.__wbg_ptr, isLikeNone(min_overlap) ? 0x100000001 : (min_overlap) >> 0, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Compute a sequence digest (sha512t24u) from raw sequence data.
  *
@@ -898,7 +1652,7 @@ export function sequenceMd5(sequence) {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_dbcd8782dbb273a2: function(arg0, arg1) {
+        __wbg_Error_83742b46f01ce22d: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -909,42 +1663,68 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_boolean_get_7f1c4dd217655ab6: function(arg0) {
+        __wbg___wbindgen_bigint_get_as_i64_447a76b5c6ef7bda: function(arg0, arg1) {
+            const v = arg1;
+            const ret = typeof(v) === 'bigint' ? v : undefined;
+            getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_boolean_get_c0f3f60bac5a78d1: function(arg0) {
             const v = arg0;
             const ret = typeof(v) === 'boolean' ? v : undefined;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
-        __wbg___wbindgen_debug_string_6cf0badf0b90f6ef: function(arg0, arg1) {
+        __wbg___wbindgen_debug_string_5398f5bb970e0daa: function(arg0, arg1) {
             const ret = debugString(arg1);
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_is_function_4500d4795b15e70b: function(arg0) {
+        __wbg___wbindgen_in_41dbb8413020e076: function(arg0, arg1) {
+            const ret = arg0 in arg1;
+            return ret;
+        },
+        __wbg___wbindgen_is_bigint_e2141d4f045b7eda: function(arg0) {
+            const ret = typeof(arg0) === 'bigint';
+            return ret;
+        },
+        __wbg___wbindgen_is_function_3c846841762788c1: function(arg0) {
             const ret = typeof(arg0) === 'function';
             return ret;
         },
-        __wbg___wbindgen_is_object_f8b6723c60349a13: function(arg0) {
+        __wbg___wbindgen_is_null_0b605fc6b167c56f: function(arg0) {
+            const ret = arg0 === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_781bc9f159099513: function(arg0) {
             const val = arg0;
             const ret = typeof(val) === 'object' && val !== null;
             return ret;
         },
-        __wbg___wbindgen_is_string_89134e23eba104e4: function(arg0) {
+        __wbg___wbindgen_is_string_7ef6b97b02428fae: function(arg0) {
             const ret = typeof(arg0) === 'string';
             return ret;
         },
-        __wbg___wbindgen_jsval_loose_eq_3173dea557396a92: function(arg0, arg1) {
+        __wbg___wbindgen_is_undefined_52709e72fb9f179c: function(arg0) {
+            const ret = arg0 === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_eq_ee31bfad3e536463: function(arg0, arg1) {
+            const ret = arg0 === arg1;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_loose_eq_5bcc3bed3c69e72b: function(arg0, arg1) {
             const ret = arg0 == arg1;
             return ret;
         },
-        __wbg___wbindgen_number_get_3330675b4e5c3680: function(arg0, arg1) {
+        __wbg___wbindgen_number_get_34bb9d9dcfa21373: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'number' ? obj : undefined;
             getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
         },
-        __wbg___wbindgen_string_get_7b8bc463f6cbeefe: function(arg0, arg1) {
+        __wbg___wbindgen_string_get_395e606bd0ee4427: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;
             var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -952,29 +1732,41 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_throw_89ca9e2c67795ec1: function(arg0, arg1) {
+        __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_alert_3ede886592780cb6: function(arg0, arg1) {
+        __wbg_alert_42dff0589bd812e0: function(arg0, arg1) {
             alert(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_call_eb691bc2f5533064: function() { return handleError(function (arg0, arg1) {
+        __wbg_call_e133b57c9155d22c: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.call(arg1);
             return ret;
         }, arguments); },
-        __wbg_done_82b14aeb31e98db6: function(arg0) {
+        __wbg_done_08ce71ee07e3bd17: function(arg0) {
             const ret = arg0.done;
             return ret;
         },
-        __wbg_get_ed44f5f876f22351: function() { return handleError(function (arg0, arg1) {
+        __wbg_entries_e8a20ff8c9757101: function(arg0) {
+            const ret = Object.entries(arg0);
+            return ret;
+        },
+        __wbg_get_326e41e095fb2575: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(arg0, arg1);
             return ret;
         }, arguments); },
-        __wbg_get_unchecked_ae4d1600970be7c3: function(arg0, arg1) {
+        __wbg_get_a8ee5c45dabc1b3b: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_get_unchecked_329cfe50afab7352: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
-        __wbg_instanceof_ArrayBuffer_4f2b9b5ed416155d: function(arg0) {
+        __wbg_get_with_ref_key_f38bf27dc398d91b: function(arg0, arg1) {
+            const ret = arg0[arg1];
+            return ret;
+        },
+        __wbg_instanceof_ArrayBuffer_101e2bf31071a9f6: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof ArrayBuffer;
@@ -984,7 +1776,7 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_Uint8Array_6482c66fce35827d: function(arg0) {
+        __wbg_instanceof_Uint8Array_740438561a5b956d: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof Uint8Array;
@@ -994,64 +1786,64 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_isArray_fe5201bfdab7e39d: function(arg0) {
+        __wbg_isArray_33b91feb269ff46e: function(arg0) {
             const ret = Array.isArray(arg0);
             return ret;
         },
-        __wbg_isSafeInteger_d6215c7562dbc4db: function(arg0) {
+        __wbg_isSafeInteger_ecd6a7f9c3e053cd: function(arg0) {
             const ret = Number.isSafeInteger(arg0);
             return ret;
         },
-        __wbg_iterator_63c3a1857203cf2f: function() {
+        __wbg_iterator_d8f549ec8fb061b1: function() {
             const ret = Symbol.iterator;
             return ret;
         },
-        __wbg_length_f875d3a041bab91a: function(arg0) {
+        __wbg_length_b3416cf66a5452c8: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_length_feaf2a40e5f9755a: function(arg0) {
+        __wbg_length_ea16607d7b61445b: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_new_5947ca72f3fee3e6: function() {
+        __wbg_new_49d5571bd3f0c4d4: function() {
             const ret = new Map();
             return ret;
         },
-        __wbg_new_6e7681a5f6f98ceb: function(arg0) {
+        __wbg_new_5f486cdf45a04d78: function(arg0) {
             const ret = new Uint8Array(arg0);
             return ret;
         },
-        __wbg_new_6feff3e11e4d0799: function() {
-            const ret = new Object();
+        __wbg_new_a70fbab9066b301f: function() {
+            const ret = new Array();
             return ret;
         },
-        __wbg_new_ff7f9cc4c9a4a0cf: function() {
-            const ret = new Array();
+        __wbg_new_ab79df5bd7c26067: function() {
+            const ret = new Object();
             return ret;
         },
-        __wbg_next_ae5b710aea83f41e: function() { return handleError(function (arg0) {
+        __wbg_next_11b99ee6237339e3: function() { return handleError(function (arg0) {
             const ret = arg0.next();
             return ret;
         }, arguments); },
-        __wbg_next_f577b3e02c9be709: function(arg0) {
+        __wbg_next_e01a967809d1aa68: function(arg0) {
             const ret = arg0.next;
             return ret;
         },
-        __wbg_prototypesetcall_37f00e1be5c4015a: function(arg0, arg1, arg2) {
+        __wbg_prototypesetcall_d62e5099504357e6: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
-        __wbg_set_601f3e1d081df3ac: function(arg0, arg1, arg2) {
+        __wbg_set_282384002438957f: function(arg0, arg1, arg2) {
             arg0[arg1 >>> 0] = arg2;
         },
-        __wbg_set_b1226382f10be917: function(arg0, arg1, arg2) {
+        __wbg_set_bf7251625df30a02: function(arg0, arg1, arg2) {
             const ret = arg0.set(arg1, arg2);
             return ret;
         },
         __wbg_set_d1cb61e9f39c870f: function(arg0, arg1, arg2) {
             arg0[arg1] = arg2;
         },
-        __wbg_value_3e1fdb73e1353fb3: function(arg0) {
+        __wbg_value_21fc78aab0322612: function(arg0) {
             const ret = arg0.value;
             return ret;
         },
@@ -1060,12 +1852,17 @@ function __wbg_get_imports() {
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000002: function(arg0) {
+            // Cast intrinsic for `I64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000003: function(arg0) {
+        __wbindgen_cast_0000000000000004: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return ret;
@@ -1092,18 +1889,42 @@ const BedClassificationOutputFinalization = (typeof FinalizationRegistry === 'un
 const ChromosomeStatisticsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_chromosomestatistics_free(ptr >>> 0, 1));
+const ConsensusBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_consensusbuilder_free(ptr >>> 0, 1));
+const GeneModelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_genemodel_free(ptr >>> 0, 1));
+const GenomicDistAnnotationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_genomicdistannotation_free(ptr >>> 0, 1));
+const LolaRegionDBFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_lolaregiondb_free(ptr >>> 0, 1));
 const OverlapperFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_overlapper_free(ptr >>> 0, 1));
+const PartitionListFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_partitionlist_free(ptr >>> 0, 1));
 const RegionDistributionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_regiondistribution_free(ptr >>> 0, 1));
 const RegionSetFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_regionset_free(ptr >>> 0, 1));
+const RegionSetListFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_regionsetlist_free(ptr >>> 0, 1));
+const SignalMatrixFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signalmatrix_free(ptr >>> 0, 1));
 const TokenizerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tokenizer_free(ptr >>> 0, 1));
+const TssIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tssindex_free(ptr >>> 0, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -1111,6 +1932,12 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -1176,6 +2003,22 @@ function debugString(val) {
     return className;
 }
 
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -1189,11 +2032,27 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return decodeText(ptr, len);
 }
 
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -1215,6 +2074,13 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -1222,6 +2088,13 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -1299,6 +2172,8 @@ function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     wasmModule = module;
     cachedDataViewMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
     wasm.__wbindgen_start();
     return wasm;