sequency/lib-umd/sequency.js

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define("Sequency", [], factory);
	else if(typeof exports === 'object')
		exports["Sequency"] = factory();
	else
		root["Sequency"] = factory();
})(window, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var all_1 = __webpack_require__(1);
var any_1 = __webpack_require__(2);
var asIterable_1 = __webpack_require__(3);
var associate_1 = __webpack_require__(4);
var associateBy_1 = __webpack_require__(5);
var average_1 = __webpack_require__(6);
var chunk_1 = __webpack_require__(7);
var contains_1 = __webpack_require__(8);
var count_1 = __webpack_require__(9);
var distinct_1 = __webpack_require__(10);
var distinctBy_1 = __webpack_require__(11);
var drop_1 = __webpack_require__(12);
var dropWhile_1 = __webpack_require__(13);
var elementAt_1 = __webpack_require__(14);
var elementAtOrElse_1 = __webpack_require__(15);
var elementAtOrNull_1 = __webpack_require__(16);
var filter_1 = __webpack_require__(17);
var filterIndexed_1 = __webpack_require__(18);
var filterNot_1 = __webpack_require__(19);
var filterNotNull_1 = __webpack_require__(20);
var first_1 = __webpack_require__(21);
var firstOrNull_1 = __webpack_require__(22);
var flatMap_1 = __webpack_require__(23);
var flatten_1 = __webpack_require__(24);
var fold_1 = __webpack_require__(25);
var foldIndexed_1 = __webpack_require__(26);
var forEach_1 = __webpack_require__(27);
var forEachIndexed_1 = __webpack_require__(28);
var groupBy_1 = __webpack_require__(29);
var indexOf_1 = __webpack_require__(30);
var indexOfFirst_1 = __webpack_require__(31);
var indexOfLast_1 = __webpack_require__(32);
var joinToString_1 = __webpack_require__(33);
var last_1 = __webpack_require__(34);
var lastOrNull_1 = __webpack_require__(35);
var map_1 = __webpack_require__(36);
var mapIndexed_1 = __webpack_require__(37);
var mapNotNull_1 = __webpack_require__(38);
var max_1 = __webpack_require__(39);
var maxBy_1 = __webpack_require__(40);
var maxWith_1 = __webpack_require__(41);
var merge_1 = __webpack_require__(42);
var min_1 = __webpack_require__(43);
var minBy_1 = __webpack_require__(44);
var minus_1 = __webpack_require__(45);
var minWith_1 = __webpack_require__(46);
var none_1 = __webpack_require__(47);
var onEach_1 = __webpack_require__(48);
var partition_1 = __webpack_require__(49);
var plus_1 = __webpack_require__(50);
var reduce_1 = __webpack_require__(51);
var reduceIndexed_1 = __webpack_require__(52);
var reverse_1 = __webpack_require__(53);
var single_1 = __webpack_require__(54);
var singleOrNull_1 = __webpack_require__(55);
var sorted_1 = __webpack_require__(56);
var sortedBy_1 = __webpack_require__(58);
var sortedByDescending_1 = __webpack_require__(59);
var sortedDescending_1 = __webpack_require__(60);
var sortedWith_1 = __webpack_require__(61);
var sum_1 = __webpack_require__(62);
var sumBy_1 = __webpack_require__(63);
var take_1 = __webpack_require__(64);
var takeWhile_1 = __webpack_require__(65);
var toArray_1 = __webpack_require__(66);
var toMap_1 = __webpack_require__(67);
var toSet_1 = __webpack_require__(68);
var unzip_1 = __webpack_require__(69);
var withIndex_1 = __webpack_require__(70);
var zip_1 = __webpack_require__(71);
var GeneratorIterator_1 = __webpack_require__(72);
var GeneratorSeedIterator_1 = __webpack_require__(73);
var SequenceImpl = /** @class */ (function () {
    function SequenceImpl(iterator) {
        this.iterator = iterator;
    }
    return SequenceImpl;
}());
applyMixins(SequenceImpl, [all_1.All, any_1.Any, asIterable_1.AsIterable, associate_1.Associate, associateBy_1.AssociateBy, average_1.Average, chunk_1.Chunk, contains_1.Contains, count_1.Count, distinct_1.Distinct, distinctBy_1.DistinctBy, drop_1.Drop,
    dropWhile_1.DropWhile, elementAt_1.ElementAt, elementAtOrElse_1.ElementAtOrElse, elementAtOrNull_1.ElementAtOrNull, filter_1.Filter, filterIndexed_1.FilterIndexed, filterNot_1.FilterNot, filterNotNull_1.FilterNotNull, first_1.First, firstOrNull_1.FirstOrNull, flatMap_1.FlatMap, flatten_1.Flatten, fold_1.Fold, foldIndexed_1.FoldIndexed,
    forEach_1.ForEach, forEachIndexed_1.ForEachIndexed, groupBy_1.GroupBy, indexOf_1.IndexOf, indexOfFirst_1.IndexOfFirst, indexOfLast_1.IndexOfLast, joinToString_1.JoinToString, last_1.Last, lastOrNull_1.LastOrNull, map_1.Map, mapIndexed_1.MapIndexed, mapNotNull_1.MapNotNull, max_1.Max, maxBy_1.MaxBy, maxWith_1.MaxWith, merge_1.Merge, min_1.Min, minBy_1.MinBy,
    minus_1.Minus, minWith_1.MinWith, none_1.None, onEach_1.OnEach, partition_1.Partition, plus_1.Plus, reduce_1.Reduce, reduceIndexed_1.ReduceIndexed, reverse_1.Reverse, single_1.Single, singleOrNull_1.SingleOrNull, sorted_1.Sorted, sortedBy_1.SortedBy, sortedByDescending_1.SortedByDescending, sortedDescending_1.SortedDescending, sortedWith_1.SortedWith,
    sum_1.Sum, sumBy_1.SumBy, take_1.Take, takeWhile_1.TakeWhile, toArray_1.ToArray, toMap_1.ToMap, toSet_1.ToSet, unzip_1.Unzip, withIndex_1.WithIndex, zip_1.Zip]);
function applyMixins(derivedCtor, baseCtors) {
    baseCtors.forEach(function (baseCtor) {
        Object.getOwnPropertyNames(baseCtor.prototype).forEach(function (name) {
            derivedCtor.prototype[name] = baseCtor.prototype[name];
        });
    });
}
function sequenceOf() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
    }
    return asSequence(args);
}
exports.sequenceOf = sequenceOf;
function emptySequence() {
    return asSequence([]);
}
exports.emptySequence = emptySequence;
function asSequence(iterable) {
    if (iterable === null) {
        throw new Error("Cannot create sequence for input: null");
    }
    if (iterable === undefined) {
        throw new Error("Cannot create sequence for input: undefined");
    }
    if (iterable[Symbol.iterator] == null) {
        throw new Error("Cannot create sequence for non-iterable input: " + iterable);
    }
    var iterator = iterable[Symbol.iterator]();
    return createSequence(iterator);
}
exports.asSequence = asSequence;
function createSequence(iterator) {
    return new SequenceImpl(iterator);
}
exports.createSequence = createSequence;
function isSequence(object) {
    return object instanceof SequenceImpl;
}
exports.isSequence = isSequence;
function extendSequence(mixin) {
    applyMixins(SequenceImpl, [mixin]);
}
exports.extendSequence = extendSequence;
function generateSequence(a, b) {
    if (typeof a === "function" && b == null) {
        return createSequence(new GeneratorIterator_1.default(a));
    }
    var seed = typeof a === "function" ? a() : a;
    return seed != null
        ? createSequence(new GeneratorSeedIterator_1.default(seed, b))
        : emptySequence();
}
exports.generateSequence = generateSequence;
function range(start, endInclusive, step) {
    if (step === void 0) { step = 1; }
    if (start > endInclusive) {
        throw new Error("start [" + start + "] must be lower then endInclusive [" + endInclusive + "]");
    }
    if (start === endInclusive) {
        return emptySequence();
    }
    var current = start;
    return generateSequence(function () {
        try {
            return current <= endInclusive
                ? current
                : undefined;
        }
        finally {
            current += step;
        }
    });
}
exports.range = range;


