@woosh/meep-engine 2.113.16 → 2.115.0

package/build/meep.module.js

@@ -47413,7 +47413,7 @@ class Vector2 {
 
     /**
      *
-     * @param {number[]} array
+     * @param {number[]|Float32Array} array
      * @param {number} offset
      */
     fromArray(array, offset = 0) {
@@ -47425,7 +47425,7 @@ class Vector2 {
 
     /**
      *
-     * @param {number[]} array
+     * @param {number[]|Float32Array} array
      * @param {number} offset
      */
     toArray(array, offset = 0) {
@@ -49001,6 +49001,34 @@ function compute_typed_array_constructor_from_data_type(dt) {
     return r;
 }
 
+/**
+ * Useful for computing hashes of large arrays, can pick a relevant stride and skip large chunks of memory while still capturing good amount of unique information from evenly-spaced areas of the array
+ * @param {number[]|Uint32Array|Uint16Array|Uint8Array} array
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} stride
+ * @return {number}
+ */
+function computeStridedIntegerArrayHash(
+    array, offset, length, stride
+) {
+    let hash = length;
+
+    for (let i = offset; i < length; i += stride) {
+        const value = array[i] >>> 0; //force uint32
+
+        /**
+         * Simple hashing scheme, multiplying existing hash by a prime and adding next value
+         * (h<<5) - h ===  h*31
+         * @type {number}
+         */
+        hash = ((hash << 5) - hash) + value;
+    }
+
+    // force uint32
+    return hash >>> 0;
+}
+
 /**
  *
  * @param {*} array
@@ -49126,47 +49154,6 @@ function is_typed_array_equals(a, b) {
     return isArrayEqualStrict(a_proxy, b_proxy);
 }
 
-/**
- * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
- * @param {number} t ratio
- * @param {number} a position -2
- * @param {number} b position -1
- * @param {number} c position +1
- * @param {number} d position +2
- * @returns {number}
- */
-function interpolate_bicubic(t, a, b, c, d) {
-    return 0.5 * (c - a + (2.0 * a - 5.0 * b + 4.0 * c - d + (3.0 * (b - c) + d - a) * t) * t) * t + b;
-}
-
-/**
- * Useful for computing hashes of large arrays, can pick a relevant stride and skip large chunks of memory while still capturing good amount of unique information from evenly-spaced areas of the array
- * @param {number[]|Uint32Array|Uint16Array|Uint8Array} array
- * @param {number} offset
- * @param {number} length
- * @param {number} stride
- * @return {number}
- */
-function computeStridedIntegerArrayHash(
-    array, offset, length, stride
-) {
-    let hash = length;
-
-    for (let i = offset; i < length; i += stride) {
-        const value = array[i] >>> 0; //force uint32
-
-        /**
-         * Simple hashing scheme, multiplying existing hash by a prime and adding next value
-         * (h<<5) - h ===  h*31
-         * @type {number}
-         */
-        hash = ((hash << 5) - hash) + value;
-    }
-
-    // force uint32
-    return hash >>> 0;
-}
-
 function typedArrayConstructorByInstance(a) {
     if (a instanceof Int8Array) {
         return Int8Array;
@@ -49193,6 +49180,19 @@ function typedArrayConstructorByInstance(a) {
     }
 }
 
+/**
+ * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
+ * @param {number} t ratio
+ * @param {number} a position -2
+ * @param {number} b position -1
+ * @param {number} c position +1
+ * @param {number} d position +2
+ * @returns {number}
+ */
+function interpolate_bicubic(t, a, b, c, d) {
+    return 0.5 * (c - a + (2.0 * a - 5.0 * b + 4.0 * c - d + (3.0 * (b - c) + d - a) * t) * t) * t + b;
+}
+
 /**
  * Data Texture class, providing an abstraction around 2d numerical arrays, mostly for sampling purposes
  * Inspired by OpenGL's glsl sampler2d API
@@ -54442,7 +54442,10 @@ function overlap1D(a0, a1, b0, b1) {
  * @param {number} by1
  * @returns {boolean} true if overlap exists, false if no overlap
  */
-function aabb2_overlap_exists(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1) {
+function aabb2_overlap_exists(
+    ax0, ay0, ax1, ay1,
+    bx0, by0, bx1, by1
+) {
     return overlap1D(ax0, ax1, bx0, bx1)
         && overlap1D(ay0, ay1, by0, by1);
 }
@@ -59310,7 +59313,7 @@ function computeThreeTextureInternalFormatFromDataType(dt, channel_count) {
  * @param {Sampler2D} sampler
  * @returns {DataTexture}
  */
-function sampler2DtoFloat32Texture(sampler) {
+function sampler2d_to_float32_texture(sampler) {
 
     const width = sampler.width;
     const height = sampler.height;
@@ -59383,7 +59386,7 @@ function heightMap2NormalMap(renderer, sampler) {
     const width = sampler.width;
     const height = sampler.height;
 
-    const texture = sampler2DtoFloat32Texture(sampler);
+    const texture = sampler2d_to_float32_texture(sampler);
 
     //construct shader
     const shader = new NormalMapShader();
@@ -59686,9 +59689,9 @@ function normalMap2OcclusionMap(
     const width = resultSize.x;
     const height = resultSize.y;
     //
-    const normalTexture = sampler2DtoFloat32Texture(normalMap);
+    const normalTexture = sampler2d_to_float32_texture(normalMap);
 
-    const heightTexture = sampler2DtoFloat32Texture(heightMap);
+    const heightTexture = sampler2d_to_float32_texture(heightMap);
 
 
     //construct shader
@@ -87418,7 +87421,7 @@ class RingBuffer {
     }
 
     /**
-     *
+     * Removed first element that fulfills the criteria
      * @param {function(V):boolean} condition
      * @param {*} [thisArg]
      * @returns {V|undefined}
@@ -99187,6 +99190,30 @@ function intersects1D(a0, a1, b0, b1) {
     return a1 >= b0 && b1 >= a0;
 }
 
+/**
+ *
+ * @param {number} bounds_x0
+ * @param {number} bounds_y0
+ * @param {number} bounds_x1
+ * @param {number} bounds_y1
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @return {boolean}
+ */
+function aabb2_contains(
+    bounds_x0, bounds_y0, bounds_x1, bounds_y1,
+    x0, y0, x1, y1
+) {
+
+    return x0 >= bounds_x0
+        && x1 <= bounds_x1
+        && y0 >= bounds_y0
+        && y1 <= bounds_y1
+        ;
+}
+
 class Rectangle {
     /**
      *
@@ -99323,8 +99350,13 @@ class Rectangle {
 
         const _x0 = p.x;
         const _y0 = p.y;
+        const _x1 = s.x + _x0;
+        const _y1 = _y0 + s.y;
 
-        return overlap1D(x0, x1, _x0, s.x + _x0) && overlap1D(y0, y1, _y0, _y0 + s.y);
+        return aabb2_overlap_exists(
+            _x0, _y0, _x1, _y1,
+            x0, y0, x1, y1
+        );
     }
 
     /**
@@ -99337,6 +99369,7 @@ class Rectangle {
         const y0 = other.position.y;
         const y1 = other.size.y + y0;
         const x1 = other.size.x + x0;
+
         return this._overlaps(x0, y0, x1, y1);
     }
 
@@ -99396,13 +99429,18 @@ class Rectangle {
     _contains(x0, y0, x1, y1) {
         const size = this.size;
 
-        const _x0 = this.position.x;
-        const _y0 = this.position.y;
+        const position = this.position;
+
+        const _x0 = position.x;
+        const _y0 = position.y;
 
         const _y1 = size.y + _y0;
         const _x1 = size.x + _x0;
 
-        return x0 >= _x0 && x1 <= _x1 && y0 >= _y0 && y1 <= _y1;
+        return aabb2_contains(
+            _x0, _y0, _x1, _y1,
+            x0, y0, x1, y1
+        );
     }
 
     /**
@@ -99413,6 +99451,7 @@ class Rectangle {
     contains(other) {
         const x0 = other.position.x;
         const y0 = other.position.y;
+
         const y1 = other.size.y + y0;
         const x1 = other.size.x + x0;
 
@@ -106396,6 +106435,7 @@ function computeBinaryDataTypeByPrecision(type, precision) {
 const stack$1 = [];
 
 /**
+ * Quicksort implementation, instead of compare operator, uses scoring function
  * @template T
  * @param {T[]|ArrayLike<number>|Uint32Array} data
  * @param {function(T):number} score_function
@@ -106405,12 +106445,13 @@ const stack$1 = [];
  * @param {function(T[],number, number):*} [swap_operator]
  * @param {*} [swap_context]
  */
-function arrayQuickSort(
+function array_sort_quick(
     data,
     score_function, score_function_context,
     start = 0, end = data.length - 1,
     swap_operator = array_swap_one, swap_context = undefined
 ) {
+
     if (start >= end) {
         // section of 0 size, nothing to sort
         return;
@@ -111351,7 +111392,7 @@ class LightManager {
         array_copy(visible_light_set.elements, 0, sorted_lights, 0, visible_light_count);
         array_copy(visible_decal_set.elements, 0, sorted_lights, visible_light_count, visible_decal_count);
 
-        arrayQuickSort(sorted_lights, this.__sort_visible_light_score, this, 0, expected_sorted_size - 1);
+        array_sort_quick(sorted_lights, this.__sort_visible_light_score, this, 0, expected_sorted_size - 1);
     }
 
     __update_visible_bvh() {

package/editor/ecs/component/editors/Sampler2DEditor.js

@@ -1,3 +1,6 @@
+import {
+    typedArrayConstructorByInstance
+} from "../../../../src/core/collection/array/typed/typedArrayConstructorByInstance.js";
 import { FrameRunner } from "../../../../src/engine/graphics/FrameRunner.js";
 import canvas2Sampler2D from "../../../../src/engine/graphics/texture/Canvas2Sampler2D.js";
 import {
@@ -10,9 +13,6 @@ import {
     sampler2d_compute_texel_value_conversion_scale_to_uint8
 } from "../../../../src/engine/graphics/texture/sampler/sampler2d_compute_texel_value_conversion_scale_to_uint8.js";
 import sampler2D2Canvas from "../../../../src/engine/graphics/texture/sampler/sampler2d_to_html_canvas.js";
-import {
-    typedArrayConstructorByInstance
-} from "../../../../src/engine/graphics/texture/sampler/typedArrayConstructorByInstance.js";
 import { MouseEvents } from "../../../../src/engine/input/devices/events/MouseEvents.js";
 import { CanvasView } from "../../../../src/view/elements/CanvasView.js";
 import EmptyView from "../../../../src/view/elements/EmptyView.js";

package/package.json

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

package/src/core/binary/clz32.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Count leading zeroes in a 32bit integer
+ * @param {number} x
+ * @returns {number}
+ */
+export function clz32(x: number): number;
+//# sourceMappingURL=clz32.d.ts.map

package/src/core/binary/clz32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clz32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/clz32.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,yBAHW,MAAM,GACJ,MAAM,CAiClB"}

package/src/core/binary/clz32.js

@@ -0,0 +1,37 @@
+/**
+ * Count leading zeroes in a 32bit integer
+ * @param {number} x
+ * @returns {number}
+ */
+export function clz32(x) {
+    if (x === 0) {
+        return 32;
+    }
+
+    let v = x >>> 0;
+    let result = 0;
+
+    // Binary search.
+    if ((v & 0xFFFF0000) === 0) {
+        v <<= 16;
+        result += 16;
+    }
+    if ((v & 0xFF000000) === 0) {
+        v <<= 8;
+        result += 8;
+    }
+    if ((v & 0xF0000000) === 0) {
+        v <<= 4;
+        result += 4;
+    }
+    if ((v & 0xC0000000) === 0) {
+        v <<= 2;
+        result += 2;
+    }
+
+    if ((v & 0x80000000) === 0) {
+        result += 1;
+    }
+
+    return result;
+}

package/src/core/binary/is_data_url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"is_data_url.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/is_data_url.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,iCAHW,MAAM,GACL,OAAO,CAQlB"}
+{"version":3,"file":"is_data_url.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/is_data_url.js"],"names":[],"mappings":"AACA;;;;GAIG;AACH,iCAHW,MAAM,GACL,OAAO,CAQlB"}

package/src/core/binary/is_data_url.js

@@ -1,3 +1,4 @@
+
 /**
  * Returns true if string is a data URL
  * @param {string} url

package/src/core/binary/makeArrayBuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"makeArrayBuffer.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/makeArrayBuffer.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,2CAJW,MAAM,WACN,OAAO,GACN,WAAW,GAAC,iBAAiB,CAcxC"}
+{"version":3,"file":"makeArrayBuffer.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/makeArrayBuffer.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,2CAJW,MAAM,WACN,OAAO,GACN,WAAW,GAAC,iBAAiB,CAexC"}

package/src/core/binary/makeArrayBuffer.js

@@ -8,6 +8,7 @@ import { assert } from "../assert.js";
  */
 export function makeArrayBuffer(byte_size, shared = false) {
     assert.isNonNegativeInteger(byte_size, 'size');
+    assert.isBoolean(shared, 'shared');
 
     if (shared) {
         if (crossOriginIsolated) {

package/src/core/binary/msb_32.d.ts

@@ -1,2 +1,8 @@
-export {};
+/**
+ * get most significant set bit
+ * @see https://graphics.stanford.edu/~seander/bithacks.html
+ * @param {number} x 32 bit integer
+ * @returns {number} integer position of most significant bit
+ */
+export function msb_32(x: number): number;
 //# sourceMappingURL=msb_32.d.ts.map

package/src/core/binary/msb_32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"msb_32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/msb_32.js"],"names":[],"mappings":""}
+{"version":3,"file":"msb_32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/msb_32.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,0BAHW,MAAM,GACJ,MAAM,CAIlB"}

package/src/core/binary/msb_32.js

@@ -1,4 +1,4 @@
-import { msb_lut_de_bruijn } from "./msb_lut_de_bruijn.js";
+import { clz32 } from "./clz32.js";
 
 /**
  * get most significant set bit
@@ -6,15 +6,6 @@ import { msb_lut_de_bruijn } from "./msb_lut_de_bruijn.js";
  * @param {number} x 32 bit integer
  * @returns {number} integer position of most significant bit
  */
-function msb_32(x) {
-    let v = x;
-
-    v |= v >>> 1;
-    v |= v >>> 2;
-    v |= v >>> 4;
-    v |= v >>> 8;
-    v |= v >>> 16;
-    v = (v >>> 1) + 1;
-
-    return msb_lut_de_bruijn[(v * 0x077CB531) >>> 27];
+export function msb_32(x) {
+    return 31 - clz32(x);
 }

package/src/core/collection/RingBuffer.d.ts

@@ -63,7 +63,7 @@ export class RingBuffer {
      */
     removeElementByIndex(index: number): void;
     /**
-     *
+     * Removed first element that fulfills the criteria
      * @param {function(V):boolean} condition
      * @param {*} [thisArg]
      * @returns {V|undefined}

package/src/core/collection/RingBuffer.js

@@ -167,7 +167,7 @@ export class RingBuffer {
     }
 
     /**
-     *
+     * Removed first element that fulfills the criteria
      * @param {function(V):boolean} condition
      * @param {*} [thisArg]
      * @returns {V|undefined}

package/src/core/collection/array/array_filter_by_multiple.d.ts

@@ -1,4 +1,6 @@
 /**
+ * Similar to standard {@link Array.prototype.filter}, but allows multiple filters. They work as an "AND".
+ * Useful to save allocations when multiple filters need to be applied, as the {@link Array.prototype.filter} allocates a new array for each call
  * @template T
  * @param {T[]} input_items
  * @param {((T)=>boolean)[]} filters

package/src/core/collection/array/array_filter_by_multiple.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array_filter_by_multiple.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_filter_by_multiple.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oFAHiB,OAAO,UAgCvB"}
+{"version":3,"file":"array_filter_by_multiple.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_filter_by_multiple.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,oFAHiB,OAAO,UAqCvB"}

package/src/core/collection/array/array_filter_by_multiple.js

@@ -1,4 +1,6 @@
 /**
+ * Similar to standard {@link Array.prototype.filter}, but allows multiple filters. They work as an "AND".
+ * Useful to save allocations when multiple filters need to be applied, as the {@link Array.prototype.filter} allocates a new array for each call
  * @template T
  * @param {T[]} input_items
  * @param {((T)=>boolean)[]} filters
@@ -13,23 +15,28 @@ export function array_filter_by_multiple(input_items, filters) {
         return input_items;
     }
 
+    /**
+     *
+     * @type {T[]}
+     */
     const filtered = [];
 
     const input_item_count = input_items.length;
 
-
     main_loop:for (let i = 0; i < input_item_count; i++) {
-        const d = input_items[i];
+        const datum = input_items[i];
+
         for (let j = 0; j < filter_count; j++) {
             const filter = filters[j];
 
-            if (filter(d) === false) {
+            if (filter(datum) === false) {
+                // filter rejected, let's move onto next element
                 continue main_loop;
             }
         }
 
         // filters passed
-        filtered.push(d);
+        filtered.push(datum);
     }
 
     return filtered;

package/src/core/collection/array/array_group_by.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @template T,K
+ * @param {T[]} array
+ * @param {function(T):K} grouping_key_producer given an element from input array, returns a grouping key. Can be an object, if it implements .equals method keys can be compared that way as well
+ * @param keyHashFunction
+ * @returns {Map<K,T[]>}
+ */
+export function array_group_by<T, K>(array: T[], grouping_key_producer: (arg0: T) => K, keyHashFunction?: typeof returnZero): Map<K, T[]>;
+import { returnZero } from "../../function/returnZero.js";
+//# sourceMappingURL=array_group_by.d.ts.map

package/src/core/collection/array/array_group_by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_group_by.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_group_by.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,0IA+BC;2BAzC0B,8BAA8B"}

package/src/core/collection/array/{groupArrayBy.js → array_group_by.js}

@@ -4,11 +4,11 @@ import { HashMap } from "../map/HashMap.js";
 /**
  * @template T,K
  * @param {T[]} array
- * @param {function(T):K} groupingFunction
+ * @param {function(T):K} grouping_key_producer given an element from input array, returns a grouping key. Can be an object, if it implements .equals method keys can be compared that way as well
  * @param keyHashFunction
  * @returns {Map<K,T[]>}
  */
-export function groupArrayBy(array, groupingFunction, keyHashFunction = returnZero) {
+export function array_group_by(array, grouping_key_producer, keyHashFunction = returnZero) {
     const result = new HashMap({
         keyHashFunction,
         keyEqualityFunction(a, b) {
@@ -27,7 +27,7 @@ export function groupArrayBy(array, groupingFunction, keyHashFunction = returnZe
     for (let i = 0; i < array.length; i++) {
         const element = array[i];
 
-        const groupKey = groupingFunction(element);
+        const groupKey = grouping_key_producer(element);
 
         const group = result.get(groupKey);
 

package/src/core/collection/array/array_sort_quick.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Quicksort implementation, instead of compare operator, uses scoring function
+ * @template T
+ * @param {T[]|ArrayLike<number>|Uint32Array} data
+ * @param {function(T):number} score_function
+ * @param {*} [score_function_context]
+ * @param {number} [start]
+ * @param {number} [end]
+ * @param {function(T[],number, number):*} [swap_operator]
+ * @param {*} [swap_context]
+ */
+export function array_sort_quick<T>(data: ArrayLike<number> | Uint32Array | T[], score_function: (arg0: T) => number, score_function_context?: any, start?: number, end?: number, swap_operator?: (arg0: T[], arg1: number, arg2: number) => any, swap_context?: any): void;
+//# sourceMappingURL=array_sort_quick.d.ts.map

package/src/core/collection/array/array_sort_quick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_sort_quick.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_sort_quick.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,8GAPuB,MAAM,wCAElB,MAAM,QACN,MAAM,oCACO,MAAM,QAAE,MAAM,oCAmErC"}

package/src/core/collection/array/{arrayQuickSort.js → array_sort_quick.js}

@@ -1,8 +1,10 @@
+import { assert } from "../../assert.js";
 import { array_swap_one } from "./array_swap_one.js";
 
 const stack = [];
 
 /**
+ * Quicksort implementation, instead of compare operator, uses scoring function
  * @template T
  * @param {T[]|ArrayLike<number>|Uint32Array} data
  * @param {function(T):number} score_function
@@ -12,12 +14,14 @@ const stack = [];
  * @param {function(T[],number, number):*} [swap_operator]
  * @param {*} [swap_context]
  */
-export function arrayQuickSort(
+export function array_sort_quick(
     data,
     score_function, score_function_context,
     start = 0, end = data.length - 1,
     swap_operator = array_swap_one, swap_context = undefined
 ) {
+    assert.isFunction(score_function, 'score_function');
+
     if (start >= end) {
         // section of 0 size, nothing to sort
         return;

package/src/core/collection/array/combine_hash.js

@@ -1,5 +1,5 @@
 import { assert } from "../../assert.js";
-import { computeIntegerArrayHash } from "../../primitives/array/computeIntegerArrayHash.js";
+import { computeIntegerArrayHash } from "./computeIntegerArrayHash.js";
 
 /**
  * Computes hash on integer values, useful for building composite hashes

package/src/core/{primitives → collection}/array/compareArrays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareArrays.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/array/compareArrays.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qFAHyB,MAAM,GACnB,MAAM,CAwBjB"}
+{"version":3,"file":"compareArrays.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/compareArrays.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qFAHyB,MAAM,GACnB,MAAM,CAwBjB"}

package/src/core/{primitives → collection}/array/computeIntegerArrayHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeIntegerArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/array/computeIntegerArrayHash.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,8CAJW,UAAU,GAAC,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,UAAU,UAChD,MAAM,UACN,MAAM,UAIhB"}
+{"version":3,"file":"computeIntegerArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/computeIntegerArrayHash.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,8CAJW,UAAU,GAAC,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,UAAU,UAChD,MAAM,UACN,MAAM,UAIhB"}

package/src/core/{primitives → collection}/array/computeStridedArrayHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeStridedArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/array/computeStridedArrayHash.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wGAPW,MAAM,UACN,MAAM,UACN,MAAM,4BACM,MAAM,6BAEjB,MAAM,CAwBjB"}
+{"version":3,"file":"computeStridedArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/computeStridedArrayHash.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wGAPW,MAAM,UACN,MAAM,UACN,MAAM,4BACM,MAAM,6BAEjB,MAAM,CAwBjB"}

package/src/core/{primitives → collection}/array/computeStridedIntegerArrayHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeStridedIntegerArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/array/computeStridedIntegerArrayHash.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,sDANW,MAAM,EAAE,GAAC,WAAW,GAAC,WAAW,GAAC,UAAU,UAC3C,MAAM,UACN,MAAM,UACN,MAAM,GACL,MAAM,CAoBjB"}
+{"version":3,"file":"computeStridedIntegerArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/computeStridedIntegerArrayHash.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,sDANW,MAAM,EAAE,GAAC,WAAW,GAAC,WAAW,GAAC,UAAU,UAC3C,MAAM,UACN,MAAM,UACN,MAAM,GACL,MAAM,CAoBjB"}

package/src/core/collection/array/randomMultipleFromArray.d.ts

@@ -2,11 +2,11 @@
  * Pick multiple random items from an array
  *
  * @template T
- * @param {function} random
- * @param {T[]} source
- * @param {T[]} target
- * @param {number} count how many items to pick
- * @returns {T}
+ * @param {function} random random function, must return a value between 0 and 1
+ * @param {T[]} source Where to pick elements from
+ * @param {T[]} target Where to place picked elements
+ * @param {number} count how many items to pick, if this number is greater than the length of {@link source}, it will be limited to length of {@link source} instead
+ * @returns {number} number of picked elements
  */
-export function randomMultipleFromArray<T>(random: Function, source: T[], target: T[], count: number): T;
+export function randomMultipleFromArray<T>(random: Function, source: T[], target: T[], count: number): number;
 //# sourceMappingURL=randomMultipleFromArray.d.ts.map

package/src/core/collection/array/randomMultipleFromArray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randomMultipleFromArray.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/randomMultipleFromArray.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,8FAHW,MAAM,KAuBhB"}
+{"version":3,"file":"randomMultipleFromArray.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/randomMultipleFromArray.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,8FAHW,MAAM,GACJ,MAAM,CAsBlB"}

package/src/core/collection/array/randomMultipleFromArray.js

@@ -5,11 +5,11 @@ import { array_shuffle } from "./array_shuffle.js";
  * Pick multiple random items from an array
  *
  * @template T
- * @param {function} random
- * @param {T[]} source
- * @param {T[]} target
- * @param {number} count how many items to pick
- * @returns {T}
+ * @param {function} random random function, must return a value between 0 and 1
+ * @param {T[]} source Where to pick elements from
+ * @param {T[]} target Where to place picked elements
+ * @param {number} count how many items to pick, if this number is greater than the length of {@link source}, it will be limited to length of {@link source} instead
+ * @returns {number} number of picked elements
  */
 export function randomMultipleFromArray(random, source, target, count) {