@woosh/meep-engine 2.50.1 → 2.50.3

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

@@ -11,651 +11,625 @@ import { arrayIndexByEquality } from "../array/arrayIndexByEquality.js";
 
 
 /**
- * @callback List~ConsumerCallback
- * @template T
- * @param {T} element
- * @param {number} [index]
- */
-
-/**
+ *
  * List structure with event signals for observing changes.
- * @param {Array.<T>} [array]
  * @template T
- * @constructor
- * @property {{added: Signal, removed: Signal}} on
  */
-function List(array) {
-    this.on = {
+class List {
+    /**
+     * @readonly
+     */
+    on = {
+        /**
+         * @type {Signal<T,number>}
+         */
         added: new Signal(),
+        /**
+         * @type {Signal<T,number>}
+         */
         removed: new Signal()
     };
 
     /**
-     * @type {T[]}
+     * @param {T[]} [array]
+     * @constructor
      */
-    this.data = array !== undefined ? array.slice() : [];
+    constructor(array) {
+
+        /**
+         * @type {T[]}
+         */
+        this.data = array !== undefined ? array.slice() : [];
+
+        /**
+         *
+         * @type {number}
+         */
+        this.length = this.data.length;
+    }
 
     /**
-     *
-     * @type {number}
+     * Retrieve element at a given position in the list
+     * @param {number} index
+     * @returns {T}
      */
-    this.length = this.data.length;
-}
+    get(index) {
+        return this.data[index];
+    }
 
-/**
- *
- * @param {number} index
- * @returns {T}
- */
-List.prototype.get = function (index) {
-    return this.data[index];
-};
+    /**
+     * Set element at a given position inside the list
+     * @param {number} index
+     * @param {T} value
+     */
+    set(index, value) {
+        const oldValue = this.data[index];
 
-/**
- *
- * @param {number} index
- * @param {T} value
- */
-List.prototype.set = function (index, value) {
-    const oldValue = this.data[index];
+        if (oldValue !== undefined) {
+            this.on.removed.send2(oldValue, index)
+        } else {
+            if (index >= this.length) {
 
-    if (oldValue !== undefined) {
-        this.on.removed.send2(oldValue, index)
-    } else {
-        if (index >= this.length) {
+                this.length = index + 1;
 
-            this.length = index + 1;
+                if (index > this.length) {
+                    console.error(`Overflow, attempted to set element at ${index} past the list length(=${this.length})`);
+                }
 
-            if (index > this.length) {
-                console.error(`Overflow, attempted to set element at ${index} past the list length(=${this.length})`);
             }
-
         }
+
+        this.data[index] = value;
+
+        this.on.added.send2(value, index);
     }
 
-    this.data[index] = value;
+    /**
+     *
+     * @param {T} el
+     */
+    add(el) {
+        this.data.push(el);
+        const oldLength = this.length;
 
-    this.on.added.send2(value, index);
-};
+        this.length++;
 
-/**
- *
- * @param {T} el
- */
-List.prototype.add = function (el) {
-    this.data.push(el);
-    const oldLength = this.length;
+        this.on.added.send2(el, oldLength);
+        return this;
+    }
 
-    this.length++;
+    /**
+     * Only add element if it doesn't already exist in the list
+     * Useful when you wish to ensure uniqueness of elements inside the list
+     * Note that this operation is rather slow as it triggers a linear scan
+     * If the list gets large - consider using a {@link Set} class instead
+     * @param {T} el
+     * @return {boolean}
+     */
+    addUnique(el) {
+        if (this.contains(el)) {
+            return false;
+        }
 
-    this.on.added.send2(el, oldLength);
-    return this;
-};
+        this.add(el);
 
-/**
- *
- * @param {T} el
- * @return {boolean}
- */
-List.prototype.addUnique = function (el) {
-    if (this.contains(el)) {
-        return false;
+        return true;
     }
 
-    this.add(el);
+    /**
+     * Insert element at a specific position into the list
+     * This operation will result in a larger list
+     * @param {number} index
+     * @param {T} el
+     * @returns {List}
+     * @throws {Error} when trying to insert past list end
+     */
+    insert(index, el) {
 
-    return true;
-}
+        if (index > this.length) {
+            console.error(`Overflow, attempted to insert element at ${index} past the list length(=${this.length})`);
+            this.length = index;
+        }
 
-/**
- * Insert element at a specific position into the list
- * @param {number} index
- * @param {T} el
- * @returns {List}
- * @throws {Error} when trying to insert past list end
- */
-List.prototype.insert = function (index, el) {
+        this.data.splice(index, 0, el);
 
-    if (index > this.length) {
-        console.error(`Overflow, attempted to insert element at ${index} past the list length(=${this.length})`);
-        this.length = index + 1;
-    }
+        this.length++;
 
-    this.data.splice(index, 0, el);
+        this.on.added.send2(el, index);
 
-    this.length++;
+        return this;
+    }
 
-    this.on.added.send2(el, index);
+    /**
+     * Reduces the list to a subsection but removing everything before startIndex and everything after endIndex
+     * @param {int} startIndex
+     * @param {int} endIndex up to this index, not including it
+     * @returns {number}
+     */
+    crop(startIndex, endIndex) {
 
-    return this;
-};
+        const data = this.data;
 
-/**
- * Reduces the list to a sub-section but removing everything before startIndex and everything after endIndex
- * @param {int} startIndex
- * @param {int} endIndex up to this index, not including it
- * @returns {number}
- */
-List.prototype.crop = function (startIndex, endIndex) {
+        const tail = data.splice(endIndex, this.length - endIndex);
 
-    const data = this.data;
+        const head = data.splice(0, startIndex);
 
-    const tail = data.splice(endIndex, this.length - endIndex);
+        this.length = endIndex - startIndex;
 
-    const head = data.splice(0, startIndex);
 
-    this.length = endIndex - startIndex;
+        const headLength = head.length;
 
+        const tailLength = tail.length;
 
-    const headLength = head.length;
+        const onRemoved = this.on.removed;
 
-    const tailLength = tail.length;
+        if (onRemoved.hasHandlers()) {
+            let i;
 
-    const onRemoved = this.on.removed;
+            for (i = 0; i < headLength; i++) {
+                onRemoved.send2(head[i], i);
+            }
 
-    if (onRemoved.hasHandlers()) {
-        let i;
 
-        for (i = 0; i < headLength; i++) {
-            onRemoved.send2(head[i], i);
+            for (i = 0; i < tailLength; i++) {
+                onRemoved.send2(tail[i], endIndex + i);
+            }
         }
 
-
-        for (i = 0; i < tailLength; i++) {
-            onRemoved.send2(tail[i], endIndex + i);
-        }
+        //return number of dropped elements
+        return headLength + tailLength;
     }
 
-    //return number of dropped elements
-    return headLength + tailLength;
-};
-
-/**
- * Replace the data, replacements is performed surgically, meaning that diff is computed and add/remove operations are performed on the set
- * This method is tailored to work well with visualisation as only elements that's missing from the new set is removed, and only elements that are new to are added
- * Conversely, relevant events are dispatched that a visualisation can observe. This results in fewer changes required to the visualisation
- * @param {T[]} newOutput
- */
-List.prototype.patch = function (newOutput) {
+    /**
+     * Replace the data, replacements is performed surgically, meaning that diff is computed and add/remove operations are performed on the set
+     * This method is tailored to work well with visualisation as only elements that's missing from the new set is removed, and only elements that are new to are added
+     * Conversely, relevant events are dispatched that a visualisation can observe. This results in fewer changes required to the visualisation
+     * @param {T[]} newOutput
+     */
+    patch(newOutput) {
 
-    const data = this.data;
+        const data = this.data;
 
-    const diff = arraySetDiff(data, newOutput, invokeObjectEquals);
+        const diff = arraySetDiff(data, newOutput, invokeObjectEquals);
 
-    //resolve diff
-    const removals = diff.uniqueA;
+        //resolve diff
+        const removals = diff.uniqueA;
 
-    const removalCount = removals.length;
+        const removalCount = removals.length;
 
-    for (let i = 0; i < removalCount; i++) {
-        const item = removals[i];
+        for (let i = 0; i < removalCount; i++) {
+            const item = removals[i];
 
-        this.removeOneOf(item);
-    }
+            this.removeOneOf(item);
+        }
 
-    const additions = diff.uniqueB;
+        const additions = diff.uniqueB;
 
-    //sort additions by their position in the input
-    additions.sort((a, b) => {
-        const ai = this.indexOf(a);
-        const bi = this.indexOf(b);
+        //sort additions by their position in the input
+        additions.sort((a, b) => {
+            const ai = this.indexOf(a);
+            const bi = this.indexOf(b);
 
-        return bi - ai;
-    });
+            return bi - ai;
+        });
 
-    const additionsCount = additions.length;
+        const additionsCount = additions.length;
 
-    for (let i = 0; i < additionsCount; i++) {
-        const item = additions[i];
+        for (let i = 0; i < additionsCount; i++) {
+            const item = additions[i];
 
-        //find where the item is in the input
-        const inputIndex = this.indexOf(item);
+            //find where the item is in the input
+            const inputIndex = this.indexOf(item);
 
-        let p = 0;
-        for (let i = inputIndex - 1; i >= 0; i--) {
-            const prev = this.get(i);
+            let p = 0;
+            for (let i = inputIndex - 1; i >= 0; i--) {
+                const prev = this.get(i);
 
-            //look for previous item in the output
-            const j = this.indexOf(prev);
+                //look for previous item in the output
+                const j = this.indexOf(prev);
 
-            if (j !== -1) {
-                p = j + 1;
-                break;
+                if (j !== -1) {
+                    p = j + 1;
+                    break;
+                }
             }
+
+            this.insert(p, item);
         }
 
-        this.insert(p, item);
     }
 
-};
-
-/**
- *
- * @param {Array.<T>} elements
- */
-List.prototype.addAll = function (elements) {
-    const addedElementsCount = elements.length;
+    /**
+     *
+     * @param {Array.<T>} elements
+     */
+    addAll(elements) {
+        const addedElementsCount = elements.length;
 
-    const added = this.on.added;
+        const added = this.on.added;
 
-    if (added.hasHandlers()) {
-        //only signal if there are listeners attached
-        for (let i = 0; i < addedElementsCount; i++) {
-            const element = elements[i];
-            this.data.push(element);
-            added.send2(element, this.length++);
+        if (added.hasHandlers()) {
+            //only signal if there are listeners attached
+            for (let i = 0; i < addedElementsCount; i++) {
+                const element = elements[i];
+                this.data.push(element);
+                added.send2(element, this.length++);
+            }
+        } else {
+            //no observers, we can add elements faster
+            Array.prototype.push.apply(this.data, elements);
+            this.length += addedElementsCount;
         }
-    } else {
-        //no observers, we can add elements faster
-        Array.prototype.push.apply(this.data, elements);
-        this.length += addedElementsCount;
     }
-};
 
-/**
- *
- * @param {Array.<T>} elements
- */
-List.prototype.addAllUnique = function (elements) {
-    const data = this.data;
+    /**
+     *
+     * @param {Array.<T>} elements
+     */
+    addAllUnique(elements) {
+        const data = this.data;
 
-    const unique = elements.filter(function (e, i) {
-        return data.indexOf(e) === -1 && elements.indexOf(e, i + 1) === -1;
-    });
+        const unique = elements.filter(function (e, i) {
+            return data.indexOf(e) === -1 && elements.indexOf(e, i + 1) === -1;
+        });
 
-    this.addAll(unique);
-};
+        this.addAll(unique);
+    }
 
-/**
- *
- * @param {number} index
- * @param {number} removeCount
- * @returns {T[]}
- */
-List.prototype.removeMany = function (index, removeCount) {
-    assert.equal(typeof index, 'number', `index must a number, instead was '${typeof index}'`);
-    assert.ok(index < this.length || index < 0, `index(=${index}) out of range (${this.length})`);
+    /**
+     *
+     * @param {number} index
+     * @param {number} removeCount
+     * @returns {T[]}
+     */
+    removeMany(index, removeCount) {
+        assert.equal(typeof index, 'number', `index must a number, instead was '${typeof index}'`);
+        assert.ok(index < this.length || index < 0, `index(=${index}) out of range (${this.length})`);
 
-    const els = this.data.splice(index, removeCount);
+        const els = this.data.splice(index, removeCount);
 
-    const removedCount = els.length;
+        const removedCount = els.length;
 
-    this.length -= removedCount;
+        this.length -= removedCount;
 
-    assert.equal(this.length, this.data.length, `length(=${this.length}) is inconsistent with underlying data array length(=${this.data.length})`)
+        assert.equal(this.length, this.data.length, `length(=${this.length}) is inconsistent with underlying data array length(=${this.data.length})`)
 
-    if (this.on.removed.hasHandlers()) {
-        for (let i = 0; i < removedCount; i++) {
-            const element = els[i];
+        if (this.on.removed.hasHandlers()) {
+            for (let i = 0; i < removedCount; i++) {
+                const element = els[i];
 
-            this.on.removed.send2(element, index + i);
+                this.on.removed.send2(element, index + i);
+            }
         }
-    }
 
-    return els;
-};
+        return els;
+    }
 
-/**
- *
- * @param {number} index
- * @returns {T}
- */
-List.prototype.remove = function (index) {
-    assert.equal(typeof index, 'number', `index must a number, instead was '${typeof index}'`);
-    assert.ok(index < this.length || index < 0, `index(=${index}) out of range (${this.length})`);
+    /**
+     *
+     * @param {number} index
+     * @returns {T}
+     */
+    remove(index) {
+        assert.equal(typeof index, 'number', `index must a number, instead was '${typeof index}'`);
+        assert.ok(index < this.length || index < 0, `index(=${index}) out of range (${this.length})`);
 
-    const els = this.data.splice(index, 1);
+        const els = this.data.splice(index, 1);
 
-    this.length--;
+        this.length--;
 
-    assert.equal(this.length, this.data.length, `length(=${this.length}) is inconsistent with underlying data array length(=${this.data.length})`)
+        assert.equal(this.length, this.data.length, `length(=${this.length}) is inconsistent with underlying data array length(=${this.data.length})`)
 
-    const element = els[0];
+        const element = els[0];
 
-    this.on.removed.send2(element, index);
+        this.on.removed.send2(element, index);
 
-    return element;
-};
+        return element;
+    }
 
-/**
- *
- * @param {Object} a
- * @param {Object} b
- * @returns {boolean}
- */
-function objectsEqual(a, b) {
-    return a === b || (typeof a.equals === "function" && a.equals(b));
-}
+    /**
+     *
+     * @param {T[]} elements
+     * @returns {boolean} True is all specified elements were found and removed, False if some elements were not present in the list
+     */
+    removeAll(elements) {
+        let i, il;
+        let j, jl;
 
-/**
- *
- * @param {Array.<T>} elements
- * @returns {boolean} True is all specified elements were found and removed, False if some elements were not present in the list
- */
-List.prototype.removeAll = function (elements) {
-    let i, il;
-    let j, jl;
+        il = elements.length;
+        jl = this.length;
 
-    il = elements.length;
-    jl = this.length;
+        let missCount = 0;
 
-    let missCount = 0;
+        const data = this.data;
 
-    const data = this.data;
+        main_loop: for (i = 0; i < il; i++) {
 
-    main_loop: for (i = 0; i < il; i++) {
+            const expected = elements[i];
 
-        const expected = elements[i];
+            for (j = jl - 1; j >= 0; j--) {
 
-        for (j = jl - 1; j >= 0; j--) {
+                const actual = data[j];
 
-            const actual = data[j];
+                if (objectsEqual(actual, expected)) {
 
-            if (objectsEqual(actual, expected)) {
+                    this.remove(j);
 
-                this.remove(j);
+                    jl--;
 
-                jl--;
 
+                    continue main_loop;
 
-                continue main_loop;
+                }
 
             }
 
-        }
 
+            missCount++;
+        }
 
-        missCount++;
+        //some elements were not deleted
+        return missCount === 0;
     }
 
-    //some elements were not deleted
-    return missCount === 0;
-};
-
-function conditionEqualsViaMethod(v) {
-    return this === v || this.equals(v);
-}
-
-function conditionEqualsStrict(v) {
-    return this === v;
-}
-
-/**
- *
- * @param {T} value
- * @return {boolean}
- */
-List.prototype.removeOneOf = function (value) {
-    if (typeof value === "object" && typeof value.equals === "function") {
-        return this.removeOneIf(conditionEqualsViaMethod, value);
-    } else {
-        return this.removeOneIf(conditionEqualsStrict, value);
+    /**
+     *
+     * @param {T} value
+     * @return {boolean}
+     */
+    removeOneOf(value) {
+        if (typeof value === "object" && typeof value.equals === "function") {
+            return this.removeOneIf(conditionEqualsViaMethod, value);
+        } else {
+            return this.removeOneIf(conditionEqualsStrict, value);
+        }
     }
-};
 
-List.prototype.sort = function () {
-    Array.prototype.sort.apply(this.data, arguments);
-    return this;
-};
+    sort() {
+        Array.prototype.sort.apply(this.data, arguments);
+        return this;
+    }
 
-/**
- * Copy of this list
- * @returns {List.<T>}
- */
-List.prototype.clone = function () {
-    return new List(this.data);
-};
+    /**
+     * Copy of this list
+     * @returns {List.<T>}
+     */
+    clone() {
+        return new List(this.data);
+    }
 
-/**
- *
- * @param {function(element:T):boolean} condition
- * @returns {boolean}
- */
-List.prototype.some = function (condition) {
-    const l = this.length;
-    const data = this.data;
-    for (let i = 0; i < l; i++) {
-        if (condition(data[i])) {
-            return true;
+    /**
+     *
+     * @param {function(element:T):boolean} condition
+     * @returns {boolean}
+     */
+    some(condition) {
+        const l = this.length;
+        const data = this.data;
+        for (let i = 0; i < l; i++) {
+            if (condition(data[i])) {
+                return true;
+            }
         }
+        return false;
     }
-    return false;
-};
 
-/**
- *
- * @param {function(T):boolean} condition must return boolean value
- */
-List.prototype.removeIf = function (condition) {
-    let l = this.length;
-    const data = this.data;
-    for (let i = 0; i < l; i++) {
-        if (condition(data[i])) {
-            this.remove(i);
-            i--;
-            l--;
+    /**
+     *
+     * @param {function(T):boolean} condition must return boolean value
+     * @param {*} [thisArg]
+     */
+    removeIf(condition, thisArg) {
+        assert.isFunction(condition, 'condition');
+
+        let l = this.length;
+        const data = this.data;
+        for (let i = 0; i < l; i++) {
+            const element = data[i];
+
+            if (condition.call(thisArg, element)) {
+                this.remove(i);
+                i--;
+                l--;
+            }
         }
     }
-};
 
-/**
- *
- * @param {function(T):boolean} condition
- * @param {*} [thisArg]
- * @return {boolean}
- */
-List.prototype.removeOneIf = function (condition, thisArg) {
-    const l = this.length;
-    const data = this.data;
+    /**
+     *
+     * @param {function(T):boolean} condition
+     * @param {*} [thisArg]
+     * @return {boolean}
+     */
+    removeOneIf(condition, thisArg) {
+        const l = this.length;
+        const data = this.data;
 
-    for (let i = 0; i < l; i++) {
-        const element = data[i];
+        for (let i = 0; i < l; i++) {
+            const element = data[i];
 
-        if (condition.call(thisArg, element)) {
-            this.remove(i);
-            return true;
+            if (condition.call(thisArg, element)) {
+                this.remove(i);
+                return true;
+            }
         }
-    }
 
-    return false;
-};
+        return false;
+    }
 
-/**
- * INVARIANT: List length must not change during the traversal
- * @param {function(el:T, index:number):?} f
- * @param {*} [thisArg]
- */
-List.prototype.forEach = function (f, thisArg) {
-    const l = this.length;
-    const data = this.data;
+    /**
+     * INVARIANT: List length must not change during the traversal
+     * @param {function(el:T, index:number):?} f
+     * @param {*} [thisArg]
+     */
+    forEach(f, thisArg) {
+        const l = this.length;
+        const data = this.data;
 
-    for (let i = 0; i < l; i++) {
+        for (let i = 0; i < l; i++) {
 
-        f.call(thisArg, data[i], i);
+            f.call(thisArg, data[i], i);
 
+        }
     }
-};
 
-/**
- * @param {function(*,T):*} f
- * @param {*} initial
- * @returns {*}
- */
-List.prototype.reduce = function (f, initial) {
-    let t = initial;
-    this.forEach(function (v) {
-        t = f(t, v);
-    });
-    return t;
-};
+    /**
+     * @param {function(*,T):*} f
+     * @param {*} initial
+     * @returns {*}
+     */
+    reduce(f, initial) {
+        let t = initial;
+        this.forEach(function (v) {
+            t = f(t, v);
+        });
+        return t;
+    }
 
-/**
- *
- * @param {function(T):boolean} f
- * @returns {Array.<T>}
- */
-List.prototype.filter = function (f) {
-    return this.data.filter(f);
-};
+    /**
+     *
+     * @param {function(T):boolean} f
+     * @returns {Array.<T>}
+     */
+    filter(f) {
+        return this.data.filter(f);
+    }
 
-/**
- *
- * @param {function(el:T):boolean} matcher
- * @returns {T|undefined}
- */
-List.prototype.find = function (matcher) {
-    const data = this.data;
-    let i = 0;
-    const l = this.length;
-    for (; i < l; i++) {
-        const el = data[i];
-        if (matcher(el)) {
-            return el;
+    /**
+     *
+     * @param {function(el:T):boolean} matcher
+     * @returns {T|undefined}
+     */
+    find(matcher) {
+        const data = this.data;
+        let i = 0;
+        const l = this.length;
+        for (; i < l; i++) {
+            const el = data[i];
+            if (matcher(el)) {
+                return el;
+            }
         }
-    }
 
-    return undefined;
-};
+        return undefined;
+    }
 
-/**
- *
- * @param {function(T):boolean} matcher
- * @returns {number} Index of the first match or -1
- */
-List.prototype.findIndex = function (matcher) {
-    const data = this.data;
+    /**
+     *
+     * @param {function(T):boolean} matcher
+     * @returns {number} Index of the first match or -1
+     */
+    findIndex(matcher) {
+        const data = this.data;
 
-    let i = 0;
+        let i = 0;
 
-    const l = this.length;
+        const l = this.length;
 
-    for (; i < l; i++) {
-        const el = data[i];
-        if (matcher(el)) {
-            return i;
+        for (; i < l; i++) {
+            const el = data[i];
+            if (matcher(el)) {
+                return i;
+            }
         }
-    }
 
-    return -1;
-};
-
-/**
- *
- * @param {function} matcher
- * @param {List~ConsumerCallback<T>} callback
- */
-List.prototype.visitFirstMatch = function (matcher, callback) {
-    const data = this.data;
-    let i = 0;
-    const l = this.length;
-    for (; i < l; i++) {
-        const el = data[i];
-        if (matcher(el)) {
-            callback(el, i);
-            return;
-        }
-    }
-};
-/**
- *
- * @param {T} v
- * @returns {boolean}
- */
-List.prototype.contains = function (v) {
-    return this.data.indexOf(v) !== -1;
-};
-
-/**
- * Does the list contain at least one of the given options?
- * @param {T[]} options
- * @returns {boolean}
- */
-List.prototype.containsAny = function (options) {
-    const n = options.length;
+        return -1;
+    }
 
-    for (let i = 0; i < n; i++) {
-        const option = options[i];
-        if (this.contains(option)) {
-            return true;
+    /**
+     *
+     * @param {function(el:T):boolean} matcher
+     * @param {function(el:T, index:number):*} callback
+     */
+    visitFirstMatch(matcher, callback) {
+        const data = this.data;
+        let i = 0;
+        const l = this.length;
+        for (; i < l; i++) {
+            const el = data[i];
+            if (matcher(el)) {
+                callback(el, i);
+                return;
+            }
         }
     }
 
-    return false;
-};
-
-/**
- * List has no elements
- * @returns {boolean}
- */
-List.prototype.isEmpty = function () {
-    return this.length <= 0;
-};
-
-/**
- *
- * @param {T} el
- * @returns {number}
- */
-List.prototype.indexOf = function (el) {
-    return this.data.indexOf(el);
-};
-
-/**
- * @template R
- * @param {function(T):R} callback
- * @param {*} [thisArg]
- * @returns {R[]}
- */
-List.prototype.map = function (callback, thisArg) {
-    const result = [];
-    const data = this.data;
-    const l = this.length;
+    /**
+     *
+     * @param {T} v
+     * @returns {boolean}
+     */
+    contains(v) {
+        return this.data.indexOf(v) !== -1;
+    }
 
-    for (let i = 0; i < l; i++) {
+    /**
+     * Does the list contain at least one of the given options?
+     * @param {T[]} options
+     * @returns {boolean}
+     */
+    containsAny(options) {
+        const n = options.length;
 
-        const datum = data[i];
-        if (datum !== undefined) {
-            result[i] = callback.call(thisArg, datum, i);
+        for (let i = 0; i < n; i++) {
+            const option = options[i];
+            if (this.contains(option)) {
+                return true;
+            }
         }
-    }
 
-    return result;
-};
+        return false;
+    }
 
-/**
- *
- * @param {function(element:T,index:number)} callback
- * @param {*} [thisArg]
- */
-List.prototype.resetViaCallback = function (callback, thisArg) {
-    const length = this.length;
-    if (length > 0) {
+    /**
+     * List has no elements
+     * @returns {boolean}
+     */
+    isEmpty() {
+        return this.length <= 0;
+    }
 
-        const removed = this.on.removed;
+    /**
+     *
+     * @param {T} el
+     * @returns {number}
+     */
+    indexOf(el) {
+        return this.data.indexOf(el);
+    }
 
-        const oldElements = this.data;
+    /**
+     * @template R
+     * @param {function(T):R} callback
+     * @param {*} [thisArg]
+     * @returns {R[]}
+     */
+    map(callback, thisArg) {
+        const result = [];
+        const data = this.data;
+        const l = this.length;
 
-        //only signal if there are listeners attached
-        for (let i = length - 1; i >= 0; i--) {
-            const element = oldElements[i];
-            // decrement data length gradually to allow handlers access to the rest of the elements
-            this.data.length = i;
-            this.length = i;
-            removed.send2(element, i);
+        for (let i = 0; i < l; i++) {
 
-            callback.call(thisArg, element, i);
+            const datum = data[i];
+            if (datum !== undefined) {
+                result[i] = callback.call(thisArg, datum, i);
+            }
         }
 
+        return result;
     }
-};
-
-List.prototype.reset = function () {
-    const length = this.length;
-    if (length > 0) {
 
-        const removed = this.on.removed;
+    /**
+     *
+     * @param {function(element:T,index:number)} callback
+     * @param {*} [thisArg]
+     */
+    resetViaCallback(callback, thisArg) {
+        const length = this.length;
+        if (length > 0) {
 
-        if (removed.hasHandlers()) {
+            const removed = this.on.removed;
 
             const oldElements = this.data;
 
@@ -666,281 +640,325 @@ List.prototype.reset = function () {
                 this.data.length = i;
                 this.length = i;
                 removed.send2(element, i);
+
+                callback.call(thisArg, element, i);
             }
 
-        } else {
-            this.data = [];
-            this.length = 0;
         }
-
     }
-};
 
-/**
- *
- * @param {List<T>} other
- * @param {function} [removeCallback]
- * @param {*} [thisArg] Used on removeCallback
- */
-List.prototype.deepCopy = function (other, removeCallback, thisArg) {
-    assert.notEqual(other, undefined, 'other is undefined');
-    assert.notEqual(other, null, 'other is null');
+    reset() {
+        const length = this.length;
+        if (length > 0) {
 
-    const newData = [];
+            const removed = this.on.removed;
 
-    const otherItems = other.asArray();
-    const nOtherItems = otherItems.length;
+            if (removed.hasHandlers()) {
 
-    const thisItems = this.data;
-    let nThisItems = this.length;
+                const oldElements = this.data;
 
-    //walk existing elements and see what can be kept
-    for (let i = 0; i < nThisItems; i++) {
-        const a = thisItems[i];
+                //only signal if there are listeners attached
+                for (let i = length - 1; i >= 0; i--) {
+                    const element = oldElements[i];
+                    // decrement data length gradually to allow handlers access to the rest of the elements
+                    this.data.length = i;
+                    this.length = i;
+                    removed.send2(element, i);
+                }
 
-        const index = arrayIndexByEquality(otherItems, a, invokeObjectEquals);
+            } else {
+                this.data = [];
+                this.length = 0;
+            }
 
-        if (index !== -1) {
-            newData[index] = a;
-        } else if (typeof removeCallback === "function") {
-            removeCallback.call(thisArg, a);
         }
     }
 
-    //fill in the blanks
-    for (let i = 0; i < nOtherItems; i++) {
-        if (newData[i] === undefined) {
-            const otherItem = otherItems[i];
-            newData[i] = otherItem.clone();
+    /**
+     * Note that elements must have .clone method for this to work
+     * @param {List<T>} other
+     * @param {function} [removeCallback]
+     * @param {*} [thisArg] Used on removeCallback
+     */
+    deepCopy(other, removeCallback, thisArg) {
+        assert.notEqual(other, undefined, 'other is undefined');
+        assert.notEqual(other, null, 'other is null');
+
+        const newData = [];
+
+        const otherItems = other.asArray();
+        const nOtherItems = otherItems.length;
+
+        const thisItems = this.data;
+        let nThisItems = this.length;
+
+        //walk existing elements and see what can be kept
+        for (let i = 0; i < nThisItems; i++) {
+            const a = thisItems[i];
+
+            const index = arrayIndexByEquality(otherItems, a, invokeObjectEquals);
+
+            if (index !== -1) {
+                newData[index] = a;
+            } else if (typeof removeCallback === "function") {
+                removeCallback.call(thisArg, a);
+            }
         }
-    }
 
-    this.reset();
-    this.addAll(newData);
-};
+        //fill in the blanks
+        for (let i = 0; i < nOtherItems; i++) {
+            if (newData[i] === undefined) {
+                const otherItem = otherItems[i];
+                newData[i] = otherItem.clone();
+            }
+        }
 
-/**
- *
- * @param {List<T>|T[]} other
- */
-List.prototype.copy = function (other) {
-    if (this !== other) {
         this.reset();
-        if (other.length > 0) {
-            if (other instanceof List) {
-                this.addAll(other.data);
-            } else {
-                this.addAll(other);
+        this.addAll(newData);
+    }
+
+    /**
+     *
+     * @param {List<T>|T[]} other
+     */
+    copy(other) {
+        if (this !== other) {
+            this.reset();
+            if (other.length > 0) {
+                if (other instanceof List) {
+                    this.addAll(other.data);
+                } else {
+                    this.addAll(other);
+                }
             }
         }
     }
-};
 
-/**
- * NOTE: do not modify resulting array
- * @returns {T[]}
- */
-List.prototype.asArray = function () {
-    return this.data;
-};
+    /**
+     * NOTE: do not modify resulting array
+     * @returns {T[]}
+     */
+    asArray() {
+        return this.data;
+    }
 
-List.prototype.toJSON = function () {
-    return JSON.parse(JSON.stringify(this.data));
-};
+    toJSON() {
+        return JSON.parse(JSON.stringify(this.data));
+    }
 
-/**
- *
- * @param {object} json
- * @param {function} constructor
- */
-List.prototype.fromJSON = function (json, constructor) {
-    this.reset();
+    /**
+     *
+     * @param {[]} json
+     * @param {function} constructor
+     */
+    fromJSON(json, constructor) {
+        this.reset();
 
-    assert.isArray(json, 'json');
+        assert.isArray(json, 'json');
 
-    if (typeof constructor === "function") {
-        this.addAll(json.map(function (elJSON) {
-            const el = new constructor();
-            el.fromJSON(elJSON);
-            return el;
-        }));
-    } else {
-        this.addAll(json);
+        if (typeof constructor === "function") {
+            this.addAll(json.map(function (elJSON) {
+                const el = new constructor();
+                el.fromJSON(elJSON);
+                return el;
+            }));
+        } else {
+            this.addAll(json);
+        }
     }
-};
 
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        const n = this.length;
 
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-List.prototype.toBinaryBuffer = function (buffer) {
-    const n = this.length;
+        buffer.writeUint32(n);
 
-    buffer.writeUint32(n);
+        for (let i = 0; i < n; i++) {
+            const item = this.data[i];
 
-    for (let i = 0; i < n; i++) {
-        const item = this.data[i];
+            if (typeof item.toBinaryBuffer !== "function") {
+                throw new Error('item.toBinaryBuffer is not a function');
+            }
 
-        if (typeof item.toBinaryBuffer !== "function") {
-            throw new Error('item.toBinaryBuffer is not a function');
+            item.toBinaryBuffer(buffer);
         }
-
-        item.toBinaryBuffer(buffer);
     }
-};
 
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param constructor
- */
-List.prototype.fromBinaryBuffer = function (buffer, constructor) {
-    this.fromBinaryBufferViaFactory(buffer, function (buffer) {
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param constructor
+     */
+    fromBinaryBuffer(buffer, constructor) {
+        this.fromBinaryBufferViaFactory(buffer, function (buffer) {
 
-        const el = new constructor();
+            const el = new constructor();
 
-        if (typeof el.fromBinaryBuffer !== "function") {
-            throw new Error('item.fromBinaryBuffer is not a function');
-        }
+            if (typeof el.fromBinaryBuffer !== "function") {
+                throw new Error('item.fromBinaryBuffer is not a function');
+            }
 
-        el.fromBinaryBuffer(buffer);
+            el.fromBinaryBuffer(buffer);
 
-        return el;
-    });
-};
+            return el;
+        });
+    }
 
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {function(buffer:BinaryBuffer)} factory
- */
-List.prototype.fromBinaryBufferViaFactory = function (buffer, factory) {
-    this.reset();
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {function(buffer:BinaryBuffer)} factory
+     */
+    fromBinaryBufferViaFactory(buffer, factory) {
+        this.reset();
 
-    this.addFromBinaryBufferViaFactory(buffer, factory);
-};
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {function(buffer:BinaryBuffer)} factory
- */
-List.prototype.addFromBinaryBufferViaFactory = function (buffer, factory) {
-    const length = buffer.readUint32();
+        this.addFromBinaryBufferViaFactory(buffer, factory);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {function(buffer:BinaryBuffer)} factory
+     */
+    addFromBinaryBufferViaFactory(buffer, factory) {
+        const length = buffer.readUint32();
 
-    for (let i = 0; i < length; i++) {
-        const el = factory(buffer);
+        for (let i = 0; i < length; i++) {
+            const el = factory(buffer);
 
-        this.add(el);
+            this.add(el);
+        }
     }
-};
 
-/**
- * @template J
- * @param {J[]} data
- * @param {function(J):T} factory
- */
-List.prototype.addFromJSONViaFactory = function (data, factory) {
-    const n = data.length;
-    for (let i = 0; i < n; i++) {
-        const datum = data[i];
+    /**
+     * @template J
+     * @param {J[]} data
+     * @param {function(J):T} factory
+     */
+    addFromJSONViaFactory(data, factory) {
+        const n = data.length;
+        for (let i = 0; i < n; i++) {
+            const datum = data[i];
 
-        const el = factory(datum);
+            const el = factory(datum);
 
-        this.add(el);
+            this.add(el);
+        }
     }
-};
 
-/**
- * NOTE: Elements must have hash method
- * @returns {number}
- */
-List.prototype.hash = function () {
-    let hash = 0;
-    const length = this.length;
+    /**
+     * NOTE: Elements must have hash method
+     * @returns {number}
+     */
+    hash() {
+        let hash = 0;
+        const length = this.length;
+
+        for (let i = 0; i < length; i++) {
+            const datum = this.data[i];
+            const singleValue = datum.hash();
+            hash = ((hash << 5) - hash) + singleValue;
+            hash |= 0; // Convert to 32bit integer
+        }
 
-    for (let i = 0; i < length; i++) {
-        const datum = this.data[i];
-        const singleValue = datum.hash();
-        hash = ((hash << 5) - hash) + singleValue;
-        hash |= 0; // Convert to 32bit integer
+        return hash;
     }
 
-    return hash;
-};
+    /**
+     *
+     * @return {T|undefined}
+     */
+    last() {
+        return this.data[this.length - 1];
+    }
 
-/**
- *
- * @return {T|undefined}
- */
-List.prototype.last = function () {
-    return this.data[this.length - 1];
-};
+    /**
+     * Perform element-wise equality comparison with another list
+     * @param {List} other
+     */
+    equals(other) {
+        assert.defined(other, 'other');
 
-/**
- * Perform element-wise equality comparison with another list
- * @param {List} other
- */
-List.prototype.equals = function (other) {
-    assert.defined(other, 'other');
+        const length = this.length;
 
-    const length = this.length;
+        if (length !== other.length) {
+            return false;
+        }
 
-    if (length !== other.length) {
-        return false;
-    }
+        let i;
 
-    let i;
+        for (i = 0; i < length; i++) {
+            const a = this.get(i);
 
-    for (i = 0; i < length; i++) {
-        const a = this.get(i);
+            const b = other.get(i);
 
-        const b = other.get(i);
+            if (a === b) {
+                continue;
+            }
 
-        if (a === b) {
-            continue;
-        }
+            if (typeof a === "object" && typeof b === "object" && typeof a.equals === "function" && a.equals(b)) {
+                //test via "equals" method
+                continue;
+            }
 
-        if (typeof a === "object" && typeof b === "object" && typeof a.equals === "function" && a.equals(b)) {
-            //test via "equals" method
-            continue;
+            //elements not equal
+            return false;
         }
 
-        //elements not equal
-        return false;
+        return true;
     }
 
-    return true;
-};
+    /**
+     *
+     * @param {List<T>} other
+     * @returns {number}
+     */
+    compare(other) {
+        const l = this.length;
 
-/**
- *
- * @param {List<T>} other
- * @returns {number}
- */
-List.prototype.compare = function (other) {
-    const l = this.length;
+        const other_length = other.length;
+        if (l !== other_length) {
+            return l - other_length;
+        }
 
-    const other_length = other.length;
-    if (l !== other_length) {
-        return l - other_length;
-    }
+        for (let i = 0; i < l; i++) {
+            const a = this.get(i);
 
-    for (let i = 0; i < l; i++) {
-        const a = this.get(i);
+            const b = other.get(i);
 
-        const b = other.get(i);
+            const delta = a.compare(b);
 
-        const delta = a.compare(b);
+            if (delta !== 0) {
+                return delta;
+            }
 
-        if (delta !== 0) {
-            return delta;
         }
 
+        // same
+        return 0;
     }
+}
+
+/**
+ *
+ * @param {Object} a
+ * @param {Object} b
+ * @returns {boolean}
+ */
+function objectsEqual(a, b) {
+    return a === b || (typeof a.equals === "function" && a.equals(b));
+}
+
+function conditionEqualsViaMethod(v) {
+    return this === v || this.equals(v);
+}
+
+function conditionEqualsStrict(v) {
+    return this === v;
+}
 
-    // same
-    return 0;
-};
 
 export default List;