/***/ }),
/* 1 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var All = /** @class */ (function () {
    function All() {
    }
    /**
     * Returns `true` if all elements match the given `predicate`.
     *
     * @param {(T) => boolean} predicate
     * @returns {boolean}
     */
    All.prototype.all = function (predicate) {
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (!predicate(item.value)) {
                return false;
            }
        }
        return true;
    };
    return All;
}());
exports.All = All;


/***/ }),
/* 2 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Any = /** @class */ (function () {
    function Any() {
    }
    /**
     * Returns `true` if at least one element match the given `predicate`.
     *
     * @param {(T) => boolean} predicate
     * @returns {boolean}
     */
    Any.prototype.any = function (predicate) {
        if (predicate == null) {
            return !this.iterator.next().done;
        }
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (predicate(item.value)) {
                return true;
            }
        }
        return false;
    };
    return Any;
}());
exports.Any = Any;


/***/ }),
/* 3 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var AsIterable = /** @class */ (function () {
    function AsIterable() {
    }
    /**
     * Returns an iterable representation of the sequence.
     *
     * @returns {Iterable<T>}
     */
    AsIterable.prototype.asIterable = function () {
        var _a;
        var iterator = this.iterator;
        return _a = {},
            _a[Symbol.iterator] = function () {
                return iterator;
            },
            _a;
    };
    return AsIterable;
}());
exports.AsIterable = AsIterable;


/***/ }),
/* 4 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Associate = /** @class */ (function () {
    function Associate() {
    }
    /**
     * Transforms each element into a key-value pair and returns the results as map. In case of
     * duplicate keys the last key-value pair overrides the other.
     *
     * @param {(value: T) => [K , V]} transform
     * @returns {Map<K, V>}
     */
    Associate.prototype.associate = function (transform) {
        var result = new Map();
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            var pair = transform(item.value);
            result.set(pair[0], pair[1]);
        }
        return result;
    };
    return Associate;
}());
exports.Associate = Associate;


/***/ }),
/* 5 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var AssociateBy = /** @class */ (function () {
    function AssociateBy() {
    }
    AssociateBy.prototype.associateBy = function (keyOrSelector, valueTransform) {
        var selector = typeof keyOrSelector === "function"
            ? keyOrSelector
            : function (value) { return value[keyOrSelector]; };
        var result = new Map();
        var transform = valueTransform != null
            ? valueTransform
            : function (value) { return value; };
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            var key = selector(item.value);
            var value = transform(item.value);
            result.set(key, value);
        }
        return result;
    };
    return AssociateBy;
}());
exports.AssociateBy = AssociateBy;


/***/ }),
/* 6 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Average = /** @class */ (function () {
    function Average() {
    }
    /**
     * Returns the average of all numbers of the sequence or `NaN` if the sequence is empty.
     *
     * @returns {number}
     */
    Average.prototype.average = function () {
        var sum = 0;
        var count = 0;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            sum += item.value;
            count++;
        }
        return count === 0
            ? Number.NaN
            : sum / count;
    };
    return Average;
}());
exports.Average = Average;


/***/ }),
/* 7 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Chunk = /** @class */ (function () {
    function Chunk() {
    }
    /**
     * Splits the elements of the sequence into arrays which length is determined by
     * the given `chunkSize` and returns all chunks as array.
     *
     * @param {number} chunkSize
     * @returns {Array<Array<T>>}
     */
    Chunk.prototype.chunk = function (chunkSize) {
        if (chunkSize < 1) {
            throw new Error("chunkSize must be > 0 but is " + chunkSize);
        }
        var result = [];
        var index = 0;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            var chunkIndex = Math.floor(index / chunkSize);
            if (result[chunkIndex] == null) {
                result[chunkIndex] = [item.value];
            }
            else {
                result[chunkIndex].push(item.value);
            }
            index++;
        }
        return result;
    };
    return Chunk;
}());
exports.Chunk = Chunk;


/***/ }),
/* 8 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Contains = /** @class */ (function () {
    function Contains() {
    }
    /**
     * Returns `true` if the sequence contains the given `element`.
     *
     * @param {T} element
     * @returns {boolean}
     */
    Contains.prototype.contains = function (element) {
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (element === item.value) {
                return true;
            }
        }
        return false;
    };
    return Contains;
}());
exports.Contains = Contains;


/***/ }),
/* 9 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Count = /** @class */ (function () {
    function Count() {
    }
    /**
     * Returns the number of elements of this sequence. If `predicate` is present, returns
     * the number of elements matching the given `predicate`.
     *
     * @param {(T) => boolean} predicate
     * @returns {number}
     */
    Count.prototype.count = function (predicate) {
        var num = 0;
        if (predicate == null) {
            for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
                num++;
            }
        }
        else {
            for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
                if (predicate(item.value)) {
                    num++;
                }
            }
        }
        return num;
    };
    return Count;
}());
exports.Count = Count;


/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var DistinctIterator = /** @class */ (function () {
    function DistinctIterator(iterator) {
        this.iterator = iterator;
        this.items = [];
    }
    DistinctIterator.prototype.next = function (value) {
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (this.items.indexOf(item.value) < 0) {
                this.items.push(item.value);
                return { done: false, value: item.value };
            }
        }
        return { done: true, value: undefined };
    };
    return DistinctIterator;
}());
var Distinct = /** @class */ (function () {
    function Distinct() {
    }
    /**
     * Returns a new sequence which discards all duplicate elements.
     *
     * @returns {Sequence<T>}
     */
    Distinct.prototype.distinct = function () {
        return Sequence_1.createSequence(new DistinctIterator(this.iterator));
    };
    return Distinct;
}());
exports.Distinct = Distinct;


/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var DistinctByIterator = /** @class */ (function () {
    function DistinctByIterator(iterator, selector) {
        this.iterator = iterator;
        this.selector = selector;
        this.keys = [];
    }
    DistinctByIterator.prototype.next = function (value) {
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            var key = this.selector(item.value);
            if (this.keys.indexOf(key) < 0) {
                this.keys.push(key);
                return { done: false, value: item.value };
            }
        }
        return { done: true, value: undefined };
    };
    return DistinctByIterator;
}());
var DistinctBy = /** @class */ (function () {
    function DistinctBy() {
    }
    /**
     * Returns a new sequence which discards all elements with duplicate items determined
     * by the given `selector`.
     *
     * @param {(item: T) => K} selector
     * @returns {Sequence<T>}
     */
    DistinctBy.prototype.distinctBy = function (selector) {
        return Sequence_1.createSequence(new DistinctByIterator(this.iterator, selector));
    };
    return DistinctBy;
}());
exports.DistinctBy = DistinctBy;


