immunum 0.9.0

package/README.md

@@ -0,0 +1,304 @@
+# immunum
+
+High-performance antibody and TCR sequence numbering in Rust, Python, and WebAssembly.
+
+## Overview
+
+`immunum` is a library for numbering antibody and T-cell receptor (TCR) variable domain sequences. It uses Needleman-Wunsch semi-global alignment against position-specific scoring matrices (PSSM) built from consensus sequences, with BLOSUM62-based substitution scores.
+
+Available as:
+- **Rust crate** — core library and CLI
+- **Python package** — via PyPI (`pip install immunum`), with a [Polars](https://pola.rs) plugin for vectorized batch processing
+- **npm package** — WebAssembly build for Node.js and browsers
+
+### Supported chains
+
+| Antibody | TCR |
+|----------|-----|
+| IGH (heavy) | TRA (alpha) |
+| IGK (kappa) | TRB (beta) |
+| IGL (lambda) | TRD (delta) |
+| | TRG (gamma) |
+
+### Numbering schemes
+
+- **IMGT** — all 7 chain types
+- **Kabat** — antibody chains (IGH, IGK, IGL)
+
+Chain type is automatically detected by aligning against all loaded chains and selecting the best match.
+
+## Python
+
+### Installation
+
+```bash
+pip install immunum
+```
+
+### Numbering
+
+```python
+from immunum import Annotator
+
+annotator = Annotator(chains=["H", "K", "L"], scheme="imgt")
+
+sequence = "QVQLVQSGAEVKRPGSSVTVSCKASGGSFSTYALSWVRQAPGRGLEWMGGVIPLLTITNYAPRFQGRITITADRSTSTAYLELNSLRPEDTAVYYCAREGTTGKPIGAFAHWGQGTLVTVSS"
+
+result = annotator.number(sequence)
+print(result.chain)       # H
+print(result.confidence)  # 0.97
+print(result.numbering)   # {"1": "E", "2": "V", "3": "Q", ...}
+```
+
+### Segmentation
+
+`segment` splits the sequence into FR/CDR regions:
+
+```python
+result = annotator.segment(sequence)
+print(result.fr1)   # EVQLVESGGGLVKPGGSLKLSCAAS
+print(result.cdr1)  # GFTFSSYAMS
+print(result.fr2)   # WVRQAPGKGLEWVS
+print(result.cdr2)  # AISGSGGS
+print(result.fr3)   # TYYADSVKGRFTISRDNAKN
+print(result.cdr3)  # ...
+print(result.fr4)   # ...
+```
+
+Chains: `"H"` (heavy), `"K"` (kappa), `"L"` (lambda), `"A"` (TRA), `"B"` (TRB), `"G"` (TRG), `"D"` (TRD).
+
+### Polars plugin
+
+For batch processing, `immunum.polars` registers elementwise Polars expressions:
+
+```python
+import polars as pl
+import immunum.polars as ip
+
+df = pl.DataFrame({"sequence": [
+    "QVQLVQSGAEVKRPGSSVTVSCKASGGSFSTYALSWVRQAPGRGLEWMGGVIPLLTITNYAPRFQGRITITADRSTSTAYLELNSLRPEDTAVYYCAREGTTGKPIGAFAHWGQGTLVTVSS",
+    "DIQMTQSPSSLSASVGDRVTITCRASQDVNTAVAWYQQKPGKAPKLLIYSASFLYSGVPSRFSGSRSGTDFTLTISSLQPEDFATYYCQQHYTTPPTFGQGTKVEIK",
+]})
+
+# Add a struct column with chain, scheme, confidence, numbering
+result = df.with_columns(
+    ip.number(pl.col("sequence"), chains=["H", "K", "L"], scheme="imgt").alias("numbered")
+)
+
+# Add a struct column with FR/CDR segments
+result = df.with_columns(
+    ip.segment(pl.col("sequence"), chains=["H", "K", "L"], scheme="imgt").alias("segmented")
+)
+```
+
+The `number` expression returns a struct with fields `chain`, `scheme`, `confidence`, and `numbering` (a struct of position→residue). The `segment` expression returns a struct with fields `fr1`, `cdr1`, `fr2`, `cdr2`, `fr3`, `cdr3`, `fr4`, `prefix`, `postfix`.
+
+## WebAssembly
+
+### Installation
+
+```bash
+npm install immunum
+```
+
+### Usage
+
+```js
+import init, { Annotator } from "immunum";
+
+await init(); // load the wasm module
+
+const annotator = new Annotator(["H", "K", "L"], "imgt");
+
+const sequence = "QVQLVQSGAEVKRPGSSVTVSCKASGGSFSTYALSWVRQAPGRGLEWMGGVIPLLTITNYAPRFQGRITITADRSTSTAYLELNSLRPEDTAVYYCAREGTTGKPIGAFAHWGQGTLVTVSS";
+
+const result = annotator.number(sequence);
+console.log(result.chain);       // "H"
+console.log(result.confidence);  // 0.97
+console.log(result.numbering);   // { "1": "E", "2": "V", ... }
+
+const segments = annotator.segment(sequence);
+console.log(segments.cdr3);
+
+annotator.free(); // or use `using annotator = new Annotator(...)` with explicit resource management
+```
+
+## Rust
+
+### Usage
+
+```rust
+use immunum::{Annotator, Chain, Scheme};
+
+let annotator = Annotator::new(
+    &[Chain::IGH, Chain::IGK, Chain::IGL],
+    Scheme::IMGT,
+    None, // uses default min_confidence of 0.5
+).unwrap();
+
+let sequence = "QVQLVQSGAEVKRPGSSVTVSCKASGGSFSTYALSWVRQAPGRGLEWMGGVIPLLTITNYAPRFQGRITITADRSTSTAYLELNSLRPEDTAVYYCAREGTTGKPIGAFAHWGQGTLVTVSS";
+
+let result = annotator.number(sequence).unwrap();
+
+println!("Chain: {}", result.chain);        // IGH
+println!("Confidence: {:.2}", result.confidence);
+
+for (aa, pos) in sequence.chars().zip(result.positions.iter()) {
+    println!("{} -> {}", aa, pos);
+}
+```
+
+## CLI
+
+```bash
+immunum number [OPTIONS] [INPUT] [OUTPUT]
+```
+
+### Options
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `-s, --scheme` | Numbering scheme: `imgt` (`i`), `kabat` (`k`) | `imgt` |
+| `-c, --chain` | Chain filter: `h`,`k`,`l`,`a`,`b`,`g`,`d` or groups: `ig`, `tcr`, `all`. Accepts any form (`h`, `heavy`, `igh`), case-insensitive. | `ig` |
+| `-f, --format` | Output format: `tsv`, `json`, `jsonl` | `tsv` |
+
+### Input
+
+Accepts a raw sequence, a FASTA file, or stdin (auto-detected):
+
+```bash
+immunum number EVQLVESGGGLVKPGGSLKLSCAASGFTFSSYAMS
+immunum number sequences.fasta
+cat sequences.fasta | immunum number
+immunum number - < sequences.fasta
+```
+
+### Output
+
+Writes to stdout by default, or to a file if a second positional argument is given:
+
+```bash
+immunum number sequences.fasta results.tsv
+immunum number -f json sequences.fasta results.json
+```
+
+### Examples
+
+```bash
+# Kabat scheme, JSON output
+immunum number -s kabat -f json EVQLVESGGGLVKPGGSLKLSCAASGFTFSSYAMS
+
+# All chains (antibody + TCR), JSONL output
+immunum number -c all -f jsonl sequences.fasta
+
+# TCR sequences only, save to file
+immunum number -c tcr tcr_sequences.fasta output.tsv
+
+# Extract sequences from a TSV column and pipe in (see fixtures/ig.tsv)
+tail -n +2 fixtures/ig.tsv | cut -f2 | immunum number
+awk -F'\t' 'NR==1{for(i=1;i<=NF;i++) if($i=="sequence") c=i} NR>1{print $c}' fixtures/ig.tsv | immunum number
+
+# Filter TSV output to CDR3 positions (111-128 in IMGT)
+immunum number sequences.fasta | awk -F'\t' '$4 >= 111 && $4 <= 128'
+
+# Filter to heavy chain results only
+immunum number -c all sequences.fasta | awk -F'\t' 'NR==1 || $2=="H"'
+
+# Extract CDR3 sequences with jq
+immunum number -f json sequences.fasta | jq '[.[] | {id: .sequence_id, numbering}]'
+```
+
+## Development
+
+To orchestrate a project between cargo and python, we use [`task`](http://taskfile.dev).
+You can install it with:
+
+```bash
+uv tool install go-task-bin
+```
+
+And then run `task` or `task --list-all` to get the full list of available tasks.
+
+By default, `dev` profile will be used in all but `behcnmark-*` taks, but you can change it
+via providing `PROFILE=release` to your task.
+
+Also, by default, `task` caches results, but you can ignore it by running `task my-task -f`.
+
+### Building local environment
+
+```bash
+# build a dev environment
+task build-local
+
+# build a dev environment with --release flag
+task build-local PROFILE=release
+```
+
+### Testing
+
+```bash
+task test-rust    # test only rust code
+task test-python  # test only python code
+task test         # test all code
+```
+
+### Linting
+
+```bash
+task format  # formats python and rust code
+task lint    # runs linting for python and rust
+```
+
+### Benchmarking
+
+There are multiple benchmarks in the repository. For full list, see `task | grep behcmark`:
+
+```bash
+$ task | grep benchmark
+* benchmark-accuracy:           Accuracy benchmark across all fixtures (1k sequences, 7 rounds each)
+* benchmark-cli:                Behcmark correctness of the CLI tool
+* benchmark-comparison:         Speed + correctness benchmark: immunum vs antpack vs anarci (1k IGH sequences)
+* benchmark-scaling:            Scaling benchmark: sizes 100..10M (10x steps), 1 round, H/imgt. Pass CLI_ARGS to filter tools, e.g. -- --tools immunum
+* benchmark-speed:              Speed benchmark across dataset sizes (100 to 1M sequences, 7 rounds, H/imgt)
+* benchmark-speed-polars:       Speed benchmark for immunum polars across all chain/scheme fixtures
+```
+
+## Project structure
+```
+src/
+├── main.rs          # CLI binary (immunum number ...)
+├── lib.rs           # Public API
+├── annotator.rs     # Sequence annotation and chain detection
+├── alignment.rs     # Needleman-Wunsch semi-global alignment
+├── io.rs            # Input parsing (FASTA, raw) and output formatting (TSV, JSON, JSONL)
+├── numbering.rs     # Numbering module entry point
+├── numbering/
+│   ├── imgt.rs      # IMGT numbering rules
+│   └── kabat.rs     # Kabat numbering rules
+├── scoring.rs       # PSSM and scoring matrices
+├── types.rs         # Core domain types (Chain, Scheme, Position)
+├── validation.rs    # Validation utilities
+├── error.rs         # Error types
+└── bin/
+    ├── benchmark.rs       # Validation metrics report
+    ├── debug_validation.rs # Alignment mismatch visualization
+    └── speed_benchmark.rs  # Performance benchmarks
+resources/
+└── consensus/       # Consensus sequence CSVs (compiled into scoring matrices)
+fixtures/
+├── validation/      # ANARCI-numbered reference datasets
+├── ig.fasta         # Example antibody sequences
+└── ig.tsv           # Example TSV input
+scripts/             # Python tooling for generating consensus data
+immunum/
+└── _internal.pyi    # python stub file for pyo3
+└── polars.py        # polars extension module
+└── python.py        # python module
+```
+
+### Design decisions
+
+- **Semi-global alignment** forces full query consumption, preventing long CDR3 regions from being treated as trailing gaps.
+- **Anchor positions** at highly conserved FR residues receive 3× gap penalties to stabilize alignment.
+- **FR regions** use alignment-based numbering; **CDR regions** use scheme-specific insertion rules.
+- Scoring matrices are generated at compile time from consensus data via `build.rs`.

package/immunum.d.ts

@@ -0,0 +1,41 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/** Numbered residues keyed by IMGT/Kabat position string (e.g. `"112A"`). */
+export type Numbering = Record<string, string>;
+
+/** Result returned by {@link Annotator.number}. */
+export interface NumberingResult {
+    /** Detected chain type: `"H"`, `"K"`, `"L"`, `"A"`, `"B"`, `"G"`, or `"D"`. */
+    chain: string;
+    /** Numbering scheme used: `"imgt"` or `"kabat"` */
+    scheme: string;
+    /** Alignment confidence score between 0 and 1. */
+    confidence: number;
+    /** Position-to-residue mapping for the aligned region. */
+    numbering: Numbering;
+}
+
+/** FR/CDR segments returned by {@link Annotator.segment}. */
+export interface SegmentationResult {
+    fr1: string;
+    cdr1: string;
+    fr2: string;
+    cdr2: string;
+    fr3: string;
+    cdr3: string;
+    fr4: string;
+    /** Residues before FR1 (non-canonical N-terminal extension). */
+    prefix: string;
+    /** Residues after FR4 (non-canonical C-terminal extension). */
+    postfix: string;
+}
+
+/** Annotator for numbering antibody and TCR sequences. */
+export class Annotator {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(chains: string[], scheme: string, min_confidence?: number | null);
+    number(sequence: string): NumberingResult;
+    segment(sequence: string): SegmentationResult;
+}

package/immunum.js

@@ -0,0 +1,307 @@
+/* @ts-self-types="./immunum.d.ts" */
+
+/**
+ * Annotator for numbering sequences
+ */
+class Annotator {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AnnotatorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_annotator_free(ptr, 0);
+    }
+    /**
+     * @param {string[]} chains
+     * @param {string} scheme
+     * @param {number | null} [min_confidence]
+     */
+    constructor(chains, scheme, min_confidence) {
+        const ptr0 = passArrayJsValueToWasm0(chains, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(scheme, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.annotator_new(ptr0, len0, ptr1, len1, isLikeNone(min_confidence) ? 0x100000001 : Math.fround(min_confidence));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        AnnotatorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {string} sequence
+     * @returns {any}
+     */
+    number(sequence) {
+        const ptr0 = passStringToWasm0(sequence, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.annotator_number(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} sequence
+     * @returns {any}
+     */
+    segment(sequence) {
+        const ptr0 = passStringToWasm0(sequence, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.annotator_segment(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) Annotator.prototype[Symbol.dispose] = Annotator.prototype.free;
+exports.Annotator = Annotator;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __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_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);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_new_ab79df5bd7c26067: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_set_7eaa4f96924fd6b3: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./immunum_bg.js": import0,
+    };
+}
+
+const AnnotatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_annotator_free(ptr >>> 0, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/immunum_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+wasm.__wbindgen_start();

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "immunum",
+  "collaborators": [
+    "ENPICOM <dev@enpicom.com>"
+  ],
+  "description": "Fast antibody and T-cell receptor numbering in Rust and Python",
+  "version": "0.9.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ENPICOM/immunum"
+  },
+  "files": [
+    "immunum_bg.wasm",
+    "immunum.js",
+    "immunum.d.ts"
+  ],
+  "main": "immunum.js",
+  "homepage": "https://immunum.enpicom.com",
+  "types": "immunum.d.ts",
+  "keywords": [
+    "antibody",
+    "numbering",
+    "schemes",
+    "python",
+    "imgt"
+  ]
+}