@molcrafts/molrs 0.0.4 → 0.0.5

package/molrs_bg.js

@@ -1,133 +1,3 @@
-/**
- * Axis-aligned bounding box spatial query for neighbor search.
- *
- * Builds a cell-list spatial index from a [`Frame`]'s atom positions
- * and simulation box, then supports both self-queries (unique pairs
- * within the reference set) and cross-queries (pairs between a
- * query set and the reference set).
- *
- * All distances are in angstrom (A).
- *
- * # Example (JavaScript)
- *
- * ```js
- * const nq = new AABBQuery(frame, 3.0); // cutoff = 3.0 A
- * const selfPairs = nq.querySelf();      // unique pairs (i < j)
- * const crossPairs = nq.query(otherFrame); // cross-query
- *
- * console.log(selfPairs.numPairs);
- * ```
- */
-export class AABBQuery {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        AABBQueryFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_aabbquery_free(ptr, 0);
-    }
-    /**
-     * Create a spatial query from a [`Frame`] with a given distance cutoff.
-     *
-     * The frame must have:
-     * - An `"atoms"` block with `x`, `y`, `z` (f32) columns
-     * - A `simbox` (simulation box) set on the frame
-     *
-     * # Arguments
-     *
-     * * `frame` - Reference frame with atom positions and simbox
-     * * `cutoff` - Maximum neighbor distance in angstrom (A)
-     *
-     * # Returns
-     *
-     * A new `AABBQuery` ready for `query()` or `querySelf()`.
-     *
-     * # Errors
-     *
-     * Throws if the frame has no `"atoms"` block, is missing `x`/`y`/`z`
-     * columns, or has no `simbox`.
-     *
-     * # Example (JavaScript)
-     *
-     * ```js
-     * const nq = new AABBQuery(frame, 5.0);
-     * ```
-     * @param {Frame} frame
-     * @param {number} cutoff
-     */
-    constructor(frame, cutoff) {
-        _assertClass(frame, Frame);
-        const ret = wasm.aabbquery_new(frame.__wbg_ptr, cutoff);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        AABBQueryFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Cross-query: find all pairs where `i` indexes query points and
-     * `j` indexes the reference points (from the constructor frame).
-     *
-     * # Arguments
-     *
-     * * `query_frame` - Frame with query atom positions (must have
-     *   `"atoms"` block with `x`, `y`, `z` columns)
-     *
-     * # Returns
-     *
-     * A [`NeighborList`] containing all `(i, j, distance)` pairs
-     * within the cutoff.
-     *
-     * # Errors
-     *
-     * Throws if `query_frame` is missing required columns.
-     *
-     * # Example (JavaScript)
-     *
-     * ```js
-     * const crossPairs = nq.query(otherFrame);
-     * console.log(crossPairs.numPairs);
-     * ```
-     * @param {Frame} query_frame
-     * @returns {NeighborList}
-     */
-    query(query_frame) {
-        _assertClass(query_frame, Frame);
-        const ret = wasm.aabbquery_query(this.__wbg_ptr, query_frame.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return NeighborList.__wrap(ret[0]);
-    }
-    /**
-     * Self-query: find all unique pairs `(i < j)` within the reference
-     * point set (the frame used to construct this query).
-     *
-     * # Returns
-     *
-     * A [`NeighborList`] containing all unique pairs within the cutoff.
-     * The `isSelfQuery` property will be `true`.
-     *
-     * # Example (JavaScript)
-     *
-     * ```js
-     * const pairs = nq.querySelf();
-     * console.log(pairs.isSelfQuery); // true
-     * console.log(pairs.numPairs);    // number of unique pairs
-     * ```
-     * @returns {NeighborList}
-     */
-    querySelf() {
-        const ret = wasm.aabbquery_querySelf(this.__wbg_ptr);
-        return NeighborList.__wrap(ret);
-    }
-}
-if (Symbol.dispose) AABBQuery.prototype[Symbol.dispose] = AABBQuery.prototype.free;
-
 /**
  * Column-oriented data store with typed arrays.
  *
@@ -142,7 +12,7 @@ if (Symbol.dispose) AABBQuery.prototype[Symbol.dispose] = AABBQuery.prototype.fr
  * | `Float32Array` | `f32` | `"f32"` | `setColF32` | `copyColF32` | `viewColF32` |
  * | `Int32Array` | `i32` | `"i32"` | `setColI32` | `copyColI32` | `viewColI32` |
  * | `Uint32Array` | `u32` | `"u32"` | `setColU32` | `copyColU32` | `viewColU32` |
- * | `Array<string>` | `String` | `"string"` | `setColStr` | `copyColStr` | -- |
+ * | `string[]` | `String` | `"string"` | `setColStr` | `copyColStr` | -- |
  *
  * # Example (JavaScript)
  *
@@ -239,7 +109,7 @@ export class Block {
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Owned `Array<string>` copy of a string column.
+     * Owned `string[]` copy of a string column.
      *
      * # Arguments
      *
@@ -344,7 +214,7 @@ export class Block {
      * # Example (JavaScript)
      *
      * ```js
-     * if (block.isEmpty()) { /* no columns yet */ }
+     * if (block.isEmpty()) { // no columns yet }
      * ```
      * @returns {boolean}
      */
@@ -356,7 +226,7 @@ export class Block {
         return ret[0] !== 0;
     }
     /**
-     * Return all column names as a JS `Array<string>`.
+     * Return all column names as a JS `string[]`.
      *
      * # Errors
      *
@@ -549,7 +419,7 @@ export class Block {
         }
     }
     /**
-     * Set a string column from a JS `Array<string>`.
+     * Set a string column from a JS `string[]`.
      *
      * # Arguments
      *
@@ -1290,8 +1160,8 @@ if (Symbol.dispose) Box.prototype[Symbol.dispose] = Box.prototype.free;
  * # Example (JavaScript)
  *
  * ```js
- * const ns = new NeighborSearch(2.0);
- * const nlist = ns.build(frame);
+ * const lc = new LinkedCell(2.0);
+ * const nlist = lc.build(frame);
  *
  * const cluster = new Cluster(5); // min 5 particles per cluster
  * const result = cluster.compute(frame, nlist);
@@ -1936,117 +1806,255 @@ export class LAMMPSReader {
 if (Symbol.dispose) LAMMPSReader.prototype[Symbol.dispose] = LAMMPSReader.prototype.free;
 
 /**
- * Mean squared displacement (MSD) relative to a reference configuration.
+ * Cell-list (linked-cell) based neighbor search.
  *
- * Computes MSD = <|r(t) - r(0)|^2> for each particle and the
- * system average. Useful for measuring diffusion coefficients
- * via the Einstein relation D = MSD / (6t).
+ * Creates a spatial index from a [`Frame`]'s atom positions and
+ * simulation box, then finds all neighbor pairs within the cutoff
+ * distance.
  *
- * All distances are in angstrom (A), so MSD is in A^2.
+ * All distances are in angstrom (A).
  *
  * # Example (JavaScript)
  *
  * ```js
- * const msd = MSD.fromReference(refFrame);
+ * const lc = new LinkedCell(3.0);       // cutoff = 3.0 A
+ * const nlist = lc.build(frame);         // self-query (unique pairs i < j)
+ * const cross = lc.query(ref, other);    // cross-query
  *
- * for (let t = 0; t < nFrames; t++) {
- *   const frame = reader.read(t);
- *   const result = msd.compute(frame);
- *   console.log(`t=${t}: MSD = ${result.mean} A^2`);
- * }
+ * console.log(nlist.numPairs);
  * ```
- *
- * # References
- *
- * - Einstein, A. (1905). *Annalen der Physik*, 322(8), 549-560.
  */
-export class MSD {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(MSD.prototype);
-        obj.__wbg_ptr = ptr;
-        MSDFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+export class LinkedCell {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MSDFinalization.unregister(this);
+        LinkedCellFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_msd_free(ptr, 0);
+        wasm.__wbg_linkedcell_free(ptr, 0);
     }
     /**
-     * Compute MSD for a frame relative to the stored reference.
+     * Build a neighbor list from a [`Frame`] (self-query).
+     *
+     * Finds all unique pairs `(i < j)` of atoms within the cutoff
+     * distance using the cell-list algorithm.
+     *
+     * The frame must have an `"atoms"` block with `x`, `y`, `z` (f32) columns.
+     * If the frame has a `simbox`, periodic boundary conditions are used.
+     * Otherwise, a free-boundary bounding box is auto-generated.
      *
      * # Arguments
      *
-     * * `frame` - Current frame with `"atoms"` block containing
-     *   `x`, `y`, `z` (f32) columns
+     * * `frame` - Frame with atom positions
      *
      * # Returns
      *
-     * An [`MSDResult`] with per-particle and system-average MSD
-     * values in A^2.
+     * A [`NeighborList`] containing all unique pairs within the cutoff.
      *
      * # Errors
      *
-     * Throws if the frame is missing required columns.
+     * Throws if the frame is missing required data.
      *
      * # Example (JavaScript)
      *
      * ```js
-     * const result = msd.compute(currentFrame);
-     * console.log(result.mean); // system-average MSD in A^2
+     * const lc = new LinkedCell(3.0);
+     * const nlist = lc.build(frame);
+     * const dists = nlist.distances(); // Float32Array
      * ```
      * @param {Frame} frame
-     * @returns {MSDResult}
+     * @returns {NeighborList}
      */
-    compute(frame) {
+    build(frame) {
         _assertClass(frame, Frame);
-        const ret = wasm.msd_compute(this.__wbg_ptr, frame.__wbg_ptr);
+        const ret = wasm.linkedcell_build(this.__wbg_ptr, frame.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return MSDResult.__wrap(ret[0]);
+        return NeighborList.__wrap(ret[0]);
     }
     /**
-     * Create an MSD analysis from a reference (t=0) frame.
+     * Create a linked-cell neighbor search with the given distance cutoff.
+     *
+     * # Arguments
+     *
+     * * `cutoff` - Maximum neighbor distance in angstrom (A)
+     *
+     * # Example (JavaScript)
      *
-     * The reference frame's `"atoms"` block must have `x`, `y`, `z`
-     * (f32) columns. These positions are stored internally and used
-     * as the baseline for all subsequent `compute()` calls.
+     * ```js
+     * const lc = new LinkedCell(5.0);
+     * ```
+     * @param {number} cutoff
+     */
+    constructor(cutoff) {
+        const ret = wasm.linkedcell_new(cutoff);
+        this.__wbg_ptr = ret >>> 0;
+        LinkedCellFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Cross-query: find all pairs where `i` indexes query points and
+     * `j` indexes the reference points.
      *
      * # Arguments
      *
-     * * `ref_frame` - Reference frame (typically the initial
-     *   configuration at t=0)
+     * * `ref_frame` - Frame with reference atom positions
+     * * `query_frame` - Frame with query atom positions (must have
+     *   `"atoms"` block with `x`, `y`, `z` columns)
      *
      * # Returns
      *
-     * A new `MSD` instance.
+     * A [`NeighborList`] containing all `(i, j, distance)` pairs
+     * within the cutoff.
      *
      * # Errors
      *
-     * Throws if the frame is missing required columns.
+     * Throws if either frame is missing required columns.
      *
      * # Example (JavaScript)
      *
      * ```js
-     * const msd = MSD.fromReference(initialFrame);
+     * const lc = new LinkedCell(3.0);
+     * const crossPairs = lc.query(refFrame, otherFrame);
+     * console.log(crossPairs.numPairs);
      * ```
      * @param {Frame} ref_frame
-     * @returns {MSD}
+     * @param {Frame} query_frame
+     * @returns {NeighborList}
      */
-    static fromReference(ref_frame) {
+    query(ref_frame, query_frame) {
         _assertClass(ref_frame, Frame);
-        const ret = wasm.msd_fromReference(ref_frame.__wbg_ptr);
+        _assertClass(query_frame, Frame);
+        const ret = wasm.linkedcell_query(this.__wbg_ptr, ref_frame.__wbg_ptr, query_frame.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return MSD.__wrap(ret[0]);
+        return NeighborList.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) LinkedCell.prototype[Symbol.dispose] = LinkedCell.prototype.free;
+
+/**
+ * Mean squared displacement (MSD) analysis.
+ *
+ * Computes MSD = |r(t) - r(0)|^2 for each particle and the system
+ * average. The first frame fed is automatically used as the reference.
+ * Useful for measuring diffusion coefficients via D = MSD / (6t).
+ *
+ * All distances are in angstrom (A), so MSD is in A^2.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const msd = new MSD();
+ * for (const frame of trajectory) {
+ *   msd.feed(frame);         // first frame = reference
+ * }
+ * const results = msd.results();  // MSDResult[] per frame
+ * console.log(results[10].mean);  // MSD at frame 10 in A^2
+ * ```
+ *
+ * # References
+ *
+ * - Einstein, A. (1905). *Annalen der Physik*, 322(8), 549-560.
+ */
+export class MSD {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MSDFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_msd_free(ptr, 0);
+    }
+    /**
+     * Number of frames accumulated.
+     * @returns {number}
+     */
+    get count() {
+        const ret = wasm.msd_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Feed a frame into the MSD analysis.
+     *
+     * The first frame sets the reference configuration.
+     * Subsequent frames compute MSD relative to that reference.
+     *
+     * # Arguments
+     *
+     * * `frame` - Frame with `"atoms"` block containing
+     *   `x`, `y`, `z` (f32) columns
+     *
+     * # Errors
+     *
+     * Throws if the frame is missing required columns or has a
+     * different number of atoms than the reference.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const msd = new MSD();
+     * msd.feed(frame0);  // sets reference
+     * msd.feed(frame1);  // computes MSD vs frame0
+     * ```
+     * @param {Frame} frame
+     */
+    feed(frame) {
+        _assertClass(frame, Frame);
+        const ret = wasm.msd_feed(this.__wbg_ptr, frame.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Create an empty MSD analysis.
+     *
+     * The first frame passed to [`feed`] becomes the reference
+     * configuration (t=0).
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const msd = new MSD();
+     * ```
+     */
+    constructor() {
+        const ret = wasm.msd_new();
+        this.__wbg_ptr = ret >>> 0;
+        MSDFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Reset the analysis, clearing reference and all results.
+     */
+    reset() {
+        wasm.msd_reset(this.__wbg_ptr);
+    }
+    /**
+     * Return all accumulated MSD results as an array.
+     *
+     * Returns one [`MSDResult`] per frame fed (including the
+     * reference frame, which has MSD = 0).
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const results = msd.results();
+     * results.forEach((r, t) => console.log(`t=${t}: MSD=${r.mean}`));
+     * ```
+     * @returns {MSDResult[]}
+     */
+    results() {
+        const ret = wasm.msd_results(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
     }
 }
 if (Symbol.dispose) MSD.prototype[Symbol.dispose] = MSD.prototype.free;
@@ -2111,9 +2119,8 @@ if (Symbol.dispose) MSDResult.prototype[Symbol.dispose] = MSDResult.prototype.fr
  * Result of a neighbor search: all atom pairs within a distance cutoff.
  *
  * Contains pair indices, distances, and squared distances for every
- * neighbor pair found. This object is produced by [`AABBQuery`] or
- * [`NeighborSearch`] and consumed by analysis classes like [`RDF`]
- * and [`Cluster`].
+ * neighbor pair found. This object is produced by [`LinkedCell`]
+ * and consumed by analysis classes like [`RDF`] and [`Cluster`].
  *
  * # Properties
  *
@@ -2127,7 +2134,7 @@ if (Symbol.dispose) MSDResult.prototype[Symbol.dispose] = MSDResult.prototype.fr
  * # Example (JavaScript)
  *
  * ```js
- * const nlist = nq.querySelf();
+ * const nlist = lc.build(frame);
  * console.log(nlist.numPairs);
  *
  * const i = nlist.queryPointIndices(); // Uint32Array
@@ -2180,31 +2187,7 @@ export class NeighborList {
         return v1;
     }
     /**
-     * **Deprecated**: Use `queryPointIndices()` instead.
-     *
-     * First particle index per pair as `Uint32Array`.
-     * @returns {Uint32Array}
-     */
-    idxI() {
-        const ret = wasm.neighborlist_idxI(this.__wbg_ptr);
-        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * **Deprecated**: Use `pointIndices()` instead.
-     *
-     * Second particle index per pair as `Uint32Array`.
-     * @returns {Uint32Array}
-     */
-    idxJ() {
-        const ret = wasm.neighborlist_idxJ(this.__wbg_ptr);
-        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * Whether this result came from a self-query (`querySelf()`).
+     * Whether this result came from a self-query (`build()`).
      *
      * In self-queries, only unique pairs `(i < j)` are reported.
      * @returns {boolean}
@@ -2265,154 +2248,6 @@ export class NeighborList {
 }
 if (Symbol.dispose) NeighborList.prototype[Symbol.dispose] = NeighborList.prototype.free;
 
-/**
- * **Deprecated**: backward-compatible alias for [`NeighborList`].
- *
- * Use [`NeighborList`] instead. This type is kept only for API
- * compatibility with older code.
- */
-export class NeighborResult {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        NeighborResultFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_neighborresult_free(ptr, 0);
-    }
-    /**
-     * Squared pairwise distances in A^2 as `Float32Array`.
-     * @returns {Float32Array}
-     */
-    distSq() {
-        const ret = wasm.neighborresult_distSq(this.__wbg_ptr);
-        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * First particle index per pair as `Uint32Array`.
-     * @returns {Uint32Array}
-     */
-    idxI() {
-        const ret = wasm.neighborresult_idxI(this.__wbg_ptr);
-        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * Second particle index per pair as `Uint32Array`.
-     * @returns {Uint32Array}
-     */
-    idxJ() {
-        const ret = wasm.neighborresult_idxJ(this.__wbg_ptr);
-        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * Total number of neighbor pairs found.
-     * @returns {number}
-     */
-    get numPairs() {
-        const ret = wasm.neighborresult_numPairs(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-}
-if (Symbol.dispose) NeighborResult.prototype[Symbol.dispose] = NeighborResult.prototype.free;
-
-/**
- * Neighbor search using the cell-list (link-cell) algorithm.
- *
- * This is a simpler, backward-compatible interface compared to
- * [`AABBQuery`]. It performs a self-query in a single `build()` call.
- *
- * Prefer [`AABBQuery`] for more flexibility (cross-queries, reusable
- * spatial index).
- *
- * # Example (JavaScript)
- *
- * ```js
- * const ns = new NeighborSearch(3.0); // cutoff = 3.0 A
- * const nbrs = ns.build(frame);
- * console.log(nbrs.numPairs);
- * ```
- */
-export class NeighborSearch {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        NeighborSearchFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_neighborsearch_free(ptr, 0);
-    }
-    /**
-     * Build a neighbor list from a [`Frame`].
-     *
-     * Performs a self-query: finds all unique pairs `(i < j)` of atoms
-     * within the cutoff distance, using the cell-list algorithm.
-     *
-     * The frame must have:
-     * - An `"atoms"` block with `x`, `y`, `z` (f32) columns
-     * - A `simbox` (simulation box) set on the frame
-     *
-     * # Arguments
-     *
-     * * `frame` - Frame with atom positions and simbox
-     *
-     * # Returns
-     *
-     * A [`NeighborList`] containing all pairs within the cutoff.
-     *
-     * # Errors
-     *
-     * Throws if the frame is missing required data.
-     *
-     * # Example (JavaScript)
-     *
-     * ```js
-     * const nbrs = ns.build(frame);
-     * const dists = nbrs.distances(); // Float32Array
-     * ```
-     * @param {Frame} frame
-     * @returns {NeighborList}
-     */
-    build(frame) {
-        _assertClass(frame, Frame);
-        const ret = wasm.neighborsearch_build(this.__wbg_ptr, frame.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return NeighborList.__wrap(ret[0]);
-    }
-    /**
-     * Create a neighbor search with the given distance cutoff.
-     *
-     * # Arguments
-     *
-     * * `cutoff` - Maximum neighbor distance in angstrom (A)
-     *
-     * # Example (JavaScript)
-     *
-     * ```js
-     * const ns = new NeighborSearch(5.0);
-     * ```
-     * @param {number} cutoff
-     */
-    constructor(cutoff) {
-        const ret = wasm.neighborsearch_new(cutoff);
-        this.__wbg_ptr = ret >>> 0;
-        NeighborSearchFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-}
-if (Symbol.dispose) NeighborSearch.prototype[Symbol.dispose] = NeighborSearch.prototype.free;
-
 /**
  * Protein Data Bank (PDB) file reader.
  *
@@ -2547,8 +2382,8 @@ if (Symbol.dispose) PDBReader.prototype[Symbol.dispose] = PDBReader.prototype.fr
  * # Example (JavaScript)
  *
  * ```js
- * const nq = new AABBQuery(frame, 5.0);
- * const nlist = nq.querySelf();
+ * const lc = new LinkedCell(5.0);
+ * const nlist = lc.build(frame);
  *
  * const rdf = new RDF(100, 5.0);
  * const result = rdf.compute(frame, nlist);
@@ -2577,8 +2412,7 @@ export class RDF {
      * # Arguments
      *
      * * `frame` - Frame with a `simbox` set (for volume normalization)
-     * * `neighbors` - Pre-built [`NeighborList`] from [`AABBQuery`]
-     *   or [`NeighborSearch`]
+     * * `neighbors` - Pre-built [`NeighborList`] from [`LinkedCell`]
      *
      * # Returns
      *
@@ -3634,6 +3468,10 @@ export function __wbg_length_ea16607d7b61445b(arg0) {
     const ret = arg0.length;
     return ret;
 }
+export function __wbg_msdresult_new(arg0) {
+    const ret = MSDResult.__wrap(arg0);
+    return ret;
+}
 export function __wbg_new_227d7c05414eb861() {
     const ret = new Error();
     return ret;
@@ -3718,9 +3556,6 @@ export function __wbindgen_init_externref_table() {
     table.set(offset + 2, true);
     table.set(offset + 3, false);
 }
-const AABBQueryFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_aabbquery_free(ptr >>> 0, 1));
 const BlockFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_block_free(ptr >>> 0, 1));
@@ -3739,6 +3574,9 @@ const FrameFinalization = (typeof FinalizationRegistry === 'undefined')
 const LAMMPSReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_lammpsreader_free(ptr >>> 0, 1));
+const LinkedCellFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_linkedcell_free(ptr >>> 0, 1));
 const MSDFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_msd_free(ptr >>> 0, 1));
@@ -3748,12 +3586,6 @@ const MSDResultFinalization = (typeof FinalizationRegistry === 'undefined')
 const NeighborListFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_neighborlist_free(ptr >>> 0, 1));
-const NeighborResultFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_neighborresult_free(ptr >>> 0, 1));
-const NeighborSearchFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_neighborsearch_free(ptr >>> 0, 1));
 const PDBReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pdbreader_free(ptr >>> 0, 1));
@@ -3863,6 +3695,17 @@ function getArrayI32FromWasm0(ptr, len) {
     return getInt32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
 
+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_command_export(ptr, len);
+    return result;
+}
+
 function getArrayU32FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);