/***/ }),
/* 12 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Drop = /** @class */ (function () {
    function Drop() {
    }
    /**
     * Returns a new sequence which discards the first `n` elements;
     *
     * @param {number} n
     * @returns {Sequence<T>}
     */
    Drop.prototype.drop = function (n) {
        return this.withIndex()
            .dropWhile(function (it) { return it.index < n; })
            .map(function (it) { return it.value; });
    };
    return Drop;
}());
exports.Drop = Drop;


/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var DropWhileIterator = /** @class */ (function () {
    function DropWhileIterator(iterator, predicate) {
        this.iterator = iterator;
        this.predicate = predicate;
        this.dropping = true;
    }
    DropWhileIterator.prototype.next = function (value) {
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (!this.dropping) {
                return { done: false, value: item.value };
            }
            var result = this.predicate(item.value);
            if (!result) {
                this.dropping = false;
                return { done: false, value: item.value };
            }
        }
        return { done: true, value: undefined };
    };
    return DropWhileIterator;
}());
var DropWhile = /** @class */ (function () {
    function DropWhile() {
    }
    /**
     * Drops all elements of the sequence as long as the given `predicate` evaluates to true.
     *
     * @param {(item: T) => boolean} predicate
     * @returns {Sequence<T>}
     */
    DropWhile.prototype.dropWhile = function (predicate) {
        return Sequence_1.createSequence(new DropWhileIterator(this.iterator, predicate));
    };
    return DropWhile;
}());
exports.DropWhile = DropWhile;


/***/ }),
/* 14 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var ElementAt = /** @class */ (function () {
    function ElementAt() {
    }
    /**
     * Returns the element at position `index` (zero-based) or throws an error if `index`
     * is out of bounds.
     *
     * @param {number} index
     * @returns {T}
     */
    ElementAt.prototype.elementAt = function (index) {
        var i = 0;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (i === index) {
                return item.value;
            }
            i++;
        }
        throw new Error("Index out of bounds: " + index);
    };
    return ElementAt;
}());
exports.ElementAt = ElementAt;


/***/ }),
/* 15 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var ElementAtOrElse = /** @class */ (function () {
    function ElementAtOrElse() {
    }
    /**
     * Returns the element at position `index` (zero-based). If `index` is out of bounds returns
     * the result of the given `defaultValue` function.
     *
     * @param {number} index
     * @param defaultValue
     * @returns {T}
     */
    ElementAtOrElse.prototype.elementAtOrElse = function (index, defaultValue) {
        var i = 0;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (i === index) {
                return item.value;
            }
            i++;
        }
        return defaultValue(index);
    };
    return ElementAtOrElse;
}());
exports.ElementAtOrElse = ElementAtOrElse;


/***/ }),
/* 16 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var ElementAtOrNull = /** @class */ (function () {
    function ElementAtOrNull() {
    }
    /**
     * Returns the element at position `index` (zero-based) or `null` if `index`
     * is out of bounds.
     *
     * @param {number} index
     * @returns {T}
     */
    ElementAtOrNull.prototype.elementAtOrNull = function (index) {
        var i = 0;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (i === index) {
                return item.value;
            }
            i++;
        }
        return null;
    };
    return ElementAtOrNull;
}());
exports.ElementAtOrNull = ElementAtOrNull;


/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var FilterIterator = /** @class */ (function () {
    function FilterIterator(predicate, iterator) {
        this.predicate = predicate;
        this.iterator = iterator;
    }
    FilterIterator.prototype.next = function (value) {
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (this.predicate(item.value)) {
                return { done: false, value: item.value };
            }
        }
        return { done: true, value: undefined };
    };
    return FilterIterator;
}());
var Filter = /** @class */ (function () {
    function Filter() {
    }
    /**
     * Returns a new sequence consisting of all elements that match the given `predicate`.
     *
     * @param {(T) => boolean} predicate
     * @returns {Sequence<T>}
     */
    Filter.prototype.filter = function (predicate) {
        return Sequence_1.createSequence(new FilterIterator(predicate, this.iterator));
    };
    return Filter;
}());
exports.Filter = Filter;


/***/ }),
/* 18 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var FilterIndexed = /** @class */ (function () {
    function FilterIndexed() {
    }
    /**
     * Returns a new sequence consisting of all elements that match the given `predicate`.
     *
     * @param {(index: number, value: T) => boolean} predicate
     * @returns {Sequence<T>}
     */
    FilterIndexed.prototype.filterIndexed = function (predicate) {
        return this.withIndex()
            .filter(function (it) { return predicate(it.index, it.value); })
            .map(function (it) { return it.value; });
    };
    return FilterIndexed;
}());
exports.FilterIndexed = FilterIndexed;


/***/ }),
/* 19 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var FilterNot = /** @class */ (function () {
    function FilterNot() {
    }
    /**
     * Returns a new sequence consisting of all elements that don't match the given `predicate`.
     *
     * @param {(value: T) => boolean} predicate
     * @returns {Sequence<T>}
     */
    FilterNot.prototype.filterNot = function (predicate) {
        return this.filter(function (value) { return !predicate(value); });
    };
    return FilterNot;
}());
exports.FilterNot = FilterNot;


/***/ }),
/* 20 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var FilterNotNull = /** @class */ (function () {
    function FilterNotNull() {
    }
    /**
     * Returns a new sequence consisting of all non-null elements.
     *
     * @returns {Sequence<T>}
     */
    FilterNotNull.prototype.filterNotNull = function () {
        return this.filter(function (it) { return it !== null; });
    };
    return FilterNotNull;
}());
exports.FilterNotNull = FilterNotNull;


/***/ }),
/* 21 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var First = /** @class */ (function () {
    function First() {
    }
    /**
     * Returns the first element of the sequence or the first element matching `predicate` if present, otherwise throws
     * an error.
     *
     * @param {(T) => boolean} predicate
     * @returns {T}
     */
    First.prototype.first = function (predicate) {
        if (predicate != null) {
            return this.filter(predicate).first();
        }
        var item = this.iterator.next();
        if (item.done) {
            throw new Error("No such element");
        }
        return item.value;
    };
    return First;
}());
exports.First = First;


/***/ }),
/* 22 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var FirstOrNull = /** @class */ (function () {
    function FirstOrNull() {
    }
    /**
     * Returns the first element of the sequence or the first element matching `predicate` if present, otherwise returns `null`.
     *
     * @param {(T) => boolean} predicate
     * @returns {T}
     */
    FirstOrNull.prototype.firstOrNull = function (predicate) {
        if (predicate != null) {
            return this.filter(predicate).firstOrNull();
        }
        var item = this.iterator.next();
        return item.done
            ? null
            : item.value;
    };
    /**
     * Returns the first element of the sequence or the first element matching `predicate` if present, otherwise returns `null`.
     *
     * @param {(T) => boolean} predicate
     * @returns {T}
     */
    FirstOrNull.prototype.find = function (predicate) {
        return this.firstOrNull(predicate);
    };
    return FirstOrNull;
}());
exports.FirstOrNull = FirstOrNull;


