@blazedpath/commons 0.0.8 → 0.0.9

package/blz-iterable/index.js

@@ -1,446 +1,448 @@
 module.exports = {
-    errorUndefinedArgument: function( argName ) {
-        const err = new Error();
-        err.code = 'UndefinedArgument';
-        err.data = { argName: argName };
-        return err;
-    },
-    compare: function( value1, value2 ) { // TODO: Sort require for objects
-        if( value1 === null && value2 === null ) return 0;
-        if( value1 === null && value2 !== null ) return -1;
-        if( value1 !== null && value2 === null ) return 1;
-
-        const value1Type = toString.call( value1 );
-        const value2Type = toString.call( value2 );
-        let value1ToCompare = null;
-        let value2ToCompare = null;
-        if ((value1Type === '[object String]' && value2Type === '[object String]') ||
-            (value1Type === '[object Number]' && value2Type === '[object Number]')) {
-            value1ToCompare = value1;
-            value2ToCompare = value2;
-        }
-        else if( value1Type === '[object Boolean]' && value2Type === '[object Boolean]' ) {
-            value1ToCompare = value1 ? 1 : 0;
-            value2ToCompare = value2 ? 1 : 0;
-        }
-        else if( value1Type === '[object Date]' && value2Type === '[object Date]' ) {
-            value1ToCompare = value1.getTime();
-            value2ToCompare = value2.getTime();
-        }
-        else if( value1Type === '[object Object]' && value2Type === '[object Object]' ) {
-            value1ToCompare = JSON.stringify( value1 );
-            value2ToCompare = JSON.stringify( value2 );
-        }
-        else if( value1Type === '[object Array]' && value2Type === '[object Array]' ) {
-            let result = this.compare( value1.length, value2.length );
-            if( result !== 0 )
-                return result;
-            for( let i = 0; i < value1.length; ++i ) {
-                const item1 = value1[ i ];
-                const item2 = value2[ i ];
-                result = this.compare( item1, item2 );
-                if( result !== 0 )
+    Dual: {
+        errorUndefinedArgument: function (argName) {
+            const err = new Error();
+            err.code = 'UndefinedArgument';
+            err.data = { argName: argName };
+            return err;
+        },
+        compare: function (value1, value2) { // TODO: Sort require for objects
+            if (value1 === null && value2 === null) return 0;
+            if (value1 === null && value2 !== null) return -1;
+            if (value1 !== null && value2 === null) return 1;
+
+            const value1Type = toString.call(value1);
+            const value2Type = toString.call(value2);
+            let value1ToCompare = null;
+            let value2ToCompare = null;
+            if ((value1Type === '[object String]' && value2Type === '[object String]') ||
+                (value1Type === '[object Number]' && value2Type === '[object Number]')) {
+                value1ToCompare = value1;
+                value2ToCompare = value2;
+            }
+            else if (value1Type === '[object Boolean]' && value2Type === '[object Boolean]') {
+                value1ToCompare = value1 ? 1 : 0;
+                value2ToCompare = value2 ? 1 : 0;
+            }
+            else if (value1Type === '[object Date]' && value2Type === '[object Date]') {
+                value1ToCompare = value1.getTime();
+                value2ToCompare = value2.getTime();
+            }
+            else if (value1Type === '[object Object]' && value2Type === '[object Object]') {
+                value1ToCompare = JSON.stringify(value1);
+                value2ToCompare = JSON.stringify(value2);
+            }
+            else if (value1Type === '[object Array]' && value2Type === '[object Array]') {
+                let result = this.compare(value1.length, value2.length);
+                if (result !== 0)
                     return result;
+                for (let i = 0; i < value1.length; ++i) {
+                    const item1 = value1[i];
+                    const item2 = value2[i];
+                    result = this.compare(item1, item2);
+                    if (result !== 0)
+                        return result;
+                }
+                return 0;
             }
-            return 0;
-        }
-        else {
-            const getValueToCompare = ( valueType, value ) => {
-                switch( valueType ) {
-                    case '[object String]'  : return value
-                    case '[object Number]'  : return value.toString()
-                    case '[object Boolean]' : return value ? '1' : '0'
-                    case '[object Date]'    : return value.toJSON()
-                    default                 : return value.toString()
+            else {
+                const getValueToCompare = (valueType, value) => {
+                    switch (valueType) {
+                        case '[object String]': return value
+                        case '[object Number]': return value.toString()
+                        case '[object Boolean]': return value ? '1' : '0'
+                        case '[object Date]': return value.toJSON()
+                        default: return value.toString()
+                    }
+
                 }
 
+                value1ToCompare = getValueToCompare(value1Type, value1)
+                value2ToCompare = getValueToCompare(value2Type, value2)
             }
 
-            value1ToCompare = getValueToCompare( value1Type, value1 )
-            value2ToCompare = getValueToCompare( value2Type, value2 )
-        }
-
-        if( value1ToCompare === value2ToCompare ) return 0;
-        else if( value1ToCompare < value2ToCompare ) return -1;
-        else if( value1ToCompare > value2ToCompare ) return 1;
-        else return null;
+            if (value1ToCompare === value2ToCompare) return 0;
+            else if (value1ToCompare < value2ToCompare) return -1;
+            else if (value1ToCompare > value2ToCompare) return 1;
+            else return null;
 
-    },
-    all: function( list, fnCondition ) {
-        if( list === null ) return false;
+        },
+        all: function (list, fnCondition) {
+            if (list === null) return false;
 
-        for( let i = 0; i < list.length; ++i ) {
-            const item = list[ i ];
-            if( !(fnCondition( item )) )
-                return false;
-        }
-        return true;
-    },
-    any: function( list, fnCondition ) {
-        if( list === null ) return false;
-
-        for( let i = 0; i < list.length; ++i ) {
-            const item = list[ i ];
-            if( fnCondition( item ) )
-                return true;
-        }
-        return false;
-    },
-    avg: function( list, fnSelection ) {
-        if( list === null ) return null;
-
-        let totalSum = 0;
-        let totalCount = 0;
-        if( fnSelection ) {
-            for( let i = 0; i < list.length; ++i ) {
-                const item = list[ i ];
-                const value = fnSelection( item );
-                if( value !== null ) {
-                    totalSum += value;
-                    totalCount++;
+            for (let i = 0; i < list.length; ++i) {
+                const item = list[i];
+                if (!(fnCondition(item)))
+                    return false;
+            }
+            return true;
+        },
+        any: function (list, fnCondition) {
+            if (list === null) return false;
+
+            for (let i = 0; i < list.length; ++i) {
+                const item = list[i];
+                if (fnCondition(item))
+                    return true;
+            }
+            return false;
+        },
+        avg: function (list, fnSelection) {
+            if (list === null) return null;
+
+            let totalSum = 0;
+            let totalCount = 0;
+            if (fnSelection) {
+                for (let i = 0; i < list.length; ++i) {
+                    const item = list[i];
+                    const value = fnSelection(item);
+                    if (value !== null) {
+                        totalSum += value;
+                        totalCount++;
+                    }
                 }
             }
-        }
-        else {
-            for( let i = 0; i < list.length; ++i ) {
-                const value = list[ i ];
-                if( value !== null ) {
-                    totalSum += value;
-                    totalCount++;
+            else {
+                for (let i = 0; i < list.length; ++i) {
+                    const value = list[i];
+                    if (value !== null) {
+                        totalSum += value;
+                        totalCount++;
+                    }
                 }
             }
-        }
-        return totalSum / totalCount;
-    },
-    concatList: function() {
-        if( arguments.length === 0 ) return null
-        if( arguments.length === 1 && arguments[ 0 ] === null ) return null
-        return Array.from( arguments ).filter( list => list !== null ).flat()
-    },
-    count: function( list ) {
-        if( list === null ) return null;
-        return list.length;
-    },
-    distinct: function( list, fnSelection ) {
-        if( list === null ) return null;
-
-        const resultArray = [];
-        if( fnSelection ) {
-            const keys = [];
-            for( let i = 0; i < list.length; ++i ) {
-                const item = list[ i ];
-                const key = fnSelection( item );
-                if( keys.indexOf( key ) === -1 ) {
-                    keys.push( key );
-                    resultArray.push( item );
+            return totalSum / totalCount;
+        },
+        concatList: function () {
+            if (arguments.length === 0) return null
+            if (arguments.length === 1 && arguments[0] === null) return null
+            return Array.from(arguments).filter(list => list !== null).flat()
+        },
+        count: function (list) {
+            if (list === null) return null;
+            return list.length;
+        },
+        distinct: function (list, fnSelection) {
+            if (list === null) return null;
+
+            const resultArray = [];
+            if (fnSelection) {
+                const keys = [];
+                for (let i = 0; i < list.length; ++i) {
+                    const item = list[i];
+                    const key = fnSelection(item);
+                    if (keys.indexOf(key) === -1) {
+                        keys.push(key);
+                        resultArray.push(item);
+                    }
                 }
             }
-        }
-        else {
-            for( let i = 0; i < list.length; ++i ) {
-                const item = list[ i ];
-                if( resultArray.indexOf( item ) === -1 )
-                    resultArray.push( item );
+            else {
+                for (let i = 0; i < list.length; ++i) {
+                    const item = list[i];
+                    if (resultArray.indexOf(item) === -1)
+                        resultArray.push(item);
+                }
             }
-        }
-        return resultArray;
-    },
-    elementAt: function( list, index ) {
-        if( list === null ) return null
-
-        const result = list[ index ]
-        return result === undefined ? null : result
-    },
-    getSelections: function( list, fnSelection ) {
-        if( !fnSelection ) return list
-
-        const selections = new Array( list.length )
-        for( let i = 0; i < list.length; ++i ) {
-            selections[ i ] = fnSelection( list[ i ] )
-        }
-        return selections
-    },
-    except: function( listA, listB, fnSelection ) {
-        if( listA === null ) return null
-        if( listB === null ) return listA.slice()
-
-        const selectionsA = this.getSelections( listA, fnSelection )
-        const selectionsB = this.getSelections( listB, fnSelection )
-
-        const resultArray = [];
-        for( let i = 0; i < listA.length; ++i ) {
-            let except = false
-            for( let j = 0; j < listB.length; ++j ) {
-                if( this.compare( selectionsA[ i ], selectionsB[ j ] ) === 0 ) {
-                    except = true
-                    break
+            return resultArray;
+        },
+        elementAt: function (list, index) {
+            if (list === null) return null
+
+            const result = list[index]
+            return result === undefined ? null : result
+        },
+        getSelections: function (list, fnSelection) {
+            if (!fnSelection) return list
+
+            const selections = new Array(list.length)
+            for (let i = 0; i < list.length; ++i) {
+                selections[i] = fnSelection(list[i])
+            }
+            return selections
+        },
+        except: function (listA, listB, fnSelection) {
+            if (listA === null) return null
+            if (listB === null) return listA.slice()
+
+            const selectionsA = this.getSelections(listA, fnSelection)
+            const selectionsB = this.getSelections(listB, fnSelection)
+
+            const resultArray = [];
+            for (let i = 0; i < listA.length; ++i) {
+                let except = false
+                for (let j = 0; j < listB.length; ++j) {
+                    if (this.compare(selectionsA[i], selectionsB[j]) === 0) {
+                        except = true
+                        break
+                    }
                 }
+                if (!except) resultArray.push(listA[i])
+            }
+            return resultArray;
+        },
+        findAll: function (list, fnCondition) {
+            if (list === null) return null;
+
+            const resultArray = [];
+            for (let i = 0; i < list.length; ++i) {
+                const item = list[i];
+                if (fnCondition(item))
+                    resultArray.push(item);
+            }
+            return resultArray;
+        },
+        findFirstInternal: function (list, fnCondition) {
+            if (list === null) return null
+
+            for (let i = 0; i < list.length; ++i) {
+                const item = list[i]
+                if (fnCondition(item))
+                    return { item, index: i }
             }
-            if( !except ) resultArray.push( listA[ i ] )
-        }
-        return resultArray;
-    },
-    findAll: function( list, fnCondition ) {
-        if( list === null ) return null;
-
-        const resultArray = [];
-        for( let i = 0; i < list.length; ++i ) {
-            const item = list[ i ];
-            if( fnCondition( item ) )
-                resultArray.push( item );
-        }
-        return resultArray;
-    },
-    findFirstInternal: function( list, fnCondition ) {
-        if( list === null ) return null
-
-        for( let i = 0; i < list.length; ++i ) {
-            const item = list[ i ]
-            if( fnCondition( item ) )
-                return { item, index: i }
-        }
 
-        return { item: null, index: -1 }
-    },
-    findFirst: function( list, fnCondition ) {
-        const result = this.findFirstInternal( list, fnCondition )
-        return result === null ? null : result.item
-    },
-    findIndex: function( list, fnCondition ) {
-        const result = this.findFirstInternal( list, fnCondition )
-        return result === null ? null : result.index
-    },
-    findLastInternal: function( list, fnCondition ) {
-        if( list === null ) return null
-
-        for( let i = ( list.length - 1 ); i > -1; i-- ) {
-            const item = list[ i ]
-            if( fnCondition( item ) )
-                return { item, index: i }
-        }
-        return { item: null, index: -1 }
-    },
-    findLast: function( list, fnCondition ) {
-        const result = this.findLastInternal( list, fnCondition )
-        return result === null ? null : result.item
-    },
-    findLastIndex: function( list, fnCondition ) {
-        const result = this.findLastInternal( list, fnCondition )
-        return result === null ? null : result.index
-    },
-    first: function( list ) {
-        if( list === null ) return null;
-        return list.length > 0 ? list[ 0 ] : null;
-    },
-    flat: function( list, depth ) {
-        if( list === null ) return null
-        return list.flat( depth )
-    },
-    includes: function( list, searchElement, fromIndex ) {
-        if( list === null ) return false
-        return list.includes( searchElement, fromIndex )
-    },
-    insertAt: function( list, index, elements ) {
-        if( list === null ) return null
-        if( elements === null ) return list.slice()
-        const copiedList = list.slice()
-        copiedList.splice( index, 0, ...elements )
-        return copiedList
-    },
-    intersect: function( listA, listB, fnSelection ) {
-        if( listA === null ) return null;
-        if( listB === null ) return null;
-
-        const selectionsA = this.getSelections( listA, fnSelection )
-        const selectionsB = this.getSelections( listB, fnSelection )
-
-        const resultArray = [];
-        for( let i = 0; i < listA.length; ++i ) {
-            let include = false;
-            for( let j = 0; j < listB.length; j++ ) {
-                if( this.compare( selectionsA[ i ], selectionsB[ j ] ) === 0 )
-                    include = true;
+            return { item: null, index: -1 }
+        },
+        findFirst: function (list, fnCondition) {
+            const result = this.findFirstInternal(list, fnCondition)
+            return result === null ? null : result.item
+        },
+        findIndex: function (list, fnCondition) {
+            const result = this.findFirstInternal(list, fnCondition)
+            return result === null ? null : result.index
+        },
+        findLastInternal: function (list, fnCondition) {
+            if (list === null) return null
+
+            for (let i = (list.length - 1); i > -1; i--) {
+                const item = list[i]
+                if (fnCondition(item))
+                    return { item, index: i }
             }
-            if( include )
-                resultArray.push( listA[ i ] );
-        }
-        return resultArray;
-    },
-    last: function( list ) {
-        if( list === null ) return null;
-        return list.length > 0 ? list[ list.length - 1 ] : null;
-    },
-    max: function( list, fnSelection ) {
-        if( list === null ) return null;
-
-        let max = null;
-        if( fnSelection ) {
-            for( let i = 0; i < list.length; ++i ) {
-                const item = list[ i ];
-                const value = fnSelection( item );
-                if( max === null || this.compare( value, max ) > 0 )
-                    max = value;
+            return { item: null, index: -1 }
+        },
+        findLast: function (list, fnCondition) {
+            const result = this.findLastInternal(list, fnCondition)
+            return result === null ? null : result.item
+        },
+        findLastIndex: function (list, fnCondition) {
+            const result = this.findLastInternal(list, fnCondition)
+            return result === null ? null : result.index
+        },
+        first: function (list) {
+            if (list === null) return null;
+            return list.length > 0 ? list[0] : null;
+        },
+        flat: function (list, depth) {
+            if (list === null) return null
+            return list.flat(depth)
+        },
+        includes: function (list, searchElement, fromIndex) {
+            if (list === null) return false
+            return list.includes(searchElement, fromIndex)
+        },
+        insertAt: function (list, index, elements) {
+            if (list === null) return null
+            if (elements === null) return list.slice()
+            const copiedList = list.slice()
+            copiedList.splice(index, 0, ...elements)
+            return copiedList
+        },
+        intersect: function (listA, listB, fnSelection) {
+            if (listA === null) return null;
+            if (listB === null) return null;
+
+            const selectionsA = this.getSelections(listA, fnSelection)
+            const selectionsB = this.getSelections(listB, fnSelection)
+
+            const resultArray = [];
+            for (let i = 0; i < listA.length; ++i) {
+                let include = false;
+                for (let j = 0; j < listB.length; j++) {
+                    if (this.compare(selectionsA[i], selectionsB[j]) === 0)
+                        include = true;
+                }
+                if (include)
+                    resultArray.push(listA[i]);
             }
-        }
-        else {
-            for( let i = 0; i < list.length; ++i ) {
-                const value = list[ i ];
-                if( max === null || this.compare( value, max ) > 0 )
-                    max = value;
+            return resultArray;
+        },
+        last: function (list) {
+            if (list === null) return null;
+            return list.length > 0 ? list[list.length - 1] : null;
+        },
+        max: function (list, fnSelection) {
+            if (list === null) return null;
+
+            let max = null;
+            if (fnSelection) {
+                for (let i = 0; i < list.length; ++i) {
+                    const item = list[i];
+                    const value = fnSelection(item);
+                    if (max === null || this.compare(value, max) > 0)
+                        max = value;
+                }
             }
-        }
-        return max;
-    },
-    min: function( list, fnSelection ) {
-        if( list === null ) return null;
-
-        let min = null;
-        if( fnSelection ) {
-            for( let i = 0; i < list.length; ++i ) {
-                const item = list[ i ];
-                const value = fnSelection( item );
-                if( min === null || this.compare( value, min ) < 0 )
-                    min = value;
+            else {
+                for (let i = 0; i < list.length; ++i) {
+                    const value = list[i];
+                    if (max === null || this.compare(value, max) > 0)
+                        max = value;
+                }
             }
-        }
-        else {
-            for( let i = 0; i < list.length; ++i ) {
-                const value = list[ i ];
-                if( min === null || this.compare( value, min ) < 0 )
-                    min = value;
+            return max;
+        },
+        min: function (list, fnSelection) {
+            if (list === null) return null;
+
+            let min = null;
+            if (fnSelection) {
+                for (let i = 0; i < list.length; ++i) {
+                    const item = list[i];
+                    const value = fnSelection(item);
+                    if (min === null || this.compare(value, min) < 0)
+                        min = value;
+                }
             }
-        }
-        return min;
-    },
-    removeAt: function( list, index, deleteCount ) {
-        if( list === null ) return null
-        const copiedList = list.slice()
-        copiedList.splice( index, deleteCount )
-        return copiedList
-    },
-    reverse: function( list ) {
-        if( list === null ) return null
-        return list.slice().reverse()
-    },
-    skip: function( list, count ) {
-        if( list === null ) return null
-        return list.slice( count )
-    },
-    skipWhile: function( list, fnCondition ) {
-        if( list === null ) return null
-
-        for( let i = 0; i < list.length; ++i ) {
-            if( !fnCondition( list[ i ] ) ) {
-                return list.slice( i )
+            else {
+                for (let i = 0; i < list.length; ++i) {
+                    const value = list[i];
+                    if (min === null || this.compare(value, min) < 0)
+                        min = value;
+                }
             }
-        }
-        return []
-    },
-    slice: function( list, start, end ) {
-        if( list === null ) return null
-        return list.slice( start, end )
-    },
-    sortInternal: function( { list, fnSelection, compareFunctionWithFnSelection, compareFunction } ) {
+            return min;
+        },
+        removeAt: function (list, index, deleteCount) {
+            if (list === null) return null
+            const copiedList = list.slice()
+            copiedList.splice(index, deleteCount)
+            return copiedList
+        },
+        reverse: function (list) {
+            if (list === null) return null
+            return list.slice().reverse()
+        },
+        skip: function (list, count) {
+            if (list === null) return null
+            return list.slice(count)
+        },
+        skipWhile: function (list, fnCondition) {
+            if (list === null) return null
+
+            for (let i = 0; i < list.length; ++i) {
+                if (!fnCondition(list[i])) {
+                    return list.slice(i)
+                }
+            }
+            return []
+        },
+        slice: function (list, start, end) {
+            if (list === null) return null
+            return list.slice(start, end)
+        },
+        sortInternal: function ({ list, fnSelection, compareFunctionWithFnSelection, compareFunction }) {
 
-        if( list === null ) return null
+            if (list === null) return null
 
-        if( !fnSelection ) return list.slice().sort( compareFunction )
+            if (!fnSelection) return list.slice().sort(compareFunction)
 
-        const unsorted = new Array( list.length )
-        for( let i = 0; i < list.length; ++i ) {
-            unsorted[ i ] = { index: i, compareValue: fnSelection( list[ i ] ) }
-        }
+            const unsorted = new Array(list.length)
+            for (let i = 0; i < list.length; ++i) {
+                unsorted[i] = { index: i, compareValue: fnSelection(list[i]) }
+            }
 
-        const sorted = unsorted.sort( compareFunctionWithFnSelection );
+            const sorted = unsorted.sort(compareFunctionWithFnSelection);
 
-        const resultArray = new Array( sorted.length )
-        for( let i = 0; i < sorted.length; ++i ) {
-            resultArray[ i ] = list[ sorted[ i ].index ]
-        }
+            const resultArray = new Array(sorted.length)
+            for (let i = 0; i < sorted.length; ++i) {
+                resultArray[i] = list[sorted[i].index]
+            }
 
-        return resultArray;
-    },
-    sort: function( list, fnSelection ) {
-        return this.sortInternal( {
-            list,
-            fnSelection,
-            compareFunctionWithFnSelection: function( a, b ) { return this.compare( a.compareValue, b.compareValue ) }.bind( this ),
-            compareFunction: function( a, b ) { return this.compare( a, b ) }.bind( this )
-        } )
-    },
-    sortDescending: function( list, fnSelection ) {
-        return this.sortInternal( {
-            list,
-            fnSelection,
-            compareFunctionWithFnSelection: function( a, b ) { return this.compare( b.compareValue, a.compareValue ); }.bind( this ),
-            compareFunction: function( a, b ) { return this.compare( b, a ); }.bind( this )
-        } )
-    },
-    sum: function( list, fnSelection ) {
-        if( list === null ) return null;
-        let sum = 0;
-        if( fnSelection ) {
-            for( let i = 0; i < list.length; ++i ) {
-                const item = list[ i ];
-                const value = fnSelection( item );
-                if( value !== null )
-                    sum += value;
+            return resultArray;
+        },
+        sort: function (list, fnSelection) {
+            return this.sortInternal({
+                list,
+                fnSelection,
+                compareFunctionWithFnSelection: function (a, b) { return this.compare(a.compareValue, b.compareValue) }.bind(this),
+                compareFunction: function (a, b) { return this.compare(a, b) }.bind(this)
+            })
+        },
+        sortDescending: function (list, fnSelection) {
+            return this.sortInternal({
+                list,
+                fnSelection,
+                compareFunctionWithFnSelection: function (a, b) { return this.compare(b.compareValue, a.compareValue); }.bind(this),
+                compareFunction: function (a, b) { return this.compare(b, a); }.bind(this)
+            })
+        },
+        sum: function (list, fnSelection) {
+            if (list === null) return null;
+            let sum = 0;
+            if (fnSelection) {
+                for (let i = 0; i < list.length; ++i) {
+                    const item = list[i];
+                    const value = fnSelection(item);
+                    if (value !== null)
+                        sum += value;
+                }
             }
-        }
-        else {
-            for( let i = 0; i < list.length; ++i ) {
-                const value = list[ i ];
-                if( value !== null )
-                    sum += value;
+            else {
+                for (let i = 0; i < list.length; ++i) {
+                    const value = list[i];
+                    if (value !== null)
+                        sum += value;
+                }
             }
-        }
-        return sum;
-    },
-    take: function( list, count ) {
-        if( list === null ) return null
-        return list.slice( 0, count )
-    },
-    takeWhile: function( list, fnCondition ) {
-        if( list === null ) return null;
-
-        let i;
-        for( i = 0; i < list.length; ++i ) {
-            if( !fnCondition( list[ i ] ) ) {
-                break
+            return sum;
+        },
+        take: function (list, count) {
+            if (list === null) return null
+            return list.slice(0, count)
+        },
+        takeWhile: function (list, fnCondition) {
+            if (list === null) return null;
+
+            let i;
+            for (i = 0; i < list.length; ++i) {
+                if (!fnCondition(list[i])) {
+                    break
+                }
+            }
+            return list.slice(0, i);
+        },
+        union: function (listA, listB, fnSelection) {
+            if (listA === null && listB === null) return null
+            if (listA === null) return listB.slice()
+            if (listB === null) return listA.slice()
+
+            if (!fnSelection) {
+                return [...new Set(listA.concat(listB))]
             }
-        }
-        return list.slice( 0, i );
-    },
-    union: function( listA, listB, fnSelection ) {
-        if( listA === null && listB === null ) return null
-        if( listA === null ) return listB.slice()
-        if( listB === null ) return listA.slice()
-
-        if( !fnSelection ) {
-            return [ ...new Set( listA.concat( listB ) ) ]
-        }
 
-        const resultArray = []
-        const keys = []
+            const resultArray = []
+            const keys = []
 
-        for( let i = 0; i < listA.length; ++i ) {
-            const item = listA[ i ]
-            const key = fnSelection( item )
-            if( keys.indexOf( key ) === -1 ) {
-                keys.push( key )
-                resultArray.push( item )
+            for (let i = 0; i < listA.length; ++i) {
+                const item = listA[i]
+                const key = fnSelection(item)
+                if (keys.indexOf(key) === -1) {
+                    keys.push(key)
+                    resultArray.push(item)
+                }
             }
-        }
 
-        for( let i = 0; i < listB.length; ++i ) {
-            const item = listB[ i ]
-            const key = fnSelection( item )
-            if( keys.indexOf( key ) === -1 ) {
-                keys.push( key )
-                resultArray.push( item )
+            for (let i = 0; i < listB.length; ++i) {
+                const item = listB[i]
+                const key = fnSelection(item)
+                if (keys.indexOf(key) === -1) {
+                    keys.push(key)
+                    resultArray.push(item)
+                }
             }
-        }
 
-        return resultArray;
+            return resultArray;
+        }
     }
 };