@woosh/meep-engine 2.115.0 → 2.116.0

package/build/meep.module.js

@@ -61407,7 +61407,7 @@ function objectsEqual(a, b) {
  * @param {function(a:T,b:T):boolean} equals
  * @returns {number} index of first match or -1 if no matches found
  */
-function arrayIndexByEquality(array, element, equals) {
+function array_index_by_equality(array, element, equals) {
     const n = array.length;
 
     for (let i = 0; i < n; i++) {
@@ -61423,14 +61423,14 @@ function arrayIndexByEquality(array, element, equals) {
 
 /**
  * Compute a diff between two arrays, result is a 3 way split between common items, unique items in `a` array and unique items in `b` array
- * @see prefer to use {@link arraySetSortingDiff}, as it's much faster, especially for large sets
+ * @see prefer to use {@link array_set_diff_sorting}, as it's much faster, especially for large sets
  * @template T
  * @param {T[]} a
  * @param {T[]} b
  * @param {function(a:T,b:T):boolean} [equals] method to determine equality between two elements
  * @returns {{uniqueA:T[], uniqueB:T[], common:T[]}}
  */
-function arraySetDiff(a, b, equals = strictEquals) {
+function array_set_diff(a, b, equals = strictEquals) {
 
     const uniqueA = a.slice();
     const uniqueB = b.slice();
@@ -61442,7 +61442,7 @@ function arraySetDiff(a, b, equals = strictEquals) {
     for (let i = 0; i < a_length; i++) {
         const elA = uniqueA[i];
 
-        const j = arrayIndexByEquality(uniqueB, elA, equals);
+        const j = array_index_by_equality(uniqueB, elA, equals);
 
         if (j !== -1) {
             // common element found
@@ -61667,7 +61667,7 @@ class List {
 
         const data = this.data;
 
-        const diff = arraySetDiff(data, new_data, objectsEqual);
+        const diff = array_set_diff(data, new_data, objectsEqual);
 
         //resolve diff
         const removals = diff.uniqueA;
@@ -62186,7 +62186,7 @@ class List {
         for (let i = 0; i < nThisItems; i++) {
             const a = thisItems[i];
 
-            const index = arrayIndexByEquality(otherItems, a, invokeObjectEquals);
+            const index = array_index_by_equality(otherItems, a, invokeObjectEquals);
 
             if (index !== -1) {
                 newData[index] = a;
@@ -94307,7 +94307,7 @@ class EntityComponentDataset {
 
         const newComponentTypeCount = map.length;
 
-        const diff = arraySetDiff(map, this.componentTypeMap);
+        const diff = array_set_diff(map, this.componentTypeMap);
 
         const typesToAdd = diff.uniqueA;
         const typesToRemove = diff.uniqueB;
@@ -94525,7 +94525,7 @@ class EntityComponentDataset {
      * @returns {boolean} false if no new classes were added, true if at least one new class was added
      */
     registerManyComponentTypes(types) {
-        const diff = arraySetDiff(types, this.componentTypeMap);
+        const diff = array_set_diff(types, this.componentTypeMap);
 
         if (diff.uniqueA.length === 0) {
             // all classes area already registered
@@ -115487,43 +115487,138 @@ function getURLHash() {
     return result;
 }
 
-class EnginePlatform {
-    /**
-     * @returns {Storage}
-     */
-    getStorage() {
-        throw new Error('Not implemented');
+/**
+ * Picks element with highest score from the array using supplied scoring function.
+ * If multiple elements with the same highest score exist, the result will be first such encountered element
+ * @template T
+ * @param {T[]} array
+ * @param {function(el:T, index:number):number} scoreFunction
+ * @returns {T|undefined}
+ */
+function array_pick_best_element(array, scoreFunction) {
+
+    let bestElement;
+    let bestScore;
+
+    const size = array.length;
+
+    if (size === 0) {
+        return undefined;
     }
 
-    /**
-     * @returns {AchievementGateway}
-     */
-    getAchievementGateway() {
-        throw new Error('Not implemented');
+    bestElement = array[0];
+
+    bestScore = scoreFunction(bestElement, 0);
+
+    for (let i = 1; i < size; i++) {
+        const el = array[i];
+
+        // compute score
+        const score = scoreFunction(el, i);
+
+        if (score > bestScore) {
+            bestScore = score;
+            bestElement = el;
+        }
+    }
+
+    return bestElement;
+}
+
+/**
+ * Base class for implementing achievement system API connectors
+ */
+class AchievementGateway {
+    constructor() {
+
     }
 
     /**
-     * @param {string[]} options
-     * @returns {string}
+     * Retrieve list of unlocked achievements
+     * @returns {Promise<String[]>} IDs of unlocked achievements
      */
-    pickDefaultLocale(options) {
+    getUnlocked() {
+        //needs to be overridden in subclass
         throw new Error('Not implemented');
     }
 
     /**
+     * Unlock an achievements by ID
+     * @param {String} id
      * @returns {Promise}
      */
-    startup() {
-        return Promise.resolve();
+    unlock(id) {
+        //needs to be overridden in subclass
+        throw new Error('Not implemented');
     }
-
+}
+
+class StorageAchievementGateway extends AchievementGateway {
     /**
-     * @returns {Promise}
+     *
+     * @param {Storage} storage
+     * @param {String} [key]
      */
-    shutdown() {
-        return Promise.resolve();
+    constructor(storage, key = "achievements") {
+        super();
+
+        this.storage = storage;
+
+        this.key = key;
+
+        this.last = Promise.resolve();
     }
 
+    getUnlocked() {
+        return new Promise((resolve, reject) => {
+            this.storage.load(this.key, (list) => {
+
+                if (list === undefined) {
+                    resolve([]);
+                } else {
+                    resolve(list);
+                }
+
+            }, reject, noop);
+        });
+    }
+
+    unlock(id) {
+        const storage = this.storage;
+
+        const promise = this.last.finally(() => {
+                return new Promise((resolve, reject) => {
+                    //read list of unlocked achievements
+                    storage.load(this.key, list => {
+
+                        let unlocked;
+                        if (list !== undefined) {
+                            if (list.includes(id)) {
+                                //achievement is already unlocked
+                                resolve();
+                                return;
+                            }
+
+                            unlocked = list.slice();
+
+                        } else {
+                            unlocked = [];
+                        }
+
+                        //modify unlocked achievements
+                        unlocked.push(id);
+
+                        //write back
+                        storage.store(this.key, unlocked, resolve, reject, noop);
+                    }, reject, noop);
+                });
+            }
+        );
+
+        this.last = promise;
+
+        return promise;
+    }
 }
 
 class Storage {
@@ -115797,138 +115892,43 @@ class IndexedDBStorage extends Storage {
     }
 }
 
-/**
- * Base class for implementing achievement system API connectors
- */
-class AchievementGateway {
-    constructor() {
-
-    }
-
+class EnginePlatform {
     /**
-     * Retrieve list of unlocked achievements
-     * @returns {Promise<String[]>} IDs of unlocked achievements
+     * @returns {Storage}
      */
-    getUnlocked() {
-        //needs to be overridden in subclass
+    getStorage() {
         throw new Error('Not implemented');
     }
 
     /**
-     * Unlock an achievements by ID
-     * @param {String} id
-     * @returns {Promise}
+     * @returns {AchievementGateway}
      */
-    unlock(id) {
-        //needs to be overridden in subclass
+    getAchievementGateway() {
         throw new Error('Not implemented');
     }
-}
-
-class StorageAchievementGateway extends AchievementGateway {
+
     /**
-     *
-     * @param {Storage} storage
-     * @param {String} [key]
+     * @param {string[]} options
+     * @returns {string}
      */
-    constructor(storage, key = "achievements") {
-        super();
-
-        this.storage = storage;
-
-        this.key = key;
-
-        this.last = Promise.resolve();
-    }
-
-    getUnlocked() {
-        return new Promise((resolve, reject) => {
-            this.storage.load(this.key, (list) => {
-
-                if (list === undefined) {
-                    resolve([]);
-                } else {
-                    resolve(list);
-                }
-
-            }, reject, noop);
-        });
-    }
-
-    unlock(id) {
-        const storage = this.storage;
-
-        const promise = this.last.finally(() => {
-                return new Promise((resolve, reject) => {
-                    //read list of unlocked achievements
-                    storage.load(this.key, list => {
-
-                        let unlocked;
-                        if (list !== undefined) {
-                            if (list.includes(id)) {
-                                //achievement is already unlocked
-                                resolve();
-                                return;
-                            }
-
-                            unlocked = list.slice();
-
-                        } else {
-                            unlocked = [];
-                        }
-
-                        //modify unlocked achievements
-                        unlocked.push(id);
-
-                        //write back
-                        storage.store(this.key, unlocked, resolve, reject, noop);
-                    }, reject, noop);
-                });
-            }
-        );
-
-        this.last = promise;
-
-        return promise;
+    pickDefaultLocale(options) {
+        throw new Error('Not implemented');
     }
-}
-
-/**
- * Picks element with highest score from the array using supplied scoring function.
- * If multiple elements with the same highest score exist, the result will be first such encountered element
- * @template T
- * @param {T[]} array
- * @param {function(el:T, index:number):number} scoreFunction
- * @returns {T|undefined}
- */
-function arrayPickBestElement(array, scoreFunction) {
 
-    let bestElement;
-    let bestScore;
-
-    const size = array.length;
-
-    if (size === 0) {
-        return undefined;
+    /**
+     * @returns {Promise}
+     */
+    startup() {
+        return Promise.resolve();
     }
 
-    bestElement = array[0];
-
-    bestScore = scoreFunction(bestElement, 0);
-
-    for (let i = 1; i < size; i++) {
-        const el = array[i];
-
-        // compute score
-        const score = scoreFunction(el, i);
-
-        if (score > bestScore) {
-            bestScore = score;
-            bestElement = el;
-        }
+    /**
+     * @returns {Promise}
+     */
+    shutdown() {
+        return Promise.resolve();
     }
 
-    return bestElement;
 }
 
 class WebEnginePlatform extends EnginePlatform {
@@ -116003,7 +116003,7 @@ class WebEnginePlatform extends EnginePlatform {
                 };
             });
 
-            const best = arrayPickBestElement(scoredKeys, o => o.score);
+            const best = array_pick_best_element(scoredKeys, o => o.score);
 
             if (best.score === 0) {
                 return 'en-gb';

package/editor/view/ecs/HierarchicalEntityListView.js

@@ -1,4 +1,4 @@
-import { arraySetSortingDiff } from "../../../src/core/collection/array/arraySetSortingDiff.js";
+import { array_set_diff_sorting } from "../../../src/core/collection/array/array_set_diff_sorting.js";
 import List from "../../../src/core/collection/list/List.js";
 import Signal from "../../../src/core/events/signal/Signal.js";
 import { number_compare_ascending } from "../../../src/core/primitives/numbers/number_compare_ascending.js";
@@ -50,7 +50,7 @@ export class HierarchicalEntityListView extends EmptyView {
         });
 
         // perform patch
-        const diff = arraySetSortingDiff(new_roots, this.#roots.asArray(), number_compare_ascending);
+        const diff = array_set_diff_sorting(new_roots, this.#roots.asArray(), number_compare_ascending);
 
         for (let i = 0; i < diff.uniqueB.length; i++) {
             const removal_id = diff.uniqueB[i];

package/package.json

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

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

@@ -5,5 +5,5 @@
  * @param {function(T,T):number} comparator
  * @return {number}
  */
-export function compareArrays<T>(as: T[], bs: T[], comparator: (arg0: T, arg1: T) => number): number;
-//# sourceMappingURL=compareArrays.d.ts.map
+export function array_compare<T>(as: T[], bs: T[], comparator: (arg0: T, arg1: T) => number): number;
+//# sourceMappingURL=array_compare.d.ts.map

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

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

package/src/core/collection/array/{compareArrays.js → array_compare.js}

@@ -1,3 +1,5 @@
+import { assert } from "../../assert.js";
+
 /**
  * @template T
  * @param {T[]} as
@@ -5,7 +7,9 @@
  * @param {function(T,T):number} comparator
  * @return {number}
  */
-export function compareArrays(as, bs, comparator) {
+export function array_compare(as, bs, comparator) {
+    assert.isFunction(comparator,'comparator');
+
     const n = as.length;
     const m = bs.length;
 

package/src/core/collection/array/{arrayIndexByEquality.d.ts → array_index_by_equality.d.ts}

@@ -6,5 +6,5 @@
  * @param {function(a:T,b:T):boolean} equals
  * @returns {number} index of first match or -1 if no matches found
  */
-export function arrayIndexByEquality<T>(array: T[], element: T, equals: any): number;
-//# sourceMappingURL=arrayIndexByEquality.d.ts.map
+export function array_index_by_equality<T>(array: T[], element: T, equals: any): number;
+//# sourceMappingURL=array_index_by_equality.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array_index_by_equality.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_index_by_equality.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,iFAFa,MAAM,CAclB"}

package/src/core/collection/array/{arrayIndexByEquality.js → array_index_by_equality.js}

@@ -6,7 +6,7 @@
  * @param {function(a:T,b:T):boolean} equals
  * @returns {number} index of first match or -1 if no matches found
  */
-export function arrayIndexByEquality(array, element, equals) {
+export function array_index_by_equality(array, element, equals) {
     const n = array.length;
 
     for (let i = 0; i < n; i++) {

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

@@ -0,0 +1 @@
+{"version":3,"file":"array_pick_best_element.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_pick_best_element.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,8EAkCC"}

package/src/core/collection/array/{arrayPickBestElement.js → array_pick_best_element.js}

@@ -8,9 +8,9 @@ import { assert } from "../../assert.js";
  * @param {function(el:T, index:number):number} scoreFunction
  * @returns {T|undefined}
  */
-export function arrayPickBestElement(array, scoreFunction) {
+export function array_pick_best_element(array, scoreFunction) {
     assert.notEqual(array, undefined, 'array is undefined');
-    assert.typeOf(scoreFunction, 'function', 'scoreFunction');
+    assert.isFunction(scoreFunction, 'scoreFunction');
 
     let bestElement;
     let bestScore;

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

@@ -0,0 +1,8 @@
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {function(el:T, index:number):number} scoreFunction
+ * @returns {T[]}
+ */
+export function array_pick_best_elements<T>(array: T[], scoreFunction: any): T[];
+//# sourceMappingURL=array_pick_best_elements.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array_pick_best_elements.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_pick_best_elements.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,iFA0CC"}

package/src/core/collection/array/{arrayPickBestElements.js → array_pick_best_elements.js}

@@ -6,7 +6,7 @@ import { assert } from "../../assert.js";
  * @param {function(el:T, index:number):number} scoreFunction
  * @returns {T[]}
  */
-export function arrayPickBestElements(array, scoreFunction) {
+export function array_pick_best_elements(array, scoreFunction) {
     assert.notEqual(array, undefined, 'array is undefined');
     assert.isArray(array, 'array');
 

package/src/core/collection/array/{arraySetDiff.d.ts → array_set_diff.d.ts}

@@ -1,16 +1,16 @@
 /**
  * Compute a diff between two arrays, result is a 3 way split between common items, unique items in `a` array and unique items in `b` array
- * @see prefer to use {@link arraySetSortingDiff}, as it's much faster, especially for large sets
+ * @see prefer to use {@link array_set_diff_sorting}, as it's much faster, especially for large sets
  * @template T
  * @param {T[]} a
  * @param {T[]} b
  * @param {function(a:T,b:T):boolean} [equals] method to determine equality between two elements
  * @returns {{uniqueA:T[], uniqueB:T[], common:T[]}}
  */
-export function arraySetDiff<T>(a: T[], b: T[], equals?: typeof strictEquals): {
+export function array_set_diff<T>(a: T[], b: T[], equals?: typeof strictEquals): {
     uniqueA: T[];
     uniqueB: T[];
     common: T[];
 };
 import { strictEquals } from "../../function/strictEquals.js";
-//# sourceMappingURL=arraySetDiff.d.ts.map
+//# sourceMappingURL=array_set_diff.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array_set_diff.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_set_diff.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH;;;;EAoCC;6BAhD4B,gCAAgC"}

package/src/core/collection/array/{arraySetDiff.js → array_set_diff.js}

@@ -1,18 +1,18 @@
 import { assert } from "../../assert.js";
 
 import { strictEquals } from "../../function/strictEquals.js";
-import { arrayIndexByEquality } from "./arrayIndexByEquality.js";
+import { array_index_by_equality } from "./array_index_by_equality.js";
 
 /**
  * Compute a diff between two arrays, result is a 3 way split between common items, unique items in `a` array and unique items in `b` array
- * @see prefer to use {@link arraySetSortingDiff}, as it's much faster, especially for large sets
+ * @see prefer to use {@link array_set_diff_sorting}, as it's much faster, especially for large sets
  * @template T
  * @param {T[]} a
  * @param {T[]} b
  * @param {function(a:T,b:T):boolean} [equals] method to determine equality between two elements
  * @returns {{uniqueA:T[], uniqueB:T[], common:T[]}}
  */
-export function arraySetDiff(a, b, equals = strictEquals) {
+export function array_set_diff(a, b, equals = strictEquals) {
     assert.isArray(a, 'a');
     assert.isArray(b, 'b');
     assert.isFunction(equals, 'equals');
@@ -27,7 +27,7 @@ export function arraySetDiff(a, b, equals = strictEquals) {
     for (let i = 0; i < a_length; i++) {
         const elA = uniqueA[i];
 
-        const j = arrayIndexByEquality(uniqueB, elA, equals);
+        const j = array_index_by_equality(uniqueB, elA, equals);
 
         if (j !== -1) {
             // common element found

package/src/core/collection/array/{arraySetSortingDiff.d.ts → array_set_diff_sorting.d.ts}

@@ -6,9 +6,9 @@
  * @param {function(a:T,b:T):number} [compare]
  * @returns {{uniqueA:T[], uniqueB:T[], common:T[]}}
  */
-export function arraySetSortingDiff<T>(a: T[], b: T[], compare: any): {
+export function array_set_diff_sorting<T>(a: T[], b: T[], compare: any): {
     uniqueA: T[];
     uniqueB: T[];
     common: T[];
 };
-//# sourceMappingURL=arraySetSortingDiff.d.ts.map
+//# sourceMappingURL=array_set_diff_sorting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array_set_diff_sorting.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_set_diff_sorting.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH;;;;EAsDC"}

package/src/core/collection/array/{arraySetSortingDiff.js → array_set_diff_sorting.js}

@@ -10,7 +10,7 @@ import { assert } from "../../assert.js";
  * @param {function(a:T,b:T):number} [compare]
  * @returns {{uniqueA:T[], uniqueB:T[], common:T[]}}
  */
-export function arraySetSortingDiff(a, b, compare) {
+export function array_set_diff_sorting(a, b, compare) {
     assert.isFunction(compare, 'compare');
 
     const uniqueA = a.slice();

package/src/core/collection/list/FilteredListProjection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FilteredListProjection.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/FilteredListProjection.js"],"names":[],"mappings":"AAKA;IACI;;;;;OAKG;IACH,qCAHW,sBAAsB,EA6BhC;IAzBG;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,gBAAwB;IAExB;;;OAGG;IACH,SAFU,sBAAsB,CAEV;IAEtB;;;OAGG;IACH,UAFU,OAAO,CAEG;IAEpB,wBAAoD;IAGxD,eAMC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,0BAGC;IAED;;;OAGG;IACH,4BAGC;IAED,aAUC;IAED,eAQC;IAED,cAiFC;CACJ;iBAxLgB,WAAW"}
+{"version":3,"file":"FilteredListProjection.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/FilteredListProjection.js"],"names":[],"mappings":"AAKA;IACI;;;;;OAKG;IACH,qCAHW,sBAAsB,EA6BhC;IAzBG;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,gBAAwB;IAExB;;;OAGG;IACH,SAFU,sBAAsB,CAEV;IAEtB;;;OAGG;IACH,UAFU,OAAO,CAEG;IAEpB,wBAAoD;IAGxD,eAMC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,0BAGC;IAED;;;OAGG;IACH,4BAGC;IAED,aAUC;IAED,eAQC;IAED,cAiFC;CACJ;iBAvLgB,WAAW"}

package/src/core/collection/list/FilteredListProjection.js

@@ -1,7 +1,7 @@
 import { frameThrottle } from "../../../engine/graphics/FrameThrottle.js";
 import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
+import { array_set_diff } from "../array/array_set_diff.js";
 import List from "./List.js";
-import { arraySetDiff } from "../array/arraySetDiff.js";
 
 export class FilteredListProjection {
     /**
@@ -136,7 +136,7 @@ export class FilteredListProjection {
             newOutput.push(v);
         }
 
-        const diff = arraySetDiff(oldOutput, newOutput, invokeObjectEquals);
+        const diff = array_set_diff(oldOutput, newOutput, invokeObjectEquals);
 
         //resolve diff
         const removals = diff.uniqueA;

package/src/core/collection/list/List.js

@@ -7,8 +7,8 @@ import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { objectsEqual } from "../../function/objectsEqual.js";
 import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
-import { arrayIndexByEquality } from "../array/arrayIndexByEquality.js";
-import { arraySetDiff } from "../array/arraySetDiff.js";
+import { array_index_by_equality } from "../array/array_index_by_equality.js";
+import { array_set_diff } from "../array/array_set_diff.js";
 
 
 /**
@@ -214,7 +214,7 @@ class List {
 
         const data = this.data;
 
-        const diff = arraySetDiff(data, new_data, objectsEqual);
+        const diff = array_set_diff(data, new_data, objectsEqual);
 
         //resolve diff
         const removals = diff.uniqueA;
@@ -744,7 +744,7 @@ class List {
         for (let i = 0; i < nThisItems; i++) {
             const a = thisItems[i];
 
-            const index = arrayIndexByEquality(otherItems, a, invokeObjectEquals);
+            const index = array_index_by_equality(otherItems, a, invokeObjectEquals);
 
             if (index !== -1) {
                 newData[index] = a;