/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var FlatMapIterator = /** @class */ (function () {
    function FlatMapIterator(transform, iterator) {
        this.transform = transform;
        this.iterator = iterator;
    }
    FlatMapIterator.prototype.next = function (value) {
        if (this.current != null) {
            var item = this.current.next();
            if (!item.done) {
                return item;
            }
        }
        var next = this.iterator.next();
        if (!next.done) {
            var sequence = this.transform(next.value);
            this.current = sequence.iterator;
            return this.next();
        }
        return { done: true, value: undefined };
    };
    return FlatMapIterator;
}());
var FlatMap = /** @class */ (function () {
    function FlatMap() {
    }
    /**
     * Transforms each element into a sequence of items and returns a flat single sequence of all those items.
     *
     * @param {(value: S) => Sequence<T>} transform
     * @returns {Sequence<T>}
     */
    FlatMap.prototype.flatMap = function (transform) {
        return Sequence_1.createSequence(new FlatMapIterator(transform, this.iterator));
    };
    return FlatMap;
}());
exports.FlatMap = FlatMap;


/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var Flatten = /** @class */ (function () {
    function Flatten() {
    }
    /**
     * Returns a single flat sequence of all the items from all sequences or iterables.
     *
     * @returns {Sequence<T>}
     */
    Flatten.prototype.flatten = function () {
        return this.flatMap(function (it) {
            if (Sequence_1.isSequence(it)) {
                return it;
            }
            else {
                return Sequence_1.asSequence(it);
            }
        });
    };
    return Flatten;
}());
exports.Flatten = Flatten;


/***/ }),
/* 25 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Fold = /** @class */ (function () {
    function Fold() {
    }
    /**
     * Accumulates all elements of the sequence into a single result by applying the given `operation` starting with
     * the `initial` value. The result of the last operation will be passed as accumulated value to the getNext invocation
     * of the operation until all elements of the sequence are processed.
     *
     * @param {R} initial
     * @param {(acc: R, element: T) => R} operation
     * @returns {R}
     */
    Fold.prototype.fold = function (initial, operation) {
        var result = initial;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            result = operation(result, item.value);
        }
        return result;
    };
    return Fold;
}());
exports.Fold = Fold;


/***/ }),
/* 26 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var FoldIndexed = /** @class */ (function () {
    function FoldIndexed() {
    }
    /**
     * Accumulates all elements of the sequence into a single result by applying the given `operation` starting with
     * the `initial` value. The result of the last operation will be passed as accumulated value to the getNext invocation
     * of the operation as well as the `index` of the current element (zero-based) until all elements of the sequence
     * are processed.
     *
     * @param {R} initial
     * @param {(index: number, acc: R, element: T) => R} operation
     * @returns {R}
     */
    FoldIndexed.prototype.foldIndexed = function (initial, operation) {
        var result = initial;
        var index = 0;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            result = operation(index, result, item.value);
            index++;
        }
        return result;
    };
    return FoldIndexed;
}());
exports.FoldIndexed = FoldIndexed;


/***/ }),
/* 27 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var ForEach = /** @class */ (function () {
    function ForEach() {
    }
    /**
     * Performs the given `action` (side-effect) for each element of the sequence.
     *
     * @param {(T) => void} action
     */
    ForEach.prototype.forEach = function (action) {
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            action(item.value);
        }
    };
    return ForEach;
}());
exports.ForEach = ForEach;


/***/ }),
/* 28 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var ForEachIndexed = /** @class */ (function () {
    function ForEachIndexed() {
    }
    /**
     * Performs the given `action` (side-effect) for each element of the sequence and passes the `index` of the current
     * element (zero-based).
     *
     * @param {(index: number, value: T) => void} action
     */
    ForEachIndexed.prototype.forEachIndexed = function (action) {
        this.withIndex()
            .forEach(function (it) { return action(it.index, it.value); });
    };
    return ForEachIndexed;
}());
exports.ForEachIndexed = ForEachIndexed;


/***/ }),
/* 29 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var GroupBy = /** @class */ (function () {
    function GroupBy() {
    }
    /**
     * Groups all elements of the sequence into a map. Keys are determined by the given `keySelector` function.
     *
     * @param {(value: T) => K} keySelector
     * @returns {Map<K, Array<T>>}
     */
    GroupBy.prototype.groupBy = function (keySelector) {
        var result = new Map();
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            var key = keySelector(item.value);
            var array = result.get(key);
            if (array == null) {
                result.set(key, [item.value]);
            }
            else {
                array.push(item.value);
            }
        }
        return result;
    };
    return GroupBy;
}());
exports.GroupBy = GroupBy;


/***/ }),
/* 30 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var IndexOf = /** @class */ (function () {
    function IndexOf() {
    }
    /**
     * Returns the zero-based index of the given `element` or -1 if the sequence does not contain the element.
     *
     * @param {T} element
     * @returns {number}
     */
    IndexOf.prototype.indexOf = function (element) {
        var index = 0;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (element === item.value) {
                return index;
            }
            index++;
        }
        return -1;
    };
    return IndexOf;
}());
exports.IndexOf = IndexOf;


/***/ }),
/* 31 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var IndexOfFirst = /** @class */ (function () {
    function IndexOfFirst() {
    }
    /**
     * Returns the zero-based index of the first element matching the given `predicate` or -1 if no element matches
     * the predicate.
     *
     * @param {(value: T) => boolean} predicate
     * @returns {number}
     */
    IndexOfFirst.prototype.indexOfFirst = function (predicate) {
        var index = 0;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (predicate(item.value)) {
                return index;
            }
            index++;
        }
        return -1;
    };
    return IndexOfFirst;
}());
exports.IndexOfFirst = IndexOfFirst;


/***/ }),
/* 32 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var IndexOfLast = /** @class */ (function () {
    function IndexOfLast() {
    }
    /**
     * Returns the zero-based index of the last element matching the given `predicate` or -1 if no element matches
     * the predicate.
     *
     * @param {(value: T) => boolean} predicate
     * @returns {number}
     */
    IndexOfLast.prototype.indexOfLast = function (predicate) {
        var index = 0;
        var result = -1;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (predicate(item.value)) {
                result = index;
            }
            index++;
        }
        return result;
    };
    return IndexOfLast;
}());
exports.IndexOfLast = IndexOfLast;


/***/ }),
/* 33 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var defaults = {
    value: "",
    separator: ", ",
    prefix: "",
    postfix: "",
    limit: -1,
    truncated: "...",
    transform: undefined
};
var JoinToString = /** @class */ (function () {
    function JoinToString() {
    }
    /**
     * Joins all elements of the sequence into a string with the given configuration.
     *
     * @param {JoinConfig<T>} config
     * @returns {string}
     */
    JoinToString.prototype.joinToString = function (config) {
        if (config === void 0) { config = defaults; }
        var _a = config.value, value = _a === void 0 ? defaults.value : _a, _b = config.separator, separator = _b === void 0 ? defaults.separator : _b, _c = config.prefix, prefix = _c === void 0 ? defaults.prefix : _c, _d = config.postfix, postfix = _d === void 0 ? defaults.postfix : _d, _e = config.limit, limit = _e === void 0 ? defaults.limit : _e, _f = config.truncated, truncated = _f === void 0 ? defaults.truncated : _f, _g = config.transform, transform = _g === void 0 ? defaults.transform : _g;
        var result = "" + value + prefix;
        var count = 0;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            count++;
            if (count > 1) {
                result += separator;
            }
            if (limit < 0 || count <= limit) {
                result += transform != null
                    ? transform(item.value)
                    : String(item.value);
            }
            else {
                break;
            }
        }
        if (limit >= 0 && count > limit) {
            result += truncated;
        }
        result += postfix;
        return result;
    };
    /**
     * Joins all elements of the sequence into a string with the given configuration.
     *
     * @param {JoinConfig<T>} config
     * @returns {string}
     */
    JoinToString.prototype.joinTo = function (config) {
        if (config === void 0) { config = defaults; }
        return this.joinToString(config);
    };
    return JoinToString;
}());
exports.JoinToString = JoinToString;


