@woosh/meep-engine 2.49.0 → 2.49.2

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.49.0",
+  "version": "2.49.2",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/binary/IndexedBinaryBVH.spec.js

@@ -0,0 +1,7 @@
+import IndexedBinaryBVH from "./IndexedBinaryBVH.js";
+
+test("constructor does not throw", () => {
+    expect(() => new IndexedBinaryBVH()).not.toThrow();
+});
+
+

package/src/core/collection/CuckooFilter.js

@@ -368,20 +368,20 @@ export class CuckooFilter {
     }
 
     /**
-     * Puts an element into this {@code CuckooFilter}. Ensures that subsequent
+     * Puts an element into this {@link CuckooFilter}. Ensures that subsequent
      * invocations of {@link #mightContain(Object)} with the same element will
-     * always return {@code true}.
-     * <p>
+     * always return `true`.
+     *
      * Note that the filter should be considered full after insertion failure.
      * Further inserts <i>may</i> fail, although deleting items can also make
      * the filter usable again.
-     * <p>
+     *
      * Also note that inserting the same item more than 8 times will cause an
      * insertion failure.
      *
      * @param {number} hash hash of item to insert
-     * @returns {boolean} {@code true} if the cuckoo filter inserts this item successfully.
-     *         Returns {@code false} if insertion failed.
+     * @returns {boolean} `true` if the cuckoo filter inserts this item successfully.
+     *         Returns `false` if insertion failed.
      */
     insert(hash) {
         const current_tag = this.__compute_tag_from_hash(hash);
@@ -461,22 +461,22 @@ export class CuckooFilter {
     }
 
     /**
-     * Deletes an element from this {@code CuckooFilter}. In most cases you
+     * Deletes an element from this {@link CuckooFilter}. In most cases you
      * should only delete items that have been previously added to the filter.
      * Attempting to delete non-existent items may successfully delete the wrong
      * item in the filter, causing a false negative. False negatives are defined
-     * as( {@code #mightContain(Object)} returning false for an item that
+     * as( {@link #mightContain(Object)} returning false for an item that
      * <i>has</i> been added to the filter. Deleting non-existent items doesn't
      * otherwise adversely affect the state of the filter, so attempting to
      * delete items that <i>may not</i> have been inserted is fine if false
      * negatives are acceptable. The false-delete rate is similar to the false
      * positive rate. False deletes can also cause the
-     * {@code #approximateCount(Object)} to return both lower and higher than
+     * {@link #approximateCount(Object)} to return both lower and higher than
      * the real count
      *
      * @param {number} hash
-     * @returns {boolean} {@code true} if the cuckoo filter deleted this item successfully.
-     *         Returns {@code false} if the item was not found.
+     * @returns {boolean} `true` if the cuckoo filter deleted this item successfully.
+     *         Returns `false` if the item was not found.
      */
     remove(hash) {
         const tag = this.__compute_tag_from_hash(hash);
@@ -508,8 +508,8 @@ export class CuckooFilter {
 
 
     /**
-     * Returns {@code true} if the element <i>might</i> have been put in this
-     * Cuckoo filter, {@code false} if this is <i>definitely</i> not the case.
+     * Returns `true` if the element <i>might</i> have been put in this
+     * Cuckoo filter, `false` if this is <i>definitely</i> not the case.
      *
      * @param {number} hash
      * @returns {boolean}
@@ -523,4 +523,4 @@ export class CuckooFilter {
                || (this.__victim_exists && this.__victim_tag === tag && (this.__victim_index === i1 || this.__victim_index === i2)) //check the victim
             ;
     }
-}
+}

package/src/core/geom/packing/miniball/Miniball.js

@@ -33,7 +33,7 @@ const MAX_ITERATIONS = 10000;
 /**
  * Computes the miniball of the given point set.
  *
- * Notice that the point set {@code pts} is assumed to be immutable during the computation. That
+ * Notice that the point set `pts` is assumed to be immutable during the computation. That
  * is, if you add, remove, or change points in the point set, you have to create a new instance of
  * {@link Miniball}.
  *
@@ -102,7 +102,7 @@ class Miniball {
     }
 
     /**
-     * Whether or not the miniball is the empty set, equivalently, whether {@code points.size() == 0}
+     * Whether or not the miniball is the empty set, equivalently, whether `points.size() == 0`
      * was true when this miniball instance was constructed.
      *
      * Notice that the miniball of a point set <i>S</i> is empty if and only if <i>S={}</i>.
@@ -115,8 +115,8 @@ class Miniball {
 
     /**
      * The radius of the miniball.
-     * <p>
-     * Precondition: {@code !isEmpty()}
+     *
+     * Precondition: `!isEmpty()`
      *
      * @return {number} the radius of the miniball, a number ≥ 0
      */
@@ -126,10 +126,10 @@ class Miniball {
 
     /**
      * The squared radius of the miniball.
-     * <p>
-     * This is equivalent to {@code radius() * radius()}.
-     * <p>
-     * Precondition: {@code !isEmpty()}
+     *
+     * This is equivalent to `radius() * radius()`.
+     *
+     * Precondition: `!isEmpty()`
      *
      * @return {number} the squared radius of the miniball
      */
@@ -139,8 +139,8 @@ class Miniball {
 
     /**
      * The Euclidean coordinates of the center of the miniball.
-     * <p>
-     * Precondition: {@code !isEmpty()}
+     *
+     * Precondition: `!isEmpty()`
      *
      * @return {number[]} an array holding the coordinates of the center of the miniball
      */
@@ -151,8 +151,8 @@ class Miniball {
     /**
      * The number of input points.
      *
-     * @return {number} the number of points in the original point set, i.e., {@code pts.size()} where
-     * {@code pts} was the {@link PointSet} instance passed to the constructor of this
+     * @return {number} the number of points in the original point set, i.e., `pts.size()` where
+     * `pts` was the {@link PointSet} instance passed to the constructor of this
      * instance
      */
     size() {
@@ -178,8 +178,8 @@ class Miniball {
      * Sets up the search ball with an arbitrary point of <i>S</i> as center and with exactly one of
      * the points farthest from center in the support. So the current ball contains all points of
      * <i>S</i> and has radius at most twice as large as the minball.
-     * <p>
-     * Precondition: {@code size > 0}
+     *
+     * Precondition: `size > 0`
      * @return {Subspan}
      * @private
      */
@@ -238,7 +238,7 @@ class Miniball {
 
     /**
      * The main function containing the main loop.
-     * <p>
+     *
      * Iteratively, we compute the point in support that is closest to the current center and then
      * walk towards this target as far as we can, i.e., we move until some new point touches the
      * boundary of the ball and must thus be inserted into support. In each of these two alternating
@@ -301,7 +301,7 @@ class Miniball {
      * {@link #successfulDrop()} elects a suitable point <i>k</i> to be removed from the support and
      * returns true. If the center lies in the convex hull, however, false is returned (and the
      * support remains unaltered).
-     * <p>
+     *
      * Precondition: center lies in <i>aff(support)</i>.
      * @return {boolean}
      */
@@ -334,10 +334,10 @@ class Miniball {
     }
 
     /**
-     * Given the center of the current enclosing ball and the walking direction {@code centerToAff},
+     * Given the center of the current enclosing ball and the walking direction `centerToAff`,
      * determine how much we can walk into this direction without losing a point from <i>S</i>. The
-     * (positive) factor by which we can walk along {@code centerToAff} is returned. Further,
-     * {@code stopper} is set to the index of the most restricting point and to -1 if no such point
+     * (positive) factor by which we can walk along `centerToAff` is returned. Further,
+     * `stopper` is set to the index of the most restricting point and to -1 if no such point
      * was found.
      * @return {number}
      * @private
@@ -403,7 +403,7 @@ class Miniball {
 
     /**
      * Verifies that the computed ball is indeed the miniball.
-     * <p>
+     *
      * This method should be called for testing purposes only; it may not be very efficient.
      * @return {Quality}
      */

package/src/core/geom/packing/miniball/Quality.js

@@ -30,7 +30,7 @@ class Quality {
 
     /**
      * A measure for the quality of the internally used support points.
-     * <p>
+     *
      * The returned number should in theory be zero (but may be non-zero due to rounding errors).
      * @return {number}
      */
@@ -52,12 +52,12 @@ class Quality {
     /**
      * The maximal over-length of a point from the input set, relative to the computed miniball's
      * radius.
-     * <p>
+     *
      * For each point <i>p</i> from the input point set, it is computed how far it is <i>outside</i>
      * the miniball ("over-length"). The returned number is the maximal such over-length, divided by
      * the radius of the computed miniball.
-     * <p>
-     * Notice that {@code getMaxOverlength() == 0} if and only if all points are contained in the
+     *
+     * Notice that `getMaxOverlength() == 0` if and only if all points are contained in the
      * miniball.
      *
      * @return {number} the maximal over-length, a number ≥ 0
@@ -69,12 +69,12 @@ class Quality {
     /**
      * The maximal under-length of a point from the input set, relative to the computed miniball's
      * radius.
-     * <p>
+     *
      * For each point <i>p</i> from the input point set, it is computed how far one has to walk from
      * this point towards the boundary of the miniball ("under-length"). The returned number is the
      * maximal such under-length, divided by the radius of the computed miniball.
-     * <p>
-     * Notice that in theory {@code getMaxUnderlength()} should be zero, otherwise the computed
+     *
+     * Notice that in theory `getMaxUnderlength()` should be zero, otherwise the computed
      * miniball is enclosing but not minimal.
      *
      * @return {number} the maximal under-length, a number ≥ 0
@@ -94,7 +94,7 @@ class Quality {
 
     /**
      * The size of the support.
-     * <p>
+     *
      * Refer to the documentation of {@link Miniball#support()} for more information on the
      * <i>support</i>.
      *

package/src/core/geom/packing/miniball/Subspan.js

@@ -117,8 +117,8 @@ export class Subspan {
     }
 
     /**
-     * The size of the instance's set <i>M</i>, a number between 0 and {@code dim+1}.
-     * <p>
+     * The size of the instance's set <i>M</i>, a number between 0 and `dim+1`.
+     *
      * Complexity: O(1).
      *
      * @returns {int} <i>|M|</i>
@@ -129,7 +129,7 @@ export class Subspan {
 
     /**
      * Whether <i>S[i]</i> is a member of <i>M</i>.
-     * <p>
+     *
      * Complexity: O(1)
      *
      * @param {int} i
@@ -142,10 +142,10 @@ export class Subspan {
 
     /**
      * The global index (into <i>S</i>) of an arbitrary element of <i>M</i>.
-     * <p>
-     * Precondition: {@code size()>0}
-     * <p>
-     * Postcondition: {@code isMember(anyMember())}
+     *
+     * Precondition: `size()>0`
+     *
+     * Postcondition: `isMember(anyMember())`
      * @returns {number}
      */
     anyMember() {
@@ -156,11 +156,11 @@ export class Subspan {
      * The index (into <i>S</i>) of the <i>i</i>th point in <i>M</i>. The points in <i>M</i> are
      * internally ordered (in an arbitrary way) and this order only changes when {@link add()} or
      * {@link remove()} is called.
-     * <p>
+     *
      * Complexity: O(1)
      *
      * @param {number} i
-     * the "local" index, 0 ≤ i < {@code size()}
+     * the "local" index, 0 ≤ i < `size()`
      * @return {number} <i>j</i> such that <i>S[j]</i> equals the <i>i</i>th point of M
      */
     globalIndex(i) {
@@ -184,7 +184,7 @@ export class Subspan {
     }
 
     /**
-     * The point {@code members[r]} is called the <i>origin</i>.
+     * The point `members[r]` is called the <i>origin</i>.
      *
      * @return {number} index into <i>S</i> of the origin.
      * @private
@@ -201,13 +201,13 @@ export class Subspan {
      * </pre>
      *
      * We don't care about the signs here, for efficiency, so make sure not to rely on them anywhere.
-     * <p>
+     *
      * <i>Source:</i> "Matrix Computations" (2nd edition) by Gene H. B. Golub & Charles F. B. Van Loan
      * (Johns Hopkins University Press, 1989), p. 216.
-     * <p>
+     *
      * Note that the code of this class sometimes does not call this method but only mentions it in a
      * comment. The reason for this is performance; Java does not allow an efficient way of returning
-     * a pair of doubles, so we sometimes manually "inline" {@code givens()} for the sake of
+     * a pair of doubles, so we sometimes manually "inline" `givens()` for the sake of
      * performance.
      * @param {number} a
      * @param {number} b
@@ -233,8 +233,8 @@ export class Subspan {
      * = QR</i>, updating <i>Q</i> and <i>R</i>. It assumes <i>r</i> to still be the old value, i.e.,
      * the index of the column used now for insertion; <i>r</i> is not altered by this routine and
      * should be changed by the caller afterwards.
-     * <p>
-     * Precondition: {@code r<dim}
+     *
+     * Precondition: `r<dim`
      * @private
      */
     appendColumn() {
@@ -268,9 +268,9 @@ export class Subspan {
 
     /**
      * Adds the point <i>S[index]</i> to the instance's set <i>M</i>.
-     * <p>
-     * Precondition: {@code !isMember(index)}
-     * <p>
+     *
+     * Precondition: `!isMember(index)`
+     *
      * Complexity: O(dim^2).
      *
      * @param {number} index
@@ -301,9 +301,9 @@ export class Subspan {
     /**
      * Computes the vector <i>w</i> directed from point <i>p</i> to <i>v</i>, where <i>v</i> is the
      * point in <i>aff(M)</i> that lies nearest to <i>p</i>.
-     * <p>
-     * Precondition: {@code size()}>0
-     * <p>
+     *
+     * Precondition: `size()>0`
+     *
      * Complexity: O(dim^2)
      *
      * @param {Array} p
@@ -389,14 +389,14 @@ export class Subspan {
     }
 
     /**
-     * Calculates the {@code size()}-many coefficients in the representation of <i>p</i> as an affine
+     * Calculates the `size()`-many coefficients in the representation of <i>p</i> as an affine
      * combination of the points <i>M</i>.
-     * <p>
-     * The <i>i</i>th computed coefficient {@code lambdas[i]} corresponds to the <i>i</i>th point in
-     * <i>M</i>, or, in other words, to the point in <i>S</i> with index {@code globalIndex(i)}.
-     * <p>
+     *
+     * The <i>i</i>th computed coefficient `lambdas[i] `corresponds to the <i>i</i>th point in
+     * <i>M</i>, or, in other words, to the point in <i>S</i> with index `globalIndex(i)`.
+     *
      * Complexity: O(dim^2)
-     * <p>
+     *
      * Preconditions: c lies in the affine hull aff(M) and size() > 0.
      * @param {Array} p
      * @param {Array} lambdas
@@ -441,7 +441,7 @@ export class Subspan {
     }
 
     /**
-     * Given <i>R</i> in lower Hessenberg form with subdiagonal entries 0 to {@code pos-1} already all
+     * Given <i>R</i> in lower Hessenberg form with subdiagonal entries 0 to `pos-1` already all
      * zero, clears the remaining subdiagonal entries via Givens rotations.
      * @param {number} pos
      * @private