sequency
Version:
Functional sequences for processing iterable data in JavaScript
1,615 lines (1,488 loc) • 81.5 kB
JavaScript
(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 });
exports.range = exports.generateSequence = exports.extendSequence = exports.isSequence = exports.createSequence = exports.asSequence = exports.emptySequence = exports.sequenceOf = void 0;
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 [".concat(start, "] must be lower then endInclusive [").concat(endInclusive, "]"));
}
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 });
exports.All = void 0;
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 });
exports.Any = void 0;
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 });
exports.AsIterable = void 0;
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 });
exports.Associate = void 0;
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 });
exports.AssociateBy = void 0;
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 });
exports.Average = void 0;
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 });
exports.Chunk = void 0;
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 });
exports.Contains = void 0;
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 });
exports.Count = void 0;
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 });
exports.Distinct = void 0;
var Sequence_1 = __webpack_require__(0);
var DistinctIterator = /** @class */ (function () {
function DistinctIterator(iterator) {
this.iterator = iterator;
this.set = new Set();
}
DistinctIterator.prototype.next = function (value) {
for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
var sizeBeforeAdd = this.set.size;
this.set.add(item.value);
if (this.set.size > sizeBeforeAdd) {
return { done: false, value: item.value };
}
}
this.set.clear();
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 (0, Sequence_1.createSequence)(new DistinctIterator(this.iterator));
};
return Distinct;
}());
exports.Distinct = Distinct;
/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.DistinctBy = void 0;
var Sequence_1 = __webpack_require__(0);
var DistinctByIterator = /** @class */ (function () {
function DistinctByIterator(iterator, selector) {
this.iterator = iterator;
this.selector = selector;
this.set = new Set();
}
DistinctByIterator.prototype.next = function (value) {
for (var item = this.iterator.next(); !item.done; item = this.iterator.next()) {
var key = this.selector(item.value);
var sizeBeforeAdd = this.set.size;
this.set.add(key);
if (this.set.size > sizeBeforeAdd) {
return { done: false, value: item.value };
}
}
this.set.clear();
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 (0, Sequence_1.createSequence)(new DistinctByIterator(this.iterator, selector));
};
return DistinctBy;
}());
exports.DistinctBy = DistinctBy;
/***/ }),
/* 12 */
/***/ (function(module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.Drop = void 0;
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 });
exports.DropWhile = void 0;
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 (0, Sequence_1.createSequence)(new DropWhileIterator(this.iterator, predicate));
};
return DropWhile;
}());
exports.DropWhile = DropWhile;
/***/ }),
/* 14 */
/***/ (function(module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ElementAt = void 0;
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 });
exports.ElementAtOrElse = void 0;
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 });
exports.ElementAtOrNull = void 0;
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 });
exports.Filter = void 0;
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 (0, Sequence_1.createSequence)(new FilterIterator(predicate, this.iterator));
};
return Filter;
}());
exports.Filter = Filter;
/***/ }),
/* 18 */
/***/ (function(module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.FilterIndexed = void 0;
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 });
exports.FilterNot = void 0;
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 });
exports.FilterNotNull = void 0;
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 });
exports.First = void 0;
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 });
exports.FirstOrNull = void 0;
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 });
exports.FlatMap = void 0;
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 (0, 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 });
exports.Flatten = void 0;
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 ((0, Sequence_1.isSequence)(it)) {
return it;
}
else {
return (0, Sequence_1.asSequence)(it);
}
});
};
return Flatten;
}());
exports.Flatten = Flatten;
/***/ }),
/* 25 */
/***/ (function(module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.Fold = void 0;
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 });
exports.FoldIndexed = void 0;
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 });
exports.ForEach = void 0;
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 });
exports.ForEachIndexed = void 0;
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 });
exports.GroupBy = void 0;
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 });
exports.IndexOf = void 0;
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 });
exports.IndexOfFirst = void 0;
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 });
exports.IndexOfLast = void 0;
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 });
exports.JoinToString = void 0;
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 = "".concat(value).concat(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 });
exports.Last = void 0;
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 });
exports.LastOrNull = void 0;
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 });
exports.Map = void 0;
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 {(S) => T} transform
* @returns {Sequence<T>}
*/
Map.prototype.map = function (transform) {
return (0, Sequence_1.createSequence)(new MapIterator(transform, this.iterator));
};
return Map;
}());
exports.Map = Map;
/***/ }),
/* 37 */
/***/ (function(module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.MapIndexed = void 0;
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 });
exports.MapNotNull = void 0;
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
? (0, Sequence_1.sequenceOf)(item)
: (0, Sequence_1.emptySequence)();
});
};
return MapNotNull;
}());
exports.MapNotNull = MapNotNull;
/***/ }),
/* 39 */
/***/ (function(module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.Max = void 0;
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 });
exports.MaxBy = void 0;
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 });
exports.MaxWith = void 0;
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__) {
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
Ob