/***/ }),
/* 34 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Last = /** @class */ (function () {
    function Last() {
    }
    /**
     * Returns the last element of the sequence or the last element matching `predicate` if present, otherwise throws
     * an error.
     *
     * @param {(value: T) => boolean} predicate
     * @returns {T}
     */
    Last.prototype.last = function (predicate) {
        if (predicate != null) {
            return this.filter(predicate).last();
        }
        var result;
        var empty = true;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            result = item.value;
            empty = false;
        }
        if (empty) {
            throw new Error("No such element");
        }
        return result;
    };
    return Last;
}());
exports.Last = Last;


/***/ }),
/* 35 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var LastOrNull = /** @class */ (function () {
    function LastOrNull() {
    }
    /**
     * Returns the last element of the sequence or the last element matching `predicate` if present, otherwise returns `null`.
     *
     * @param {(value: T) => boolean} predicate
     * @returns {T}
     */
    LastOrNull.prototype.lastOrNull = function (predicate) {
        if (predicate != null) {
            return this.filter(predicate).lastOrNull();
        }
        var result = null;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            result = item.value;
        }
        return result;
    };
    /**
     * Returns the last element of the sequence or the last element matching `predicate` if present, otherwise returns `null`.
     *
     * @param {(value: T) => boolean} predicate
     * @returns {T}
     */
    LastOrNull.prototype.findLast = function (predicate) {
        return this.lastOrNull(predicate);
    };
    return LastOrNull;
}());
exports.LastOrNull = LastOrNull;


/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var MapIterator = /** @class */ (function () {
    function MapIterator(transform, iterator) {
        this.transform = transform;
        this.iterator = iterator;
    }
    MapIterator.prototype.next = function (value) {
        var item = this.iterator.next();
        return item.done
            ? { done: true, value: undefined }
            : { done: false, value: this.transform(item.value) };
    };
    return MapIterator;
}());
var Map = /** @class */ (function () {
    function Map() {
    }
    /**
     * Transforms each element into another value by applying the given `transform` function and returns a new sequence.
     *
     * @param {(T) => S} transform
     * @returns {Sequence<S>}
     */
    Map.prototype.map = function (transform) {
        return Sequence_1.createSequence(new MapIterator(transform, this.iterator));
    };
    return Map;
}());
exports.Map = Map;


/***/ }),
/* 37 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var MapIndexed = /** @class */ (function () {
    function MapIndexed() {
    }
    /**
     * Transforms each element into another value by applying the given `transform` function and returns a new sequence.
     *
     * @param {(index: number, value: T) => R} transform
     * @returns {Sequence<R>}
     */
    MapIndexed.prototype.mapIndexed = function (transform) {
        return this.withIndex()
            .map(function (it) { return transform(it.index, it.value); });
    };
    return MapIndexed;
}());
exports.MapIndexed = MapIndexed;


/***/ }),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var MapNotNull = /** @class */ (function () {
    function MapNotNull() {
    }
    /**
     * Transforms each element into another value by applying the given `transform` function and returns a new sequence.
     * Transformations into `null` values are discarded.
     *
     * @param {(value: T) => R} transform
     * @returns {Sequence<R>}
     */
    MapNotNull.prototype.mapNotNull = function (transform) {
        return this.flatMap(function (value) {
            var item = transform(value);
            return item !== null
                ? Sequence_1.sequenceOf(item)
                : Sequence_1.emptySequence();
        });
    };
    return MapNotNull;
}());
exports.MapNotNull = MapNotNull;


/***/ }),
/* 39 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Max = /** @class */ (function () {
    function Max() {
    }
    /**
     * Returns the maximum element of the sequence or `null` if sequence is empty.
     *
     * @returns {T}
     */
    Max.prototype.max = function () {
        var result = null;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (result == null || item.value > result) {
                result = item.value;
            }
        }
        return result;
    };
    return Max;
}());
exports.Max = Max;


/***/ }),
/* 40 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var MaxBy = /** @class */ (function () {
    function MaxBy() {
    }
    /**
     * Returns the maximum element by comparing the results of the given `selector` function
     * for each element of the sequence or `null` if the sequence is empty.
     *
     * @param {(value: T) => R} selector
     * @returns {T}
     */
    MaxBy.prototype.maxBy = function (selector) {
        var max = null;
        var maxSelected = null;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            var value = selector(item.value);
            if (maxSelected == null || value > maxSelected) {
                maxSelected = value;
                max = item.value;
            }
        }
        return max;
    };
    return MaxBy;
}());
exports.MaxBy = MaxBy;


/***/ }),
/* 41 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var MaxWith = /** @class */ (function () {
    function MaxWith() {
    }
    /**
     * Returns the maximum element of the sequence by evaluating the given `compare`
     * function or `null` if sequence is empty.
     *
     * @returns {T}
     */
    MaxWith.prototype.maxWith = function (compare) {
        var max = null;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (max == null || compare(item.value, max) > 0) {
                max = item.value;
            }
        }
        return max;
    };
    return MaxWith;
}());
exports.MaxWith = MaxWith;


/***/ }),
/* 42 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var Merge = /** @class */ (function () {
    function Merge() {
    }
    /**
     * Merges the elements of both sequences into a new sequence. Each element of this sequence is eventually replaced with
     * an element of the other sequence by comparing results of the given `selector` function. If no value is found in the other
     * sequence the element is retained. New elements of the other sequence are appended to the end of the new sequence or
     * prepended to the start of the new sequence, if `prependNewValues` is set to `true`. This operation is not lazy evaluated.
     *
     * @param {Sequence<T>} other
     * @param {(value: T) => S} selector
     * @param prependNewValues
     * @returns {Sequence<T>}
     */
    Merge.prototype.merge = function (other, selector, prependNewValues) {
        if (prependNewValues === void 0) { prependNewValues = false; }
        var mergeValues = Sequence_1.isSequence(other)
            ? other.toArray()
            : Sequence_1.asSequence(other).toArray();
        var leftValues = this.toArray();
        var result = leftValues.map(function (left) {
            var selected = selector(left);
            var right = Sequence_1.asSequence(mergeValues)
                .find(function (it) { return selector(it) === selected; });
            if (right != null) {
                mergeValues = mergeValues.filter(function (it) { return it !== right; });
                return right;
            }
            else {
                return left;
            }
        });
        if (prependNewValues) {
            return Sequence_1.asSequence(mergeValues.concat(result));
        }
        else {
            return Sequence_1.asSequence(result.concat(mergeValues));
        }
    };
    return Merge;
}());
exports.Merge = Merge;


/***/ }),
/* 43 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Min = /** @class */ (function () {
    function Min() {
    }
    /**
     * Returns the minimum element of the sequence or `null` if sequence is empty.
     *
     * @returns {T}
     */
    Min.prototype.min = function () {
        var result = null;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (result == null || item.value < result) {
                result = item.value;
            }
        }
        return result;
    };
    return Min;
}());
exports.Min = Min;


/***/ }),
/* 44 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var MinBy = /** @class */ (function () {
    function MinBy() {
    }
    /**
     * Returns the minimum element by comparing the results of the given `selector` function
     * for each element of the sequence or `null` if the sequence is empty.
     *
     * @param {(value: T) => R} selector
     * @returns {T}
     */
    MinBy.prototype.minBy = function (selector) {
        var min = null;
        var minSelected = null;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            var value = selector(item.value);
            if (minSelected == null || value < minSelected) {
                minSelected = value;
                min = item.value;
            }
        }
        return min;
    };
    return MinBy;
}());
exports.MinBy = MinBy;


/***/ }),
/* 45 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var Minus = /** @class */ (function () {
    function Minus() {
    }
    /**
     * Removes the given `data` and returns a new sequence. Data can either be a single element, an array of elements
     * or a sequence of elements.
     *
     * @param {Sequence<T> | Array<T> | T} data
     * @returns {Sequence<T>}
     */
    Minus.prototype.minus = function (data) {
        if (Sequence_1.isSequence(data)) {
            var array_1 = data.toArray();
            return this.filter(function (it) { return array_1.indexOf(it) < 0; });
        }
        else if (data instanceof Array) {
            return this.filter(function (it) { return data.indexOf(it) < 0; });
        }
        else {
            return this.filter(function (it) { return it !== data; });
        }
    };
    return Minus;
}());
exports.Minus = Minus;


/***/ }),
/* 46 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var MinWith = /** @class */ (function () {
    function MinWith() {
    }
    /**
     * Returns the minimum element of the sequence by evaluating the given `compare`
     * function or `null` if sequence is empty.
     *
     * @returns {T}
     */
    MinWith.prototype.minWith = function (compare) {
        var min = null;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (min == null || compare(item.value, min) < 0) {
                min = item.value;
            }
        }
        return min;
    };
    return MinWith;
}());
exports.MinWith = MinWith;


/***/ }),
/* 47 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var None = /** @class */ (function () {
    function None() {
    }
    /**
     * Returns `true` if no element match the given `predicate` or if the sequence is empty
     * if no predicate is present.
     *
     * @param {(value: T) => boolean} predicate
     * @returns {boolean}
     */
    None.prototype.none = function (predicate) {
        if (predicate == null) {
            return this.iterator.next().done;
        }
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (predicate(item.value)) {
                return false;
            }
        }
        return true;
    };
    return None;
}());
exports.None = None;


/***/ }),
/* 48 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var OnEach = /** @class */ (function () {
    function OnEach() {
    }
    /**
     * Performs the given `action` for each element and returns the sequence.
     *
     * @param {(value: T) => void} action
     * @returns {Sequence<T>}
     */
    OnEach.prototype.onEach = function (action) {
        return this.map(function (it) {
            action(it);
            return it;
        });
    };
    return OnEach;
}());
exports.OnEach = OnEach;


/***/ }),
/* 49 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Partition = /** @class */ (function () {
    function Partition() {
    }
    /**
     * Evaluates the given `predicate` for each element of the sequence and assorts each element into one of two lists
     * according to the result of the predicate. Returns both lists as an object.
     *
     * @param {(value: T) => boolean} predicate
     * @returns {{true: Array<T>; false: Array<T>}}
     */
    Partition.prototype.partition = function (predicate) {
        var arrayTrue = [];
        var arrayFalse = [];
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            if (predicate(item.value)) {
                arrayTrue.push(item.value);
            }
            else {
                arrayFalse.push(item.value);
            }
        }
        return { "true": arrayTrue, "false": arrayFalse };
    };
    return Partition;
}());
exports.Partition = Partition;


/***/ }),
/* 50 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var AppendIterator = /** @class */ (function () {
    function AppendIterator(first, second) {
        this.first = first;
        this.second = second;
    }
    AppendIterator.prototype.next = function (value) {
        var item1 = this.first.next();
        if (!item1.done) {
            return { done: false, value: item1.value };
        }
        var item2 = this.second.next();
        if (!item2.done) {
            return { done: false, value: item2.value };
        }
        return { done: true, value: undefined };
    };
    return AppendIterator;
}());
var Plus = /** @class */ (function () {
    function Plus() {
    }
    Plus.prototype.plus = function (data) {
        if (Sequence_1.isSequence(data)) {
            return Sequence_1.createSequence(new AppendIterator(this.iterator, data.iterator));
        }
        else if (data instanceof Array) {
            var iterator = data[Symbol.iterator]();
            return Sequence_1.createSequence(new AppendIterator(this.iterator, iterator));
        }
        else {
            var iterator = [data][Symbol.iterator]();
            return Sequence_1.createSequence(new AppendIterator(this.iterator, iterator));
        }
    };
    return Plus;
}());
exports.Plus = Plus;


/***/ }),
/* 51 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Reduce = /** @class */ (function () {
    function Reduce() {
    }
    /**
     * Reduces the whole sequence to a single value by invoking `operation` with each element
     * from left to right. For every invocation of the operation `acc` is the result of the last
     * invocation. For the first invocation of the operation `acc` is the first element of the
     * sequence.
     *
     * @param {(acc: S, value: T) => S} operation
     * @returns {S}
     */
    Reduce.prototype.reduce = function (operation) {
        var first = this.iterator.next();
        if (first.done) {
            throw new Error("Cannot reduce empty sequence");
        }
        var result = first.value;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            result = operation(result, item.value);
        }
        return result;
    };
    return Reduce;
}());
exports.Reduce = Reduce;


/***/ }),
/* 52 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var ReduceIndexed = /** @class */ (function () {
    function ReduceIndexed() {
    }
    /**
     * Reduces the whole sequence to a single value by invoking `operation` with each element
     * from left to right. For every invocation of the operation `acc` is the result of the last
     * invocation. For the first invocation of the operation `acc` is the first element of the
     * sequence. In addition the `index` of the current element is also passed to the operation.
     *
     * @param {(index: number, acc: S, element: T) => S} operation
     * @returns {S}
     */
    ReduceIndexed.prototype.reduceIndexed = function (operation) {
        var first = this.iterator.next();
        if (first.done) {
            throw new Error("Cannot reduce empty sequence");
        }
        var index = 1;
        var result = first.value;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            result = operation(index, result, item.value);
            index++;
        }
        return result;
    };
    return ReduceIndexed;
}());
exports.ReduceIndexed = ReduceIndexed;


/***/ }),
/* 53 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Reverse = /** @class */ (function () {
    function Reverse() {
    }
    /**
     * Returns a new sequence with all elements of the sequence in reverse order.
     *
     * @returns {Sequence<T>}
     */
    Reverse.prototype.reverse = function () {
        return this.withIndex()
            .sortedByDescending(function (it) { return it.index; })
            .map(function (it) { return it.value; });
    };
    return Reverse;
}());
exports.Reverse = Reverse;


/***/ }),
/* 54 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Single = /** @class */ (function () {
    function Single() {
    }
    /**
     * Returns the single element of the sequence or throws error if the sequence has more than
     * one element or none at all. If a `predicate` is passed returns the single element matching
     * the predicate or throws an error if more or less than one element match the predicate.
     *
     * @param {(value: T) => boolean} predicate
     * @returns {T}
     */
    Single.prototype.single = function (predicate) {
        if (predicate != null) {
            return this.filter(predicate).single();
        }
        var first = this.iterator.next();
        if (first.done) {
            throw new Error("No such element");
        }
        if (!this.iterator.next().done) {
            throw new Error("Expect single element");
        }
        return first.value;
    };
    return Single;
}());
exports.Single = Single;


/***/ }),
/* 55 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var SingleOrNull = /** @class */ (function () {
    function SingleOrNull() {
    }
    /**
     * Returns the single element of the sequence or `null` if the sequence has more than
     * one element or none at all. If a `predicate` is passed returns the single element matching
     * the predicate or `null` if more or less than one element match the predicate.
     *
     * @param {(value: T) => boolean} predicate
     * @returns {T}
     */
    SingleOrNull.prototype.singleOrNull = function (predicate) {
        if (predicate != null) {
            return this.filter(predicate).singleOrNull();
        }
        var first = this.iterator.next();
        if (first.done) {
            return null;
        }
        if (!this.iterator.next().done) {
            return null;
        }
        return first.value;
    };
    return SingleOrNull;
}());
exports.SingleOrNull = SingleOrNull;


/***/ }),
/* 56 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var createComparatorFactory_1 = __webpack_require__(57);
var Sorted = /** @class */ (function () {
    function Sorted() {
    }
    /**
     * Returns a new sequence with all elements sorted by the comparator specified by the given `composeComparator` function
     * or in natural order if no arguments are given.
     *
     * @returns {Sequence<T>}
     */
    Sorted.prototype.sorted = function (composeComparator) {
        var result = [];
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            result.push(item.value);
        }
        if (composeComparator == null) {
            result.sort();
        }
        else {
            var factory = createComparatorFactory_1.default();
            var comparator = composeComparator(factory);
            result.sort(comparator);
        }
        var iterator = result[Symbol.iterator]();
        return Sequence_1.createSequence(iterator);
    };
    return Sorted;
}());
exports.Sorted = Sorted;


/***/ }),
/* 57 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
function compare(comparison) {
    return Object.assign(comparison, {
        reversed: function () {
            return compare(function (a, b) { return comparison(a, b) * -1; });
        },
        then: function (nextComparison) {
            return compare(function (a, b) {
                var result = comparison(a, b);
                return result !== 0
                    ? result
                    : nextComparison(a, b);
            });
        },
        thenDescending: function (nextComparison) {
            return this.then(compare(nextComparison)
                .reversed());
        },
        thenBy: function (keyOrSelector) {
            var selector = asSelector(keyOrSelector);
            return this.then(function (a, b) { return naturalCompare(selector(a), selector(b)); });
        },
        thenByDescending: function (keyOrSelector) {
            var selector = asSelector(keyOrSelector);
            return this.then(compare(function (a, b) { return naturalCompare(selector(a), selector(b)); }).reversed());
        }
    });
}
function compareBy(keyOrSelector) {
    var selector = asSelector(keyOrSelector);
    return compare(function (a, b) { return naturalCompare(selector(a), selector(b)); });
}
function compareByDescending(keyOrSelector) {
    var selector = asSelector(keyOrSelector);
    return compare(function (a, b) { return naturalCompare(selector(b), selector(a)); });
}
function asSelector(keyOrSelector) {
    return typeof keyOrSelector === "function"
        ? keyOrSelector
        : function (item) { return item[keyOrSelector]; };
}
function naturalCompare(a, b) {
    return a < b ? -1 : a > b ? 1 : 0;
}
function naturalOrder() {
    return compare(naturalCompare);
}
function reverseOrder() {
    return compare(naturalCompare).reversed();
}
function nullsLast() {
    return compare(function (a, b) { return a === null ? 1 : b === null ? -1 : 0; });
}
function nullsFirst() {
    return compare(function (a, b) { return a === null ? -1 : b === null ? 1 : 0; });
}
function createComparatorFactory() {
    return {
        compare: compare,
        compareBy: compareBy,
        compareByDescending: compareByDescending,
        naturalOrder: naturalOrder,
        reverseOrder: reverseOrder,
        nullsFirst: nullsFirst,
        nullsLast: nullsLast
    };
}
exports.default = createComparatorFactory;


/***/ }),
/* 58 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var SortedBy = /** @class */ (function () {
    function SortedBy() {
    }
    /**
     * Returns a new sequence with all elements sorted ascending by the value specified
     * by the given `selector` function.
     *
     * @param {(value: T) => R} selector
     * @returns {Sequence<T>}
     */
    SortedBy.prototype.sortedBy = function (selector) {
        return this.sorted(function (it) { return it.compareBy(selector); });
    };
    return SortedBy;
}());
exports.SortedBy = SortedBy;


/***/ }),
/* 59 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var SortedByDescending = /** @class */ (function () {
    function SortedByDescending() {
    }
    /**
     * Returns a new sequence with all elements sorted descending by the value specified
     * by the given `selector` function.
     *
     * @param {(value: T) => R} selector
     * @returns {Sequence<T>}
     */
    SortedByDescending.prototype.sortedByDescending = function (selector) {
        return this.sorted(function (it) { return it.compareByDescending(selector); });
    };
    return SortedByDescending;
}());
exports.SortedByDescending = SortedByDescending;


/***/ }),
/* 60 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var SortedDescending = /** @class */ (function () {
    function SortedDescending() {
    }
    /**
     * Returns a new sequence with all elements sorted in reverse (descending) natural order.
     *
     * @returns {Sequence<T>}
     */
    SortedDescending.prototype.sortedDescending = function () {
        return this.sorted(function (it) { return it.reverseOrder(); });
    };
    return SortedDescending;
}());
exports.SortedDescending = SortedDescending;


/***/ }),
/* 61 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var SortedWith = /** @class */ (function () {
    function SortedWith() {
    }
    /**
     * Returns a new sequence with all elements sorted be the given `compare` function.
     *
     * @param {(a: T, b: T) => number} comparison
     * @returns {Sequence<T>}
     */
    SortedWith.prototype.sortedWith = function (comparison) {
        return this.sorted(function (it) { return it.compare(comparison); });
    };
    return SortedWith;
}());
exports.SortedWith = SortedWith;


/***/ }),
/* 62 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sum = /** @class */ (function () {
    function Sum() {
    }
    /**
     * Returns the sum of all numbers.
     *
     * @returns {number}
     */
    Sum.prototype.sum = function () {
        var result = 0;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            result += item.value;
        }
        return result;
    };
    return Sum;
}());
exports.Sum = Sum;


/***/ }),
/* 63 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var SumBy = /** @class */ (function () {
    function SumBy() {
    }
    /**
     * Returns the sum of all numbers specified by the given `selector` function.
     *
     * @param {(value: T) => number} selector
     * @returns {number}
     */
    SumBy.prototype.sumBy = function (selector) {
        var result = 0;
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            result += selector(item.value);
        }
        return result;
    };
    return SumBy;
}());
exports.SumBy = SumBy;


/***/ }),
/* 64 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Take = /** @class */ (function () {
    function Take() {
    }
    /**
     * Returns a new sequence consisting of the first `n` elements. All other elements
     * are discarded.
     *
     * @param {number} n
     * @returns {Sequence<T>}
     */
    Take.prototype.take = function (n) {
        return this.withIndex()
            .takeWhile(function (it) { return it.index < n; })
            .map(function (it) { return it.value; });
    };
    return Take;
}());
exports.Take = Take;


/***/ }),
/* 65 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var TakeWhileIterator = /** @class */ (function () {
    function TakeWhileIterator(iterator, predicate) {
        this.iterator = iterator;
        this.predicate = predicate;
    }
    TakeWhileIterator.prototype.next = function (value) {
        var item = this.iterator.next();
        if (!item.done) {
            var result = this.predicate(item.value);
            if (result) {
                return { done: false, value: item.value };
            }
        }
        return { done: true, value: undefined };
    };
    return TakeWhileIterator;
}());
var TakeWhile = /** @class */ (function () {
    function TakeWhile() {
    }
    /**
     * Takes all elements of the sequence as long as the given `predicate` evaluates to true.
     *
     * @param {(item: T) => boolean} predicate
     * @returns {Sequence<T>}
     */
    TakeWhile.prototype.takeWhile = function (predicate) {
        return Sequence_1.createSequence(new TakeWhileIterator(this.iterator, predicate));
    };
    return TakeWhile;
}());
exports.TakeWhile = TakeWhile;


/***/ }),
/* 66 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var ToArray = /** @class */ (function () {
    function ToArray() {
    }
    /**
     * Returns all elements of the sequence as array. If an `array` is passed
     * the elements are appended to the end of the array.
     *
     * @param {Array<T>} array
     * @returns {Array<T>}
     */
    ToArray.prototype.toArray = function (array) {
        var result = array || [];
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            result.push(item.value);
        }
        return result;
    };
    /**
     * Returns all elements of the sequence as array. If an `array` is passed
     * the elements are appended to the end of the array.
     *
     * @param {Array<T>} array
     * @returns {Array<T>}
     */
    ToArray.prototype.toList = function (array) {
        return this.toArray(array);
    };
    return ToArray;
}());
exports.ToArray = ToArray;


/***/ }),
/* 67 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var ToMap = /** @class */ (function () {
    function ToMap() {
    }
    /**
     * Returns a map consisting of each key-value pair. If a `map` is passed
     * the pairs are set on this map. Duplicate keys override each other.
     *
     * @param {Map<K, V>} map
     * @returns {Map<K, V>}
     */
    ToMap.prototype.toMap = function (map) {
        var result = map || new Map();
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            var pair = item.value;
            var key = pair[0];
            var value = pair[1];
            result.set(key, value);
        }
        return result;
    };
    return ToMap;
}());
exports.ToMap = ToMap;


/***/ }),
/* 68 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var ToSet = /** @class */ (function () {
    function ToSet() {
    }
    /**
     * Returns all elements of the sequence as set. If a `set` is passed
     * the elements are added to this set.
     *
     * @param {Set<T>} set
     * @returns {Set<T>}
     */
    ToSet.prototype.toSet = function (set) {
        var result = set || new Set();
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            result.add(item.value);
        }
        return result;
    };
    return ToSet;
}());
exports.ToSet = ToSet;


/***/ }),
/* 69 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var Unzip = /** @class */ (function () {
    function Unzip() {
    }
    /**
     * Returns a pair of arrays where the first array contains all first values
     * and the second array all second values from each input pair of the sequence.
     *
     * @returns {[Array<T> , Array<S>]}
     */
    Unzip.prototype.unzip = function () {
        var array1 = [];
        var array2 = [];
        for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
            var _a = item.value, first = _a[0], second = _a[1];
            array1.push(first);
            array2.push(second);
        }
        return [array1, array2];
    };
    return Unzip;
}());
exports.Unzip = Unzip;


/***/ }),
/* 70 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var IndexIterator = /** @class */ (function () {
    function IndexIterator(iterator) {
        this.iterator = iterator;
        this.index = -1;
    }
    IndexIterator.prototype.next = function (value) {
        var item = this.iterator.next();
        if (item.done) {
            return { done: true, value: undefined };
        }
        this.index++;
        return {
            done: false,
            value: {
                index: this.index,
                value: item.value
            }
        };
    };
    return IndexIterator;
}());
var WithIndex = /** @class */ (function () {
    function WithIndex() {
    }
    /**
     * Returns a new sequence consisting of indexed values for all original elements.
     *
     * @returns {Sequence<IndexedValue<T>>}
     */
    WithIndex.prototype.withIndex = function () {
        return Sequence_1.createSequence(new IndexIterator(this.iterator));
    };
    return WithIndex;
}());
exports.WithIndex = WithIndex;


/***/ }),
/* 71 */
/***/ (function(module, exports, __webpack_require__) {

Object.defineProperty(exports, "__esModule", { value: true });
var Sequence_1 = __webpack_require__(0);
var ZipIterator = /** @class */ (function () {
    function ZipIterator(iterator1, iterator2) {
        this.iterator1 = iterator1;
        this.iterator2 = iterator2;
    }
    ZipIterator.prototype.next = function (value) {
        var item1 = this.iterator1.next();
        var item2 = this.iterator2.next();
        if (item1.done || item2.done) {
            return { done: true, value: undefined };
        }
        else {
            return { done: false, value: [item1.value, item2.value] };
        }
    };
    return ZipIterator;
}());
var Zip = /** @class */ (function () {
    function Zip() {
    }
    /**
     * Returns a new sequence consisting of pairs built the elements of both sequences
     * with the same index. The resulting sequence has the length of the shortest input
     * sequence. All other elements are discarded.
     *
     * @param {Sequence<S>} other
     * @returns {Sequence<[T , S]>}
     */
    Zip.prototype.zip = function (other) {
        return Sequence_1.createSequence(new ZipIterator(this.iterator, other.iterator));
    };
    return Zip;
}());
exports.Zip = Zip;


/***/ }),
/* 72 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var GeneratorIterator = /** @class */ (function () {
    function GeneratorIterator(nextFunction) {
        this.nextFunction = nextFunction;
    }
    GeneratorIterator.prototype.next = function (value) {
        var nextItem = this.nextFunction();
        return {
            done: nextItem == null,
            value: nextItem
        };
    };
    return GeneratorIterator;
}());
exports.default = GeneratorIterator;


/***/ }),
/* 73 */
/***/ (function(module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });
var GeneratorSeedIterator = /** @class */ (function () {
    function GeneratorSeedIterator(seed, nextFunction) {
        this.seed = seed;
        this.nextFunction = nextFunction;
    }
    GeneratorSeedIterator.prototype.next = function (value) {
        if (this.prevItem == null) {
            this.prevItem = this.seed;
            return { done: false, value: this.seed };
        }
        var nextItem = this.nextFunction(this.prevItem);
        if (nextItem == null) {
            return { done: true, value: undefined };
        }
        this.prevItem = nextItem;
        return {
            done: false,
            value: nextItem
        };
    };
    return GeneratorSeedIterator;
}());
exports.default = GeneratorSeedIterator;


/***/ })
/******/ ]);
});
//# sourceMappingURL=sequency.js.map