This repository has been archived by the owner on Dec 25, 2018. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 36
/
Linq.js.map
1 lines (1 loc) · 236 KB
/
Linq.js.map
1
{"version":3,"sources":["System.Linq/Linq.js","System.Linq/Linq.ts"],"names":["__extends","this","d","b","__","constructor","p","hasOwnProperty","prototype","Object","create","define","require","exports","Values","Arrays","ArrayUtility","Enumerator_1","Types_1","Integer_1","Functions_1","ArrayEnumerator_1","EnumeratorBase_1","Dictionary_1","Queue_1","dispose_1","DisposableBase_1","UnsupportedEnumerableException_1","ObjectDisposedException_1","KeySortedContext_1","ArgumentNullException_1","ArgumentOutOfRangeException_1","getEmptyEnumerator","empty","nextEnumerator","queue","e","moveNext","enqueue","dispose","createSortContext","orderedEnumerable","currentContext","context","KeySortedContext","keySelector","order","comparer","parent","throwIfDisposed","disposed","ObjectDisposedException","INVALID_DEFAULT","VOID0","BREAK","element","LinqFunctions","_super","apply","arguments","Greater","a","Lesser","Functions","freeze","InfiniteEnumerable","_enumeratorFactory","finalizer","call","_isEndless","defineProperty","get","enumerable","configurable","getEnumerator","_onDispose","asEnumerable","_","doAction","action","initializer","isEndless","Enumerable","enumerator","index","EnumeratorBase","yielder","actionResult","current","yieldBreak","yieldReturn","force","skip","count","isFinite","Integer","assert","take","ArgumentOutOfRangeException","elementAt","v","elementAtOrDefault","defaultValue","assertZeroOrGreater","n","using","i","first","firstOrDefault","Error","single","value","singleOrDefault","any","isEmpty","traverseBreadthFirst","childrenSelector","resultSelector","Identity","buffer","len","nestLevel","next","from","selectMany","length","traverseDepthFirst","enumeratorStack","fromAny","these","flatten","middleEnumerator","c","Type","isString","pairwise","selector","prev","scan","func","seed","isUseSeed","isFirst","select","_selectMany","collectionSelector","undefined","middleSeq","_choose","result","choose","where","predicate","ofType","type","typeName","Number","NUMBER","String","STRING","Boolean","BOOLEAN","Function","FUNCTION","x","except","second","compareSelector","keys","Dictionary","forEach","key","addByKeyValue","containsKey","clear","distinct","distinctUntilChanged","compareKey","initial","areEqual","defaultIfEmpty","zip","firstEnumerator","secondEnumerator","zipMultiple","secondTemp","Queue","dequeue","join","inner","outerKeySelector","innerKeySelector","outerEnumerator","lookup","innerElements","innerCount","toLookup","innerElement","groupJoin","merge","enumerables","concat","_i","union","insertAt","other","isEnumerated","alternateMultiple","sequence","mode","alternateEnumerator","ArrayEnumerator","toArray","hasAtLeastOne","reset","latest","another","alternateSingle","make","alternate","catchError","handler","finallyAction","size","array","initialize","share","sharedEnumerator","DisposableBase","enumeratorFactory","source","UnsupportedEnumerableException","defaultEnumerable","isObject","isArrayLike","ArrayEnumerable","isEnumerable","fromOrEmpty","choice","values","random","chooseFrom","args","cycle","cycleThrough","FiniteEnumerable","repeat","Infinity","repeatWithFinalize","range","start","step","rangeDown","Math","abs","toInfinity","toNegativeInfinity","rangeTo","to","isNaN","matches","input","pattern","flags","ArgumentNullException","RegExp","indexOf","regex","match","exec","generate","factory","unfold","valueFactory","skipSeed","map","max","takeUntil","aggregate","min","weave","mainEnumerator","dump","skipWhile","takeWhile","includeUntilValue","found","throwIfEndless","copyTo","target","elementSelector","dict","getValue","push","Lookup","toMap","obj","toDictionary","toJoinedString","separator","takeExceptLast","q","skipToLast","reverse","shuffle","capacity","selectedIndex","selectedValue","all","every","some","contains","lastIndexOf","intersect","outs","sequenceEqual","equalityComparer","e1","e2","orderBy","OrderedEnumerable","orderUsing","comparison","orderUsingReversed","orderByDescending","groupBy","_this","partitionBy","elements","Grouping","group","hasNext","lastOrDefault","average","numberOrNaN","sum","NaN","maxBy","minBy","sumInfinite","product","exists","quotient","last","memoize","cache","_source","_disposableObjectName","s","Array","isArray","_groupKey","_dictionary","compare","createOrderedEnumerable","thenBy","thenUsing","thenByDescending","thenUsingReversed","indexes","generateSortedIndexes"],"mappings":"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","file":"System.Linq/Linq.js","sourcesContent":["/*!\n * @author electricessence / https://github.com/electricessence/\n * Original: http://linqjs.codeplex.com/\n * Licensing: MIT https://github.com/electricessence/TypeScript.NET/blob/master/LICENSE.md\n */\nvar __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\ndefine([\"require\", \"exports\", \"../System/Compare\", \"../System/Collections/Array/Compare\", \"../System/Collections/Array/Utility\", \"../System/Collections/Enumeration/Enumerator\", \"../System/Types\", \"../System/Integer\", \"../System/Functions\", \"../System/Collections/Enumeration/ArrayEnumerator\", \"../System/Collections/Enumeration/EnumeratorBase\", \"../System/Collections/Dictionaries/Dictionary\", \"../System/Collections/Queue\", \"../System/Disposable/dispose\", \"../System/Disposable/DisposableBase\", \"../System/Collections/Enumeration/UnsupportedEnumerableException\", \"../System/Disposable/ObjectDisposedException\", \"../System/Collections/Sorting/KeySortedContext\", \"../System/Exceptions/ArgumentNullException\", \"../System/Exceptions/ArgumentOutOfRangeException\"], function (require, exports, Values, Arrays, ArrayUtility, Enumerator_1, Types_1, Integer_1, Functions_1, ArrayEnumerator_1, EnumeratorBase_1, Dictionary_1, Queue_1, dispose_1, DisposableBase_1, UnsupportedEnumerableException_1, ObjectDisposedException_1, KeySortedContext_1, ArgumentNullException_1, ArgumentOutOfRangeException_1) {\n \"use strict\";\n var INVALID_DEFAULT = {};\n var VOID0 = void 0;\n var BREAK = function (element) { return 0; };\n var LinqFunctions = (function (_super) {\n __extends(LinqFunctions, _super);\n function LinqFunctions() {\n _super.apply(this, arguments);\n }\n LinqFunctions.prototype.Greater = function (a, b) {\n return a > b ? a : b;\n };\n LinqFunctions.prototype.Lesser = function (a, b) {\n return a < b ? a : b;\n };\n return LinqFunctions;\n }(Functions_1.Functions));\n var Functions = new LinqFunctions();\n Object.freeze(Functions);\n function getEmptyEnumerator() {\n return Enumerator_1.empty;\n }\n var InfiniteEnumerable = (function (_super) {\n __extends(InfiniteEnumerable, _super);\n function InfiniteEnumerable(_enumeratorFactory, finalizer) {\n _super.call(this, finalizer);\n this._enumeratorFactory = _enumeratorFactory;\n this._isEndless = true;\n }\n Object.defineProperty(InfiniteEnumerable.prototype, \"isEndless\", {\n get: function () {\n return this._isEndless;\n },\n enumerable: true,\n configurable: true\n });\n InfiniteEnumerable.prototype.getEnumerator = function () {\n this.throwIfDisposed();\n return this._enumeratorFactory();\n };\n InfiniteEnumerable.prototype._onDispose = function () {\n _super.prototype._onDispose.call(this);\n this._enumeratorFactory = null;\n };\n InfiniteEnumerable.prototype.asEnumerable = function () {\n var _ = this;\n _.throwIfDisposed();\n return new InfiniteEnumerable(function () { return _.getEnumerator(); });\n };\n InfiniteEnumerable.prototype.doAction = function (action, initializer, isEndless) {\n if (isEndless === void 0) { isEndless = this.isEndless; }\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n throwIfDisposed(disposed);\n if (initializer)\n initializer();\n index = 0;\n enumerator = _.getEnumerator();\n }, function (yielder) {\n throwIfDisposed(disposed);\n while (enumerator.moveNext()) {\n var actionResult = action(enumerator.current, index++);\n if (actionResult === false || actionResult === 0)\n return yielder.yieldBreak();\n if (actionResult !== 2)\n return yielder.yieldReturn(enumerator.current);\n }\n return false;\n }, function () {\n dispose_1.dispose(enumerator);\n }, isEndless);\n }, function () {\n disposed = true;\n }, isEndless);\n };\n InfiniteEnumerable.prototype.force = function () {\n this.throwIfDisposed();\n this.doAction(BREAK)\n .getEnumerator()\n .moveNext();\n };\n InfiniteEnumerable.prototype.skip = function (count) {\n var _ = this;\n _.throwIfDisposed();\n if (!isFinite(count))\n return Enumerable.empty();\n Integer_1.Integer.assert(count, \"count\");\n return this.doAction(function (element, index) {\n return index < count\n ? 2\n : 1;\n });\n };\n InfiniteEnumerable.prototype.take = function (count) {\n if (!(count > 0))\n return Enumerable.empty();\n var _ = this;\n _.throwIfDisposed();\n if (!isFinite(count))\n throw new ArgumentOutOfRangeException_1.ArgumentOutOfRangeException('count', count, 'Must be finite.');\n Integer_1.Integer.assert(count, \"count\");\n return _.doAction(function (element, index) { return index < count; }, null, false);\n };\n InfiniteEnumerable.prototype.elementAt = function (index) {\n var v = this.elementAtOrDefault(index, INVALID_DEFAULT);\n if (v === INVALID_DEFAULT)\n throw new ArgumentOutOfRangeException_1.ArgumentOutOfRangeException('index', index, \"is greater than or equal to the number of elements in source\");\n return v;\n };\n InfiniteEnumerable.prototype.elementAtOrDefault = function (index, defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n var _ = this;\n _.throwIfDisposed();\n Integer_1.Integer.assertZeroOrGreater(index, 'index');\n var n = index;\n return dispose_1.using(this.getEnumerator(), function (e) {\n var i = 0;\n while (e.moveNext()) {\n if (i == n)\n return e.current;\n i++;\n }\n return defaultValue;\n });\n };\n InfiniteEnumerable.prototype.first = function () {\n var v = this.firstOrDefault(INVALID_DEFAULT);\n if (v === INVALID_DEFAULT)\n throw new Error(\"first:The sequence is empty.\");\n return v;\n };\n InfiniteEnumerable.prototype.firstOrDefault = function (defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n var _ = this;\n _.throwIfDisposed();\n return dispose_1.using(this.getEnumerator(), function (e) { return e.moveNext() ? e.current : defaultValue; });\n };\n InfiniteEnumerable.prototype.single = function () {\n var _ = this;\n _.throwIfDisposed();\n return dispose_1.using(this.getEnumerator(), function (e) {\n if (e.moveNext()) {\n var value = e.current;\n if (!e.moveNext())\n return value;\n throw new Error(\"single:sequence contains more than one element.\");\n }\n throw new Error(\"single:The sequence is empty.\");\n });\n };\n InfiniteEnumerable.prototype.singleOrDefault = function (defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n var _ = this;\n _.throwIfDisposed();\n return dispose_1.using(this.getEnumerator(), function (e) {\n if (e.moveNext()) {\n var value = e.current;\n if (!e.moveNext())\n return value;\n }\n return defaultValue;\n });\n };\n InfiniteEnumerable.prototype.any = function () {\n var _ = this;\n _.throwIfDisposed();\n return dispose_1.using(this.getEnumerator(), function (e) { return e.moveNext(); });\n };\n InfiniteEnumerable.prototype.isEmpty = function () {\n return !this.any();\n };\n InfiniteEnumerable.prototype.traverseBreadthFirst = function (childrenSelector, resultSelector) {\n if (resultSelector === void 0) { resultSelector = Functions.Identity; }\n var _ = this, isEndless = _._isEndless || null;\n return new Enumerable(function () {\n var enumerator;\n var nestLevel = 0;\n var buffer, len;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n nestLevel = 0;\n buffer = [];\n len = 0;\n enumerator = _.getEnumerator();\n }, function (yielder) {\n while (true) {\n if (enumerator.moveNext()) {\n buffer[len++] = enumerator.current;\n return yielder.yieldReturn(resultSelector(enumerator.current, nestLevel));\n }\n if (!len)\n return yielder.yieldBreak();\n var next = Enumerable\n .from(buffer)\n .selectMany(childrenSelector);\n if (!next.any()) {\n return yielder.yieldBreak();\n }\n else {\n nestLevel++;\n buffer = [];\n len = 0;\n enumerator.dispose();\n enumerator = next.getEnumerator();\n }\n }\n }, function () {\n dispose_1.dispose(enumerator);\n buffer.length = 0;\n }, isEndless);\n }, null, isEndless);\n };\n InfiniteEnumerable.prototype.traverseDepthFirst = function (childrenSelector, resultSelector) {\n if (resultSelector === void 0) { resultSelector = Functions.Identity; }\n var _ = this, isEndless = _._isEndless || null;\n return new Enumerable(function () {\n var enumeratorStack = [];\n var enumerator;\n var len;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n enumerator = _.getEnumerator();\n len = 0;\n }, function (yielder) {\n while (true) {\n if (enumerator.moveNext()) {\n var value = resultSelector(enumerator.current, len);\n enumeratorStack[len++] = enumerator;\n var e = Enumerable.fromAny(childrenSelector(enumerator.current));\n enumerator = e ? e.getEnumerator() : Enumerator_1.empty;\n return yielder.yieldReturn(value);\n }\n if (len == 0)\n return false;\n enumerator.dispose();\n enumerator = enumeratorStack[--len];\n enumeratorStack.length = len;\n }\n }, function () {\n try {\n dispose_1.dispose(enumerator);\n }\n finally {\n dispose_1.dispose.these(enumeratorStack);\n }\n }, isEndless);\n }, null, isEndless);\n };\n InfiniteEnumerable.prototype.flatten = function () {\n var _ = this, isEndless = _._isEndless || null;\n return new Enumerable(function () {\n var enumerator;\n var middleEnumerator = null;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n enumerator = _.getEnumerator();\n }, function (yielder) {\n while (true) {\n if (middleEnumerator) {\n if (middleEnumerator.moveNext()) {\n return yielder.yieldReturn(middleEnumerator.current);\n }\n else {\n middleEnumerator.dispose();\n middleEnumerator = null;\n }\n }\n if (enumerator.moveNext()) {\n var c = enumerator.current;\n var e = !Types_1.Type.isString(c) && Enumerable.fromAny(c);\n if (e) {\n middleEnumerator\n = e\n .selectMany(Functions.Identity)\n .flatten()\n .getEnumerator();\n continue;\n }\n else {\n return yielder.yieldReturn(c);\n }\n }\n return yielder.yieldBreak();\n }\n }, function () {\n dispose_1.dispose(enumerator, middleEnumerator);\n }, isEndless);\n }, null, isEndless);\n };\n InfiniteEnumerable.prototype.pairwise = function (selector) {\n var _ = this;\n return new Enumerable(function () {\n var enumerator;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n enumerator = _.getEnumerator();\n enumerator.moveNext();\n }, function (yielder) {\n var prev = enumerator.current;\n return enumerator.moveNext()\n && yielder.yieldReturn(selector(prev, enumerator.current));\n }, function () {\n dispose_1.dispose(enumerator);\n }, _._isEndless);\n }, null, _._isEndless);\n };\n InfiniteEnumerable.prototype.scan = function (func, seed) {\n var isUseSeed = seed !== VOID0;\n var _ = this;\n return new Enumerable(function () {\n var enumerator;\n var value;\n var isFirst;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n enumerator = _.getEnumerator();\n isFirst = true;\n }, function (yielder) {\n if (isFirst) {\n isFirst = false;\n return isUseSeed\n ? yielder.yieldReturn(value = seed)\n : enumerator.moveNext() && yielder.yieldReturn(value\n = enumerator.current);\n }\n return (enumerator.moveNext())\n ? yielder.yieldReturn(value = func(value, enumerator.current))\n : false;\n }, function () {\n dispose_1.dispose(enumerator);\n }, _._isEndless);\n }, null, _._isEndless);\n };\n InfiniteEnumerable.prototype.select = function (selector) {\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n throwIfDisposed(disposed);\n index = 0;\n enumerator = _.getEnumerator();\n }, function (yielder) {\n throwIfDisposed(disposed);\n return enumerator.moveNext()\n ? yielder.yieldReturn(selector(enumerator.current, index++))\n : yielder.yieldBreak();\n }, function () {\n dispose_1.dispose(enumerator);\n }, _._isEndless);\n }, function () {\n disposed = true;\n }, _._isEndless);\n };\n InfiniteEnumerable.prototype._selectMany = function (collectionSelector, resultSelector) {\n var _ = this, isEndless = _._isEndless || null;\n if (!resultSelector)\n resultSelector = function (a, b) { return b; };\n return new Enumerable(function () {\n var enumerator;\n var middleEnumerator;\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n enumerator = _.getEnumerator();\n middleEnumerator = undefined;\n index = 0;\n }, function (yielder) {\n if (middleEnumerator === VOID0 && !enumerator.moveNext())\n return false;\n do {\n if (!middleEnumerator) {\n var middleSeq = collectionSelector(enumerator.current, index++);\n if (!middleSeq)\n continue;\n middleEnumerator = Enumerator_1.from(middleSeq);\n }\n if (middleEnumerator.moveNext())\n return yielder.yieldReturn(resultSelector(enumerator.current, middleEnumerator.current));\n middleEnumerator.dispose();\n middleEnumerator = null;\n } while (enumerator.moveNext());\n return false;\n }, function () {\n dispose_1.dispose(enumerator, middleEnumerator);\n enumerator = null;\n middleEnumerator = null;\n }, isEndless);\n }, null, isEndless);\n };\n InfiniteEnumerable.prototype.selectMany = function (collectionSelector, resultSelector) {\n return this._selectMany(collectionSelector, resultSelector);\n };\n InfiniteEnumerable.prototype._choose = function (selector) {\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n throwIfDisposed(disposed);\n index = 0;\n enumerator = _.getEnumerator();\n }, function (yielder) {\n throwIfDisposed(disposed);\n while (enumerator.moveNext()) {\n var result = selector(enumerator.current, index++);\n if (result !== null && result !== VOID0)\n return yielder.yieldReturn(result);\n }\n return false;\n }, function () {\n dispose_1.dispose(enumerator);\n }, _._isEndless);\n }, function () {\n disposed = true;\n }, _._isEndless);\n };\n InfiniteEnumerable.prototype.choose = function (selector) {\n if (selector === void 0) { selector = Functions.Identity; }\n return this._choose(selector);\n };\n InfiniteEnumerable.prototype.where = function (predicate) {\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n throwIfDisposed(disposed);\n index = 0;\n enumerator = _.getEnumerator();\n }, function (yielder) {\n throwIfDisposed(disposed);\n while (enumerator.moveNext()) {\n if (predicate(enumerator.current, index++))\n return yielder.yieldReturn(enumerator.current);\n }\n return false;\n }, function () {\n dispose_1.dispose(enumerator);\n }, _._isEndless);\n }, function () {\n disposed = true;\n }, _._isEndless);\n };\n InfiniteEnumerable.prototype.ofType = function (type) {\n var typeName;\n switch (type) {\n case Number:\n typeName = Types_1.Type.NUMBER;\n break;\n case String:\n typeName = Types_1.Type.STRING;\n break;\n case Boolean:\n typeName = Types_1.Type.BOOLEAN;\n break;\n case Function:\n typeName = Types_1.Type.FUNCTION;\n break;\n default:\n return this\n .where(function (x) { return x instanceof type; });\n }\n return this\n .choose()\n .where(function (x) { return (typeof x) === typeName; });\n };\n InfiniteEnumerable.prototype.except = function (second, compareSelector) {\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n var keys;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n throwIfDisposed(disposed);\n enumerator = _.getEnumerator();\n keys = new Dictionary_1.Dictionary(compareSelector);\n if (second)\n Enumerator_1.forEach(second, function (key) { return keys.addByKeyValue(key, true); });\n }, function (yielder) {\n throwIfDisposed(disposed);\n while (enumerator.moveNext()) {\n var current = enumerator.current;\n if (!keys.containsKey(current)) {\n keys.addByKeyValue(current, true);\n return yielder.yieldReturn(current);\n }\n }\n return false;\n }, function () {\n dispose_1.dispose(enumerator);\n keys.clear();\n }, _._isEndless);\n }, function () {\n disposed = true;\n }, _._isEndless);\n };\n InfiniteEnumerable.prototype.distinct = function (compareSelector) {\n return this.except(null, compareSelector);\n };\n InfiniteEnumerable.prototype.distinctUntilChanged = function (compareSelector) {\n if (compareSelector === void 0) { compareSelector = Functions.Identity; }\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n var compareKey;\n var initial = true;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n throwIfDisposed(disposed);\n enumerator = _.getEnumerator();\n }, function (yielder) {\n throwIfDisposed(disposed);\n while (enumerator.moveNext()) {\n var key = compareSelector(enumerator.current);\n if (initial) {\n initial = false;\n }\n else if (Values.areEqual(compareKey, key)) {\n continue;\n }\n compareKey = key;\n return yielder.yieldReturn(enumerator.current);\n }\n return false;\n }, function () {\n dispose_1.dispose(enumerator);\n }, _._isEndless);\n }, function () {\n disposed = true;\n }, _._isEndless);\n };\n InfiniteEnumerable.prototype.defaultIfEmpty = function (defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n var isFirst;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n isFirst = true;\n throwIfDisposed(disposed);\n enumerator = _.getEnumerator();\n }, function (yielder) {\n throwIfDisposed(disposed);\n if (enumerator.moveNext()) {\n isFirst = false;\n return yielder.yieldReturn(enumerator.current);\n }\n else if (isFirst) {\n isFirst = false;\n return yielder.yieldReturn(defaultValue);\n }\n return false;\n }, function () {\n dispose_1.dispose(enumerator);\n }, _._isEndless);\n }, null, _._isEndless);\n };\n InfiniteEnumerable.prototype.zip = function (second, resultSelector) {\n var _ = this;\n _.throwIfDisposed();\n return new Enumerable(function () {\n var firstEnumerator;\n var secondEnumerator;\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n index = 0;\n firstEnumerator = _.getEnumerator();\n secondEnumerator = Enumerator_1.from(second);\n }, function (yielder) { return firstEnumerator.moveNext()\n && secondEnumerator.moveNext()\n && yielder.yieldReturn(resultSelector(firstEnumerator.current, secondEnumerator.current, index++)); }, function () {\n dispose_1.dispose(firstEnumerator, secondEnumerator);\n });\n });\n };\n InfiniteEnumerable.prototype.zipMultiple = function (second, resultSelector) {\n var _ = this;\n _.throwIfDisposed();\n if (!second.length)\n return Enumerable.empty();\n return new Enumerable(function () {\n var secondTemp;\n var firstEnumerator;\n var secondEnumerator;\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n secondTemp = new Queue_1.Queue(second);\n index = 0;\n firstEnumerator = _.getEnumerator();\n secondEnumerator = null;\n }, function (yielder) {\n if (firstEnumerator.moveNext()) {\n while (true) {\n while (!secondEnumerator) {\n if (secondTemp.count) {\n var next = secondTemp.dequeue();\n if (next)\n secondEnumerator = Enumerator_1.from(next);\n }\n else\n return yielder.yieldBreak();\n }\n if (secondEnumerator.moveNext())\n return yielder.yieldReturn(resultSelector(firstEnumerator.current, secondEnumerator.current, index++));\n secondEnumerator.dispose();\n secondEnumerator = null;\n }\n }\n return yielder.yieldBreak();\n }, function () {\n dispose_1.dispose(firstEnumerator, secondTemp);\n });\n });\n };\n InfiniteEnumerable.prototype.join = function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector) {\n if (compareSelector === void 0) { compareSelector = Functions.Identity; }\n var _ = this;\n return new Enumerable(function () {\n var outerEnumerator;\n var lookup;\n var innerElements = null;\n var innerCount = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n outerEnumerator = _.getEnumerator();\n lookup = Enumerable.from(inner)\n .toLookup(innerKeySelector, Functions.Identity, compareSelector);\n }, function (yielder) {\n while (true) {\n if (innerElements != null) {\n var innerElement = innerElements[innerCount++];\n if (innerElement !== VOID0)\n return yielder.yieldReturn(resultSelector(outerEnumerator.current, innerElement));\n innerElement = null;\n innerCount = 0;\n }\n if (outerEnumerator.moveNext()) {\n var key = outerKeySelector(outerEnumerator.current);\n innerElements = lookup.get(key);\n }\n else {\n return yielder.yieldBreak();\n }\n }\n }, function () {\n dispose_1.dispose(outerEnumerator);\n });\n });\n };\n InfiniteEnumerable.prototype.groupJoin = function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector) {\n if (compareSelector === void 0) { compareSelector = Functions.Identity; }\n var _ = this;\n return new Enumerable(function () {\n var enumerator;\n var lookup = null;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n enumerator = _.getEnumerator();\n lookup = Enumerable.from(inner)\n .toLookup(innerKeySelector, Functions.Identity, compareSelector);\n }, function (yielder) {\n return enumerator.moveNext()\n && yielder.yieldReturn(resultSelector(enumerator.current, lookup.get(outerKeySelector(enumerator.current))));\n }, function () {\n dispose_1.dispose(enumerator);\n });\n });\n };\n InfiniteEnumerable.prototype.merge = function (enumerables) {\n var _ = this, isEndless = _._isEndless || null;\n if (!enumerables || enumerables.length == 0)\n return _;\n return new Enumerable(function () {\n var enumerator;\n var queue;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n enumerator = _.getEnumerator();\n queue = new Queue_1.Queue(enumerables);\n }, function (yielder) {\n while (true) {\n while (!enumerator && queue.count) {\n enumerator = Enumerator_1.from(queue.dequeue());\n }\n if (enumerator && enumerator.moveNext())\n return yielder.yieldReturn(enumerator.current);\n if (enumerator) {\n enumerator.dispose();\n enumerator = null;\n continue;\n }\n return yielder.yieldBreak();\n }\n }, function () {\n dispose_1.dispose(enumerator, queue);\n }, isEndless);\n }, null, isEndless);\n };\n InfiniteEnumerable.prototype.concat = function () {\n var enumerables = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n enumerables[_i - 0] = arguments[_i];\n }\n return this.merge(enumerables);\n };\n InfiniteEnumerable.prototype.union = function (second, compareSelector) {\n if (compareSelector === void 0) { compareSelector = Functions.Identity; }\n var _ = this, isEndless = _._isEndless || null;\n return new Enumerable(function () {\n var firstEnumerator;\n var secondEnumerator;\n var keys;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n firstEnumerator = _.getEnumerator();\n keys = new Dictionary_1.Dictionary(compareSelector);\n }, function (yielder) {\n var current;\n if (secondEnumerator === VOID0) {\n while (firstEnumerator.moveNext()) {\n current = firstEnumerator.current;\n if (!keys.containsKey(current)) {\n keys.addByKeyValue(current, null);\n return yielder.yieldReturn(current);\n }\n }\n secondEnumerator = Enumerator_1.from(second);\n }\n while (secondEnumerator.moveNext()) {\n current = secondEnumerator.current;\n if (!keys.containsKey(current)) {\n keys.addByKeyValue(current, null);\n return yielder.yieldReturn(current);\n }\n }\n return false;\n }, function () {\n dispose_1.dispose(firstEnumerator, secondEnumerator);\n }, isEndless);\n }, null, isEndless);\n };\n InfiniteEnumerable.prototype.insertAt = function (index, other) {\n Integer_1.Integer.assertZeroOrGreater(index, 'index');\n var n = index;\n var _ = this, isEndless = _._isEndless || null;\n _.throwIfDisposed();\n return new Enumerable(function () {\n var firstEnumerator;\n var secondEnumerator;\n var count = 0;\n var isEnumerated = false;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n count = 0;\n firstEnumerator = _.getEnumerator();\n secondEnumerator = Enumerator_1.from(other);\n isEnumerated = false;\n }, function (yielder) {\n if (count == n) {\n isEnumerated = true;\n if (secondEnumerator.moveNext())\n return yielder.yieldReturn(secondEnumerator.current);\n }\n if (firstEnumerator.moveNext()) {\n count++;\n return yielder.yieldReturn(firstEnumerator.current);\n }\n return !isEnumerated\n && secondEnumerator.moveNext()\n && yielder.yieldReturn(secondEnumerator.current);\n }, function () {\n dispose_1.dispose(firstEnumerator, secondEnumerator);\n }, isEndless);\n }, null, isEndless);\n };\n InfiniteEnumerable.prototype.alternateMultiple = function (sequence) {\n var _ = this;\n return new Enumerable(function () {\n var buffer, mode, enumerator, alternateEnumerator;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n alternateEnumerator = new ArrayEnumerator_1.ArrayEnumerator(Enumerable.toArray(sequence));\n enumerator = _.getEnumerator();\n var hasAtLeastOne = enumerator.moveNext();\n mode = hasAtLeastOne\n ? 1\n : 0;\n if (hasAtLeastOne)\n buffer = enumerator.current;\n }, function (yielder) {\n switch (mode) {\n case 0:\n return yielder.yieldBreak();\n case 2:\n if (alternateEnumerator.moveNext())\n return yielder.yieldReturn(alternateEnumerator.current);\n alternateEnumerator.reset();\n mode = 1;\n break;\n }\n var latest = buffer;\n var another = enumerator.moveNext();\n mode = another\n ? 2\n : 0;\n if (another)\n buffer = enumerator.current;\n return yielder.yieldReturn(latest);\n }, function () {\n dispose_1.dispose(enumerator, alternateEnumerator);\n }, _._isEndless);\n }, null, _._isEndless);\n };\n InfiniteEnumerable.prototype.alternateSingle = function (value) {\n return this.alternateMultiple(Enumerable.make(value));\n };\n InfiniteEnumerable.prototype.alternate = function () {\n var sequence = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n sequence[_i - 0] = arguments[_i];\n }\n return this.alternateMultiple(sequence);\n };\n InfiniteEnumerable.prototype.catchError = function (handler) {\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n try {\n throwIfDisposed(disposed);\n enumerator = _.getEnumerator();\n }\n catch (e) {\n }\n }, function (yielder) {\n try {\n throwIfDisposed(disposed);\n if (enumerator.moveNext())\n return yielder.yieldReturn(enumerator.current);\n }\n catch (e) {\n handler(e);\n }\n return false;\n }, function () {\n dispose_1.dispose(enumerator);\n });\n });\n };\n InfiniteEnumerable.prototype.finallyAction = function (action) {\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n throwIfDisposed(disposed);\n enumerator = _.getEnumerator();\n }, function (yielder) {\n throwIfDisposed(disposed);\n return (enumerator.moveNext())\n ? yielder.yieldReturn(enumerator.current)\n : false;\n }, function () {\n try {\n dispose_1.dispose(enumerator);\n }\n finally {\n action();\n }\n });\n });\n };\n InfiniteEnumerable.prototype.buffer = function (size) {\n if (size < 1 || !isFinite(size))\n throw new Error(\"Invalid buffer size.\");\n Integer_1.Integer.assert(size, \"size\");\n var _ = this, len;\n return new Enumerable(function () {\n var enumerator;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n enumerator = _.getEnumerator();\n }, function (yielder) {\n var array = ArrayUtility.initialize(size);\n len = 0;\n while (len < size && enumerator.moveNext()) {\n array[len++] = enumerator.current;\n }\n array.length = len;\n return len && yielder.yieldReturn(array);\n }, function () {\n dispose_1.dispose(enumerator);\n }, _._isEndless);\n }, null, _._isEndless);\n };\n InfiniteEnumerable.prototype.share = function () {\n var _ = this;\n _.throwIfDisposed();\n var sharedEnumerator;\n return new Enumerable(function () {\n return sharedEnumerator || (sharedEnumerator = _.getEnumerator());\n }, function () {\n dispose_1.dispose(sharedEnumerator);\n }, _._isEndless);\n };\n return InfiniteEnumerable;\n }(DisposableBase_1.DisposableBase));\n exports.InfiniteEnumerable = InfiniteEnumerable;\n var Enumerable = (function (_super) {\n __extends(Enumerable, _super);\n function Enumerable(enumeratorFactory, finalizer, isEndless) {\n if (isEndless === void 0) { isEndless = null; }\n _super.call(this, enumeratorFactory, finalizer);\n this._isEndless = isEndless;\n }\n Enumerable.from = function (source) {\n var e = Enumerable.fromAny(source);\n if (!e)\n throw new UnsupportedEnumerableException_1.UnsupportedEnumerableException();\n return e;\n };\n Enumerable.fromAny = function (source, defaultEnumerable) {\n if (defaultEnumerable === void 0) { defaultEnumerable = null; }\n if (Types_1.Type.isObject(source) || Types_1.Type.isString(source)) {\n if (source instanceof Enumerable)\n return source;\n if (Types_1.Type.isArrayLike(source))\n return new ArrayEnumerable(source);\n if (Enumerator_1.isEnumerable(source))\n return new Enumerable(function () { return source.getEnumerator(); }, null, source.isEndless);\n }\n return defaultEnumerable;\n };\n Enumerable.fromOrEmpty = function (source) {\n return Enumerable.fromAny(source) || Enumerable.empty();\n };\n Enumerable.toArray = function (source) {\n if (source instanceof Enumerable)\n return source.toArray();\n return Enumerator_1.toArray(source);\n };\n Enumerable.choice = function (values) {\n var len = values && values.length;\n if (!len || !isFinite(len))\n throw new ArgumentOutOfRangeException_1.ArgumentOutOfRangeException('length', length);\n return new InfiniteEnumerable(function () { return new EnumeratorBase_1.EnumeratorBase(null, function (yielder) {\n return yielder.yieldReturn(Integer_1.Integer.random.select(values));\n }, true); });\n };\n Enumerable.chooseFrom = function () {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i - 0] = arguments[_i];\n }\n return Enumerable.choice(args);\n };\n Enumerable.cycle = function (values) {\n var len = values && values.length;\n if (!len || !isFinite(len))\n throw new ArgumentOutOfRangeException_1.ArgumentOutOfRangeException('length', length);\n return new InfiniteEnumerable(function () {\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n index = 0;\n }, function (yielder) {\n if (index >= values.length)\n index = 0;\n return yielder.yieldReturn(values[index++]);\n }, true);\n });\n };\n Enumerable.cycleThrough = function () {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i - 0] = arguments[_i];\n }\n return Enumerable.cycle(args);\n };\n Enumerable.empty = function () {\n return new FiniteEnumerable(getEmptyEnumerator);\n };\n Enumerable.repeat = function (element, count) {\n if (count === void 0) { count = Infinity; }\n if (!(count > 0))\n return Enumerable.empty();\n return isFinite(count) && Integer_1.Integer.assert(count, \"count\")\n ? new FiniteEnumerable(function () {\n var c = count;\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () { index = 0; }, function (yielder) { return (index++ < c) && yielder.yieldReturn(element); }, null, false);\n })\n : new Enumerable(function () {\n return new EnumeratorBase_1.EnumeratorBase(null, function (yielder) { return yielder.yieldReturn(element); }, true);\n });\n };\n Enumerable.repeatWithFinalize = function (initializer, finalizer) {\n return new InfiniteEnumerable(function () {\n var element;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n element = initializer();\n }, function (yielder) { return yielder.yieldReturn(element); }, function () {\n finalizer(element);\n }, true);\n });\n };\n Enumerable.make = function (element) {\n return Enumerable.repeat(element, 1);\n };\n Enumerable.range = function (start, count, step) {\n if (step === void 0) { step = 1; }\n if (!isFinite(start))\n throw new ArgumentOutOfRangeException_1.ArgumentOutOfRangeException(\"start\", start, \"Must be a finite number.\");\n if (!(count > 0))\n return Enumerable.empty();\n if (!step)\n throw new ArgumentOutOfRangeException_1.ArgumentOutOfRangeException(\"step\", step, \"Must be a valid value\");\n if (!isFinite(step))\n throw new ArgumentOutOfRangeException_1.ArgumentOutOfRangeException(\"step\", step, \"Must be a finite number.\");\n Integer_1.Integer.assert(count, \"count\");\n return new FiniteEnumerable(function () {\n var value;\n var c = count;\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n index = 0;\n value = start;\n }, function (yielder) {\n var result = index++ < c\n && yielder.yieldReturn(value);\n if (result && index < count)\n value += step;\n return result;\n }, false);\n });\n };\n Enumerable.rangeDown = function (start, count, step) {\n if (step === void 0) { step = 1; }\n step = Math.abs(step) * -1;\n return Enumerable.range(start, count, step);\n };\n Enumerable.toInfinity = function (start, step) {\n if (start === void 0) { start = 0; }\n if (step === void 0) { step = 1; }\n if (!isFinite(start))\n throw new ArgumentOutOfRangeException_1.ArgumentOutOfRangeException(\"start\", start, \"Must be a finite number.\");\n if (!step)\n throw new ArgumentOutOfRangeException_1.ArgumentOutOfRangeException(\"step\", step, \"Must be a valid value\");\n if (!isFinite(step))\n throw new ArgumentOutOfRangeException_1.ArgumentOutOfRangeException(\"step\", step, \"Must be a finite number.\");\n return new InfiniteEnumerable(function () {\n var value;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n value = start;\n }, function (yielder) {\n var current = value;\n value += step;\n return yielder.yieldReturn(current);\n }, true);\n });\n };\n Enumerable.toNegativeInfinity = function (start, step) {\n if (start === void 0) { start = 0; }\n if (step === void 0) { step = 1; }\n return Enumerable.toInfinity(start, -step);\n };\n Enumerable.rangeTo = function (start, to, step) {\n if (step === void 0) { step = 1; }\n if (isNaN(to) || !isFinite(to))\n throw new ArgumentOutOfRangeException_1.ArgumentOutOfRangeException(\"to\", to, \"Must be a finite number.\");\n if (step && !isFinite(step))\n throw new ArgumentOutOfRangeException_1.ArgumentOutOfRangeException(\"step\", step, \"Must be a finite non-zero number.\");\n step = Math.abs(step);\n return new FiniteEnumerable(function () {\n var value;\n return new EnumeratorBase_1.EnumeratorBase(function () { value = start; }, start < to\n ?\n function (yielder) {\n var result = value <= to && yielder.yieldReturn(value);\n if (result)\n value += step;\n return result;\n }\n :\n function (yielder) {\n var result = value >= to && yielder.yieldReturn(value);\n if (result)\n value -= step;\n return result;\n }, false);\n });\n };\n Enumerable.matches = function (input, pattern, flags) {\n if (flags === void 0) { flags = \"\"; }\n if (input === null || input === VOID0)\n throw new ArgumentNullException_1.ArgumentNullException(\"input\");\n var type = typeof input;\n if (type != Types_1.Type.STRING)\n throw new Error(\"Cannot exec RegExp matches of type '\" + type + \"'.\");\n if (pattern instanceof RegExp) {\n flags += (pattern.ignoreCase) ? \"i\" : \"\";\n flags += (pattern.multiline) ? \"m\" : \"\";\n pattern = pattern.source;\n }\n if (flags.indexOf(\"g\") === -1)\n flags += \"g\";\n return new FiniteEnumerable(function () {\n var regex;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n regex = new RegExp(pattern, flags);\n }, function (yielder) {\n var match = regex.exec(input);\n return (match !== null) ? yielder.yieldReturn(match) : false;\n });\n });\n };\n Enumerable.generate = function (factory, count) {\n if (count === void 0) { count = Infinity; }\n if (isNaN(count) || count <= 0)\n return Enumerable.empty();\n return isFinite(count) && Integer_1.Integer.assert(count, \"count\")\n ?\n new FiniteEnumerable(function () {\n var c = count;\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n index = 0;\n }, function (yielder) {\n var current = index++;\n return current < c && yielder.yieldReturn(factory(current));\n }, false);\n })\n :\n new InfiniteEnumerable(function () {\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n index = 0;\n }, function (yielder) { return yielder.yieldReturn(factory(index++)); }, true);\n });\n };\n Enumerable.unfold = function (seed, valueFactory, skipSeed) {\n if (skipSeed === void 0) { skipSeed = false; }\n return new InfiniteEnumerable(function () {\n var index = 0;\n var value;\n var isFirst;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n index = 0;\n value = seed;\n isFirst = !skipSeed;\n }, function (yielder) {\n var i = index++;\n if (isFirst)\n isFirst = false;\n else\n value = valueFactory(value, i);\n return yielder.yieldReturn(value);\n }, true);\n });\n };\n Enumerable.forEach = function (enumerable, action) {\n Enumerator_1.forEach(enumerable, action);\n };\n Enumerable.map = function (enumerable, selector) {\n return Enumerator_1.map(enumerable, selector);\n };\n Enumerable.max = function (values) {\n return values\n .takeUntil(function (v) { return v == +Infinity; }, true)\n .aggregate(Functions.Greater);\n };\n Enumerable.min = function (values) {\n return values\n .takeUntil(function (v) { return v == -Infinity; }, true)\n .aggregate(Functions.Lesser);\n };\n Enumerable.weave = function (enumerables) {\n if (!enumerables)\n throw new ArgumentNullException_1.ArgumentNullException('enumerables');\n return new Enumerable(function () {\n var queue;\n var mainEnumerator;\n var index;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n index = 0;\n queue = new Queue_1.Queue();\n mainEnumerator = Enumerator_1.from(enumerables);\n }, function (yielder) {\n var e;\n if (mainEnumerator) {\n while (!e && mainEnumerator.moveNext()) {\n var c = mainEnumerator.current;\n e = nextEnumerator(queue, c && Enumerator_1.from(c));\n }\n if (!e)\n mainEnumerator = null;\n }\n while (!e && queue.count) {\n e = nextEnumerator(queue, queue.dequeue());\n }\n return e\n ? yielder.yieldReturn(e.current)\n : yielder.yieldBreak();\n }, function () {\n dispose_1.dispose.these(queue.dump());\n dispose_1.dispose(mainEnumerator, queue);\n mainEnumerator = null;\n queue = null;\n });\n });\n };\n Enumerable.prototype.doAction = function (action, initializer, isEndless) {\n if (isEndless === void 0) { isEndless = this.isEndless; }\n return _super.prototype.doAction.call(this, action, initializer, isEndless);\n };\n Enumerable.prototype.skip = function (count) {\n return _super.prototype.skip.call(this, count);\n };\n Enumerable.prototype.skipWhile = function (predicate) {\n this.throwIfDisposed();\n return this.doAction(function (element, index) {\n return predicate(element, index)\n ? 2\n : 1;\n });\n };\n Enumerable.prototype.takeWhile = function (predicate) {\n this.throwIfDisposed();\n if (!predicate)\n throw new ArgumentNullException_1.ArgumentNullException('predicate');\n return this.doAction(function (element, index) {\n return predicate(element, index)\n ? 1\n : 0;\n }, null, null);\n };\n Enumerable.prototype.takeUntil = function (predicate, includeUntilValue) {\n this.throwIfDisposed();\n if (!predicate)\n throw new ArgumentNullException_1.ArgumentNullException('predicate');\n if (!includeUntilValue)\n return this.doAction(function (element, index) {\n return predicate(element, index)\n ? 0\n : 1;\n }, null, null);\n var found = false;\n return this.doAction(function (element, index) {\n if (found)\n return 0;\n found = predicate(element, index);\n return 1;\n }, function () {\n found = false;\n }, null);\n };\n Enumerable.prototype.forEach = function (action) {\n var _ = this;\n _.throwIfDisposed();\n Enumerator_1.throwIfEndless(_.isEndless);\n var index = 0;\n dispose_1.using(_.getEnumerator(), function (e) {\n Enumerator_1.throwIfEndless(e.isEndless);\n while (_.throwIfDisposed() && e.moveNext()) {\n if (action(e.current, index++) === false)\n break;\n }\n });\n };\n Enumerable.prototype.toArray = function (predicate) {\n return predicate\n ? this.where(predicate).toArray()\n : this.copyTo([]);\n };\n Enumerable.prototype.copyTo = function (target, index) {\n if (index === void 0) { index = 0; }\n this.throwIfDisposed();\n if (!target)\n throw new ArgumentNullException_1.ArgumentNullException(\"target\");\n Integer_1.Integer.assertZeroOrGreater(index);\n Enumerator_1.forEach(this, function (x, i) {\n target[i + index] = x;\n });\n return target;\n };\n Enumerable.prototype.toLookup = function (keySelector, elementSelector, compareSelector) {\n if (elementSelector === void 0) { elementSelector = Functions.Identity; }\n if (compareSelector === void 0) { compareSelector = Functions.Identity; }\n var dict = new Dictionary_1.Dictionary(compareSelector);\n this.forEach(function (x) {\n var key = keySelector(x);\n var element = elementSelector(x);\n var array = dict.getValue(key);\n if (array !== VOID0)\n array.push(element);\n else\n dict.addByKeyValue(key, [element]);\n });\n return new Lookup(dict);\n };\n Enumerable.prototype.toMap = function (keySelector, elementSelector) {\n var obj = {};\n this.forEach(function (x, i) {\n obj[keySelector(x, i)] = elementSelector(x, i);\n });\n return obj;\n };\n Enumerable.prototype.toDictionary = function (keySelector, elementSelector, compareSelector) {\n if (compareSelector === void 0) { compareSelector = Functions.Identity; }\n var dict = new Dictionary_1.Dictionary(compareSelector);\n this.forEach(function (x, i) { return dict.addByKeyValue(keySelector(x, i), elementSelector(x, i)); });\n return dict;\n };\n Enumerable.prototype.toJoinedString = function (separator, selector) {\n if (separator === void 0) { separator = \"\"; }\n if (selector === void 0) { selector = Functions.Identity; }\n return this.select(selector).toArray().join(separator);\n };\n Enumerable.prototype.takeExceptLast = function (count) {\n if (count === void 0) { count = 1; }\n var _ = this;\n if (!(count > 0))\n return _;\n if (!isFinite(count))\n return Enumerable.empty();\n Integer_1.Integer.assert(count, \"count\");\n var c = count;\n return new Enumerable(function () {\n var enumerator;\n var q;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n enumerator = _.getEnumerator();\n q = new Queue_1.Queue();\n }, function (yielder) {\n while (enumerator.moveNext()) {\n q.enqueue(enumerator.current);\n if (q.count > c)\n return yielder.yieldReturn(q.dequeue());\n }\n return false;\n }, function () {\n dispose_1.dispose(enumerator, q);\n });\n });\n };\n Enumerable.prototype.skipToLast = function (count) {\n if (!(count > 0))\n return Enumerable.empty();\n var _ = this;\n if (!isFinite(count))\n return _;\n Integer_1.Integer.assert(count, \"count\");\n return _.reverse()\n .take(count)\n .reverse();\n };\n Enumerable.prototype.where = function (predicate) {\n return _super.prototype.where.call(this, predicate);\n };\n Enumerable.prototype.select = function (selector) {\n return _super.prototype.select.call(this, selector);\n };\n Enumerable.prototype.selectMany = function (collectionSelector, resultSelector) {\n return this._selectMany(collectionSelector, resultSelector);\n };\n Enumerable.prototype.choose = function (selector) {\n if (selector === void 0) { selector = Functions.Identity; }\n return this._choose(selector);\n };\n Enumerable.prototype.reverse = function () {\n var _ = this, disposed = !_.throwIfDisposed();\n Enumerator_1.throwIfEndless(_._isEndless);\n return new Enumerable(function () {\n var buffer;\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n throwIfDisposed(disposed);\n buffer = _.toArray();\n index = buffer.length;\n }, function (yielder) { return index && yielder.yieldReturn(buffer[--index]); }, function () {\n buffer.length = 0;\n });\n }, function () {\n disposed = true;\n });\n };\n Enumerable.prototype.shuffle = function () {\n var _ = this, disposed = !_.throwIfDisposed();\n Enumerator_1.throwIfEndless(_._isEndless);\n return new Enumerable(function () {\n var buffer;\n var capacity;\n var len;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n throwIfDisposed(disposed);\n buffer = _.toArray();\n capacity = len = buffer.length;\n }, function (yielder) {\n if (!len)\n return yielder.yieldBreak();\n var selectedIndex = Integer_1.Integer.random(len);\n var selectedValue = buffer[selectedIndex];\n buffer[selectedIndex] = buffer[--len];\n buffer[len] = null;\n if (len % 32 == 0)\n buffer.length = len;\n return yielder.yieldReturn(selectedValue);\n }, function () {\n buffer.length = 0;\n });\n }, function () {\n disposed = true;\n });\n };\n Enumerable.prototype.count = function (predicate) {\n var count = 0;\n this.forEach(predicate\n ?\n function (x, i) {\n if (predicate(x, i))\n ++count;\n }\n :\n function () {\n ++count;\n });\n return count;\n };\n Enumerable.prototype.all = function (predicate) {\n if (!predicate)\n throw new ArgumentNullException_1.ArgumentNullException(\"predicate\");\n var result = true;\n this.forEach(function (x, i) {\n if (!predicate(x, i)) {\n result = false;\n return false;\n }\n });\n return result;\n };\n Enumerable.prototype.every = function (predicate) {\n return this.all(predicate);\n };\n Enumerable.prototype.any = function (predicate) {\n if (!predicate)\n return _super.prototype.any.call(this);\n var result = false;\n this.forEach(function (x, i) {\n result = predicate(x, i);\n return !result;\n });\n return result;\n };\n Enumerable.prototype.some = function (predicate) {\n return this.any(predicate);\n };\n Enumerable.prototype.contains = function (value, compareSelector) {\n return compareSelector\n ? this.any(function (v) { return compareSelector(v) === compareSelector(value); })\n : this.any(function (v) { return v === value; });\n };\n Enumerable.prototype.indexOf = function (value, compareSelector) {\n var found = -1;\n this.forEach(compareSelector\n ?\n function (element, i) {\n if (Values.areEqual(compareSelector(element, i), compareSelector(value, i), true)) {\n found = i;\n return false;\n }\n }\n :\n function (element, i) {\n if (Values.areEqual(element, value, true)) {\n found = i;\n return false;\n }\n });\n return found;\n };\n Enumerable.prototype.lastIndexOf = function (value, compareSelector) {\n var result = -1;\n this.forEach(compareSelector\n ?\n function (element, i) {\n if (Values.areEqual(compareSelector(element, i), compareSelector(value, i), true))\n result\n = i;\n }\n :\n function (element, i) {\n if (Values.areEqual(element, value, true))\n result = i;\n });\n return result;\n };\n Enumerable.prototype.merge = function (enumerables) {\n return _super.prototype.merge.call(this, enumerables);\n };\n Enumerable.prototype.concat = function () {\n var enumerables = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n enumerables[_i - 0] = arguments[_i];\n }\n return this.merge(enumerables);\n };\n Enumerable.prototype.intersect = function (second, compareSelector) {\n var _ = this;\n return new Enumerable(function () {\n var enumerator;\n var keys;\n var outs;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n enumerator = _.getEnumerator();\n keys = new Dictionary_1.Dictionary(compareSelector);\n outs = new Dictionary_1.Dictionary(compareSelector);\n Enumerator_1.forEach(second, function (key) {\n keys.addByKeyValue(key, true);\n });\n }, function (yielder) {\n while (enumerator.moveNext()) {\n var current = enumerator.current;\n if (!outs.containsKey(current) && keys.containsKey(current)) {\n outs.addByKeyValue(current, true);\n return yielder.yieldReturn(current);\n }\n }\n return yielder.yieldBreak();\n }, function () {\n dispose_1.dispose(enumerator, keys, outs);\n }, _._isEndless);\n }, null, _._isEndless);\n };\n Enumerable.prototype.sequenceEqual = function (second, equalityComparer) {\n if (equalityComparer === void 0) { equalityComparer = Values.areEqual; }\n return dispose_1.using(this.getEnumerator(), function (e1) { return dispose_1.using(Enumerator_1.from(second), function (e2) {\n Enumerator_1.throwIfEndless(e1.isEndless && e2.isEndless);\n while (e1.moveNext()) {\n if (!e2.moveNext() || !equalityComparer(e1.current, e2.current))\n return false;\n }\n return !e2.moveNext();\n }); });\n };\n Enumerable.prototype.ofType = function (type) {\n return _super.prototype.ofType.call(this, type);\n };\n Enumerable.prototype.except = function (second, compareSelector) {\n return _super.prototype.except.call(this, second, compareSelector);\n };\n Enumerable.prototype.distinct = function (compareSelector) {\n return _super.prototype.distinct.call(this, compareSelector);\n };\n Enumerable.prototype.distinctUntilChanged = function (compareSelector) {\n if (compareSelector === void 0) { compareSelector = Functions.Identity; }\n return _super.prototype.distinctUntilChanged.call(this, compareSelector);\n };\n Enumerable.prototype.orderBy = function (keySelector) {\n if (keySelector === void 0) { keySelector = Functions.Identity; }\n return new OrderedEnumerable(this, keySelector, 1);\n };\n Enumerable.prototype.orderUsing = function (comparison) {\n return new OrderedEnumerable(this, null, 1, null, comparison);\n };\n Enumerable.prototype.orderUsingReversed = function (comparison) {\n return new OrderedEnumerable(this, null, -1, null, comparison);\n };\n Enumerable.prototype.orderByDescending = function (keySelector) {\n if (keySelector === void 0) { keySelector = Functions.Identity; }\n return new OrderedEnumerable(this, keySelector, -1);\n };\n Enumerable.prototype.buffer = function (size) {\n return _super.prototype.buffer.call(this, size);\n };\n Enumerable.prototype.groupBy = function (keySelector, elementSelector, compareSelector) {\n var _this = this;\n if (!elementSelector)\n elementSelector = Functions.Identity;\n return new Enumerable(function () { return _this.toLookup(keySelector, elementSelector, compareSelector)\n .getEnumerator(); });\n };\n Enumerable.prototype.partitionBy = function (keySelector, elementSelector, resultSelector, compareSelector) {\n if (resultSelector === void 0) { resultSelector = function (key, elements) { return new Grouping(key, elements); }; }\n if (compareSelector === void 0) { compareSelector = Functions.Identity; }\n var _ = this;\n if (!elementSelector)\n elementSelector = Functions.Identity;\n return new Enumerable(function () {\n var enumerator;\n var key;\n var compareKey;\n var group;\n var len;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n enumerator = _.getEnumerator();\n if (enumerator.moveNext()) {\n key = keySelector(enumerator.current);\n compareKey = compareSelector(key);\n group = [elementSelector(enumerator.current)];\n len = 1;\n }\n else\n group = null;\n }, function (yielder) {\n if (!group)\n return yielder.yieldBreak();\n var hasNext, c;\n while ((hasNext = enumerator.moveNext())) {\n c = enumerator.current;\n if (compareKey === compareSelector(keySelector(c)))\n group[len++] = elementSelector(c);\n else\n break;\n }\n var result = resultSelector(key, group);\n if (hasNext) {\n c = enumerator.current;\n key = keySelector(c);\n compareKey = compareSelector(key);\n group = [elementSelector(c)];\n len = 1;\n }\n else {\n group = null;\n }\n return yielder.yieldReturn(result);\n }, function () {\n dispose_1.dispose(enumerator);\n group = null;\n });\n });\n };\n Enumerable.prototype.aggregate = function (func, seed) {\n return this.scan(func, seed).lastOrDefault();\n };\n Enumerable.prototype.average = function (selector) {\n if (selector === void 0) { selector = Types_1.Type.numberOrNaN; }\n var count = 0;\n var sum = this.sum(function (e, i) {\n count++;\n return selector(e, i);\n });\n return (isNaN(sum) || !count)\n ? NaN\n : (sum / count);\n };\n Enumerable.prototype.max = function () {\n return this.aggregate(Functions.Greater);\n };\n Enumerable.prototype.min = function () {\n return this.aggregate(Functions.Lesser);\n };\n Enumerable.prototype.maxBy = function (keySelector) {\n if (keySelector === void 0) { keySelector = Functions.Identity; }\n return this.aggregate(function (a, b) { return (keySelector(a) > keySelector(b)) ? a : b; });\n };\n Enumerable.prototype.minBy = function (keySelector) {\n if (keySelector === void 0) { keySelector = Functions.Identity; }\n return this.aggregate(function (a, b) { return (keySelector(a) < keySelector(b)) ? a : b; });\n };\n Enumerable.prototype.sum = function (selector) {\n if (selector === void 0) { selector = Types_1.Type.numberOrNaN; }\n var sum = 0;\n var sumInfinite = 0;\n this.forEach(function (x) {\n var value = selector(x);\n if (isNaN(value)) {\n sum = NaN;\n return false;\n }\n if (isFinite(value))\n sum += value;\n else\n sumInfinite +=\n value > 0 ?\n (+1) :\n (-1);\n });\n return isNaN(sum) ? NaN : (sumInfinite ? (sumInfinite * Infinity) : sum);\n };\n Enumerable.prototype.product = function (selector) {\n if (selector === void 0) { selector = Types_1.Type.numberOrNaN; }\n var result = 1, exists = false;\n this.forEach(function (x, i) {\n exists = true;\n var value = selector(x, i);\n if (isNaN(value)) {\n result = NaN;\n return false;\n }\n if (value == 0) {\n result = 0;\n return false;\n }\n result *= value;\n });\n return (exists && isNaN(result)) ? NaN : result;\n };\n Enumerable.prototype.quotient = function (selector) {\n if (selector === void 0) { selector = Types_1.Type.numberOrNaN; }\n var count = 0;\n var result = NaN;\n this.forEach(function (x, i) {\n var value = selector(x, i);\n count++;\n if (count === 1) {\n result = value;\n }\n else {\n if (isNaN(value) || value === 0 || !isFinite(value)) {\n result = NaN;\n return false;\n }\n result /= value;\n }\n });\n if (count === 1)\n result = NaN;\n return result;\n };\n Enumerable.prototype.last = function () {\n var _ = this;\n _.throwIfDisposed();\n var value = undefined;\n var found = false;\n _.forEach(function (x) {\n found = true;\n value = x;\n });\n if (!found)\n throw new Error(\"last:No element satisfies the condition.\");\n return value;\n };\n Enumerable.prototype.lastOrDefault = function (defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n var _ = this;\n _.throwIfDisposed();\n var value = undefined;\n var found = false;\n _.forEach(function (x) {\n found = true;\n value = x;\n });\n return (!found) ? defaultValue : value;\n };\n Enumerable.prototype.share = function () {\n return _super.prototype.share.call(this);\n };\n Enumerable.prototype.catchError = function (handler) {\n return _super.prototype.catchError.call(this, handler);\n };\n Enumerable.prototype.finallyAction = function (action) {\n return _super.prototype.finallyAction.call(this, action);\n };\n Enumerable.prototype.memoize = function () {\n var _ = this, disposed = !_.throwIfDisposed();\n var cache;\n var enumerator;\n return new Enumerable(function () {\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n throwIfDisposed(disposed);\n if (!enumerator)\n enumerator = _.getEnumerator();\n if (!cache)\n cache = [];\n index = 0;\n }, function (yielder) {\n throwIfDisposed(disposed);\n var i = index++;\n if (i >= cache.length) {\n return (enumerator.moveNext())\n ? yielder.yieldReturn(cache[i] = enumerator.current)\n : false;\n }\n return yielder.yieldReturn(cache[i]);\n });\n }, function () {\n disposed = true;\n if (cache)\n cache.length = 0;\n cache = null;\n dispose_1.dispose(enumerator);\n enumerator = null;\n });\n };\n return Enumerable;\n }(InfiniteEnumerable));\n exports.Enumerable = Enumerable;\n var FiniteEnumerable = (function (_super) {\n __extends(FiniteEnumerable, _super);\n function FiniteEnumerable(enumeratorFactory, finalizer) {\n _super.call(this, enumeratorFactory, finalizer, false);\n }\n return FiniteEnumerable;\n }(Enumerable));\n exports.FiniteEnumerable = FiniteEnumerable;\n var ArrayEnumerable = (function (_super) {\n __extends(ArrayEnumerable, _super);\n function ArrayEnumerable(source) {\n _super.call(this, function () {\n _.throwIfDisposed();\n return new ArrayEnumerator_1.ArrayEnumerator(function () {\n _.throwIfDisposed(\"The underlying ArrayEnumerable was disposed.\", \"ArrayEnumerator\");\n return _._source;\n });\n });\n var _ = this;\n _._disposableObjectName = \"ArrayEnumerable\";\n _._source = source;\n }\n ArrayEnumerable.prototype._onDispose = function () {\n _super.prototype._onDispose.call(this);\n this._source = null;\n };\n Object.defineProperty(ArrayEnumerable.prototype, \"source\", {\n get: function () {\n return this._source;\n },\n enumerable: true,\n configurable: true\n });\n ArrayEnumerable.prototype.toArray = function () {\n var _ = this;\n _.throwIfDisposed();\n return Enumerator_1.toArray(_._source);\n };\n ArrayEnumerable.prototype.asEnumerable = function () {\n return new ArrayEnumerable(this._source);\n };\n ArrayEnumerable.prototype.forEach = function (action) {\n var _ = this;\n _.throwIfDisposed();\n Enumerator_1.forEach(_._source, action);\n };\n ArrayEnumerable.prototype.any = function (predicate) {\n var _ = this;\n _.throwIfDisposed();\n var source = _._source, len = source.length;\n return len && (!predicate || _super.prototype.any.call(this, predicate));\n };\n ArrayEnumerable.prototype.count = function (predicate) {\n var _ = this;\n _.throwIfDisposed();\n var source = _._source, len = source.length;\n return len && (predicate ? _super.prototype.count.call(this, predicate) : len);\n };\n ArrayEnumerable.prototype.elementAtOrDefault = function (index, defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n var _ = this;\n _.throwIfDisposed();\n Integer_1.Integer.assertZeroOrGreater(index, 'index');\n var source = _._source;\n return index < source.length\n ? source[index]\n : defaultValue;\n };\n ArrayEnumerable.prototype.last = function () {\n var _ = this;\n _.throwIfDisposed();\n var source = _._source, len = source.length;\n return (len)\n ? source[len - 1]\n : _super.prototype.last.call(this);\n };\n ArrayEnumerable.prototype.lastOrDefault = function (defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n var _ = this;\n _.throwIfDisposed();\n var source = _._source, len = source.length;\n return len\n ? source[len - 1]\n : defaultValue;\n };\n ArrayEnumerable.prototype.skip = function (count) {\n var _ = this;\n if (!(count > 0))\n return _;\n return new Enumerable(function () { return new ArrayEnumerator_1.ArrayEnumerator(function () { return _._source; }, count); });\n };\n ArrayEnumerable.prototype.takeExceptLast = function (count) {\n if (count === void 0) { count = 1; }\n var _ = this;\n return _.take(_._source.length - count);\n };\n ArrayEnumerable.prototype.skipToLast = function (count) {\n if (!(count > 0))\n return Enumerable.empty();\n var _ = this;\n if (!isFinite(count))\n return _;\n var len = _._source\n ? _._source.length\n : 0;\n return _.skip(len - count);\n };\n ArrayEnumerable.prototype.reverse = function () {\n var _ = this;\n return new Enumerable(function () { return new ArrayEnumerator_1.ArrayEnumerator(function () { return _._source; }, _._source\n ? (_._source.length - 1)\n : 0, -1); });\n };\n ArrayEnumerable.prototype.memoize = function () {\n return this.asEnumerable();\n };\n ArrayEnumerable.prototype.sequenceEqual = function (second, equalityComparer) {\n if (equalityComparer === void 0) { equalityComparer = Values.areEqual; }\n if (Types_1.Type.isArrayLike(second))\n return Arrays.areEqual(this.source, second, true, equalityComparer);\n if (second instanceof ArrayEnumerable)\n return second.sequenceEqual(this.source, equalityComparer);\n return _super.prototype.sequenceEqual.call(this, second, equalityComparer);\n };\n ArrayEnumerable.prototype.toJoinedString = function (separator, selector) {\n if (separator === void 0) { separator = \"\"; }\n if (selector === void 0) { selector = Functions.Identity; }\n var s = this._source;\n return !selector && Array.isArray(s)\n ? s.join(separator)\n : _super.prototype.toJoinedString.call(this, separator, selector);\n };\n return ArrayEnumerable;\n }(FiniteEnumerable));\n var Grouping = (function (_super) {\n __extends(Grouping, _super);\n function Grouping(_groupKey, elements) {\n _super.call(this, elements);\n this._groupKey = _groupKey;\n }\n Object.defineProperty(Grouping.prototype, \"key\", {\n get: function () {\n return this._groupKey;\n },\n enumerable: true,\n configurable: true\n });\n return Grouping;\n }(ArrayEnumerable));\n var Lookup = (function () {\n function Lookup(_dictionary) {\n this._dictionary = _dictionary;\n }\n Object.defineProperty(Lookup.prototype, \"count\", {\n get: function () {\n return this._dictionary.count;\n },\n enumerable: true,\n configurable: true\n });\n Lookup.prototype.get = function (key) {\n return this._dictionary.getValue(key);\n };\n Lookup.prototype.contains = function (key) {\n return this._dictionary.containsKey(key);\n };\n Lookup.prototype.getEnumerator = function () {\n var _ = this;\n var enumerator;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n enumerator = _._dictionary.getEnumerator();\n }, function (yielder) {\n if (!enumerator.moveNext())\n return false;\n var current = enumerator.current;\n return yielder.yieldReturn(new Grouping(current.key, current.value));\n }, function () {\n dispose_1.dispose(enumerator);\n });\n };\n return Lookup;\n }());\n var OrderedEnumerable = (function (_super) {\n __extends(OrderedEnumerable, _super);\n function OrderedEnumerable(source, keySelector, order, parent, comparer) {\n if (comparer === void 0) { comparer = Values.compare; }\n _super.call(this, null);\n this.source = source;\n this.keySelector = keySelector;\n this.order = order;\n this.parent = parent;\n this.comparer = comparer;\n Enumerator_1.throwIfEndless(source && source.isEndless);\n }\n OrderedEnumerable.prototype.createOrderedEnumerable = function (keySelector, order) {\n return new OrderedEnumerable(this.source, keySelector, order, this);\n };\n OrderedEnumerable.prototype.thenBy = function (keySelector) {\n return this.createOrderedEnumerable(keySelector, 1);\n };\n OrderedEnumerable.prototype.thenUsing = function (comparison) {\n return new OrderedEnumerable(this.source, null, 1, this, comparison);\n };\n OrderedEnumerable.prototype.thenByDescending = function (keySelector) {\n return this.createOrderedEnumerable(keySelector, -1);\n };\n OrderedEnumerable.prototype.thenUsingReversed = function (comparison) {\n return new OrderedEnumerable(this.source, null, -1, this, comparison);\n };\n OrderedEnumerable.prototype.getEnumerator = function () {\n var _ = this;\n var buffer;\n var indexes;\n var index = 0;\n return new EnumeratorBase_1.EnumeratorBase(function () {\n index = 0;\n buffer = Enumerable.toArray(_.source);\n indexes = createSortContext(_).generateSortedIndexes(buffer);\n }, function (yielder) {\n return (index < indexes.length)\n ? yielder.yieldReturn(buffer[indexes[index++]])\n : false;\n }, function () {\n if (buffer)\n buffer.length = 0;\n buffer = null;\n if (indexes)\n indexes.length = 0;\n indexes = null;\n }, false);\n };\n OrderedEnumerable.prototype._onDispose = function () {\n _super.prototype._onDispose.call(this);\n this.source = null;\n this.keySelector = null;\n this.order = null;\n this.parent = null;\n };\n return OrderedEnumerable;\n }(FiniteEnumerable));\n function nextEnumerator(queue, e) {\n if (e) {\n if (e.moveNext()) {\n queue.enqueue(e);\n }\n else {\n dispose_1.dispose(e);\n e = null;\n }\n }\n return e;\n }\n function createSortContext(orderedEnumerable, currentContext) {\n if (currentContext === void 0) { currentContext = null; }\n var context = new KeySortedContext_1.KeySortedContext(currentContext, orderedEnumerable.keySelector, orderedEnumerable.order, orderedEnumerable.comparer);\n if (orderedEnumerable.parent)\n return createSortContext(orderedEnumerable.parent, context);\n return context;\n }\n function throwIfDisposed(disposed) {\n if (disposed)\n throw new ObjectDisposedException_1.ObjectDisposedException(\"Enumerable\");\n }\n Object.defineProperty(exports, \"__esModule\", { value: true });\n exports.default = Enumerable;\n});\n","/*!\r\n * @author electricessence / https://github.com/electricessence/\r\n * Original: http://linqjs.codeplex.com/\r\n * Licensing: MIT https://github.com/electricessence/TypeScript.NET/blob/master/LICENSE.md\r\n */\r\n\r\n\r\nimport * as Values from \"../System/Compare\";\r\nimport * as Arrays from \"../System/Collections/Array/Compare\";\r\nimport * as ArrayUtility from \"../System/Collections/Array/Utility\";\r\nimport {\r\n\tempty as EmptyEnumerator,\r\n\tfrom as enumeratorFrom,\r\n\tforEach,\r\n\ttoArray,\r\n\tmap,\r\n\tisEnumerable,\r\n\tthrowIfEndless\r\n} from \"../System/Collections/Enumeration/Enumerator\";\r\nimport {Type} from \"../System/Types\";\r\nimport {Integer} from \"../System/Integer\";\r\nimport {Functions as BaseFunctions} from \"../System/Functions\";\r\nimport {ArrayEnumerator} from \"../System/Collections/Enumeration/ArrayEnumerator\";\r\nimport {EnumeratorBase} from \"../System/Collections/Enumeration/EnumeratorBase\";\r\nimport {Dictionary} from \"../System/Collections/Dictionaries/Dictionary\";\r\nimport {Queue} from \"../System/Collections/Queue\";\r\nimport {dispose, using} from \"../System/Disposable/dispose\";\r\nimport {DisposableBase} from \"../System/Disposable/DisposableBase\";\r\nimport {UnsupportedEnumerableException} from \"../System/Collections/Enumeration/UnsupportedEnumerableException\";\r\nimport {ObjectDisposedException} from \"../System/Disposable/ObjectDisposedException\";\r\nimport {KeySortedContext} from \"../System/Collections/Sorting/KeySortedContext\";\r\nimport {ArgumentNullException} from \"../System/Exceptions/ArgumentNullException\";\r\nimport {ArgumentOutOfRangeException} from \"../System/Exceptions/ArgumentOutOfRangeException\";\r\nimport {IEnumerator} from \"../System/Collections/Enumeration/IEnumerator\";\r\nimport {IEnumerable} from \"../System/Collections/Enumeration/IEnumerable\";\r\nimport {Action, Predicate, Selector, EqualityComparison, Comparison} from \"../System/FunctionTypes\";\r\nimport {IEnumerableOrArray} from \"../System/Collections/IEnumerableOrArray\";\r\nimport {IArray} from \"../System/Collections/Array/IArray\";\r\nimport {IMap} from \"../System/Collections/Dictionaries/IDictionary\";\r\nimport {Comparable} from \"../System/IComparable\";\r\nimport {IComparer} from \"../System/IComparer\";\r\nimport {IKeyValuePair} from \"../System/KeyValuePair\";\r\nimport {Order} from \"../System/Collections/Sorting/Order\";\r\n\r\n// #region Local Constants.\r\n\r\nconst INVALID_DEFAULT:any = {}; // create a private unique instance for referencing.\r\nconst VOID0:any = void 0;\r\nconst BREAK:(e:any)=>EnumerableAction = element => EnumerableAction.Break;\r\n\r\n// Leave internal to avoid accidental overwriting.\r\nclass LinqFunctions extends BaseFunctions\r\n{\r\n\tGreater<T>(a:T, b:T)\r\n\t{\r\n\t\treturn a>b ? a : b;\r\n\t}\r\n\r\n\tLesser<T>(a:T, b:T)\r\n\t{\r\n\t\treturn a<b ? a : b;\r\n\t}\r\n}\r\n\r\nvar Functions = new LinqFunctions();\r\nObject.freeze(Functions);\r\n\r\n// For re-use as a factory.\r\nfunction getEmptyEnumerator():IEnumerator<any>\r\n{\r\n\treturn EmptyEnumerator;\r\n}\r\n\r\n// #endregion\r\n\r\n/**\r\n * Defined values for doAction.\r\n */\r\nexport const enum EnumerableAction\r\n{\r\n\tBreak = 0,\r\n\tReturn = 1,\r\n\tSkip = 2\r\n}\r\n\r\n/*\r\n * NOTE: About InfiniteEnumerable<T> and Enumerable<T>.\r\n * There may seem like there's extra overrides here and they may seem unnecessary.\r\n * But after closer inspection you'll see the type chain is retained and\r\n * infinite enumerables are prevented from having features that finite ones have.\r\n *\r\n * I'm not sure if it's the best option to just use overrides, but it honors the typing properly.\r\n */\r\n\r\nexport class InfiniteEnumerable<T>\r\nextends DisposableBase implements IEnumerable<T>\r\n{\r\n\tconstructor(\r\n\t\tprotected _enumeratorFactory:() => IEnumerator<T>,\r\n\t\tfinalizer?:() => void)\r\n\t{\r\n\t\tsuper(finalizer);\r\n\t\tthis._isEndless = true;\r\n\t}\r\n\r\n\tprotected _isEndless:boolean;\r\n\tget isEndless():boolean\r\n\t{\r\n\t\treturn this._isEndless;\r\n\t}\r\n\r\n\t// #region IEnumerable<T> Implementation...\r\n\tgetEnumerator():IEnumerator<T>\r\n\t{\r\n\r\n\t\tthis.throwIfDisposed();\r\n\r\n\t\treturn this._enumeratorFactory();\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\t// #region IDisposable override...\r\n\tprotected _onDispose():void\r\n\t{\r\n\t\tsuper._onDispose(); // Just in case.\r\n\t\tthis._enumeratorFactory = null;\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\t// Return a default (unfiltered) enumerable.\r\n\tasEnumerable():InfiniteEnumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\t\treturn new InfiniteEnumerable<T>(() => _.getEnumerator());\r\n\t}\r\n\r\n\r\n\t/**\r\n\t * Similar to forEach, but executes an action for each time a value is enumerated.\r\n\t * If the action explicitly returns false or 0 (EnumerationAction.Break), the enumeration will complete.\r\n\t * If it returns a 2 (EnumerationAction.Skip) it will move on to the next item.\r\n\t * This also automatically handles disposing the enumerator.\r\n\t */\r\n\tdoAction(\r\n\t\taction:Action<T> | Predicate<T> | Selector<T, number> | Selector<T, EnumerableAction>,\r\n\t\tinitializer?:()=>void,\r\n\t\tisEndless:boolean = this.isEndless):InfiniteEnumerable<T>\r\n\t{\r\n\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\tif(initializer) initializer();\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\t// May need a way to propagate isEndless\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tvar actionResult = <any>action(enumerator.current, index++);\r\n\r\n\t\t\t\t\t\t\tif(actionResult===false || actionResult===EnumerableAction.Break)\r\n\t\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\r\n\t\t\t\t\t\t\tif(actionResult!==EnumerableAction.Skip) // || !== 2\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(enumerator.current);\r\n\r\n\t\t\t\t\t\t\t// If actionResult===2, then a signal for skip is received.\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\tisEndless\r\n\t\t\t\t);\r\n\r\n\t\t\t},\r\n\t\t\t// Using a finalizer value reduces the chance of a circular reference\r\n\t\t\t// since we could simply reference the enumeration and check e.wasDisposed.\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t},\r\n\r\n\t\t\tisEndless\r\n\t\t);\r\n\t}\r\n\r\n\r\n\tforce():void\r\n\t{\r\n\t\tthis.throwIfDisposed();\r\n\t\tthis.doAction(BREAK)\r\n\t\t\t.getEnumerator()\r\n\t\t\t.moveNext();\r\n\r\n\t}\r\n\r\n\t// #region Indexing/Paging methods.\r\n\tskip(count:number):InfiniteEnumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tif(!isFinite(count)) // +Infinity equals skip all so return empty.\r\n\t\t\treturn Enumerable.empty<T>();\r\n\r\n\t\tInteger.assert(count, \"count\");\r\n\r\n\t\treturn this.doAction(\r\n\t\t\t(element:T, index?:number) =>\r\n\t\t\t\tindex<count\r\n\t\t\t\t\t? EnumerableAction.Skip\r\n\t\t\t\t\t: EnumerableAction.Return\r\n\t\t);\r\n\t}\r\n\r\n\r\n\ttake(count:number):FiniteEnumerable<T>\r\n\t{\r\n\t\tif(!(count>0)) // Out of bounds? Empty.\r\n\t\t\treturn Enumerable.empty<T>();\r\n\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tif(!isFinite(count))\r\n\t\t\tthrow new ArgumentOutOfRangeException('count', count, 'Must be finite.');\r\n\r\n\t\tInteger.assert(count, \"count\");\r\n\r\n\t\t// Once action returns false, the enumeration will stop.\r\n\t\treturn <Enumerable<T>>_.doAction((element:T, index?:number) => index<count, null, false);\r\n\t}\r\n\r\n\t// #region Single Value Return...\r\n\r\n\telementAt(index:number):T\r\n\t{\r\n\t\tvar v = this.elementAtOrDefault(index, INVALID_DEFAULT);\r\n\t\tif(v===INVALID_DEFAULT) throw new ArgumentOutOfRangeException('index', index, \"is greater than or equal to the number of elements in source\");\r\n\t\treturn v;\r\n\t}\r\n\r\n\telementAtOrDefault(index:number, defaultValue:T = null):T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tInteger.assertZeroOrGreater(index, 'index');\r\n\t\tvar n:number = index;\r\n\r\n\t\treturn using(\r\n\t\t\tthis.getEnumerator(),\r\n\t\t\te=>\r\n\t\t\t{\r\n\t\t\t\tvar i = 0;\r\n\t\t\t\twhile(e.moveNext())\r\n\t\t\t\t{\r\n\t\t\t\t\tif(i==n) return e.current;\r\n\t\t\t\t\ti++;\r\n\t\t\t\t}\r\n\r\n\t\t\t\treturn defaultValue;\r\n\t\t\t});\r\n\t}\r\n\r\n\t/* Note: Unlike previous implementations, you could pass a predicate into these methods.\r\n\t * But since under the hood it ends up calling .where(predicate) anyway,\r\n\t * it may be better to remove this to allow for a cleaner signature/override.\r\n\t * JavaScript/TypeScript does not easily allow for a strict method interface like C#.\r\n\t * Having to write extra override logic is error prone and confusing to the consumer.\r\n\t * Removing the predicate here may also cause the consumer of this method to think more about how they structure their query.\r\n\t * The end all difference is that the user must declare .where(predicate) before .first(), .single(), or .last().\r\n\t * */\r\n\r\n\tfirst():T\r\n\t{\r\n\t\tvar v = this.firstOrDefault(INVALID_DEFAULT);\r\n\t\tif(v===INVALID_DEFAULT) throw new Error(\"first:The sequence is empty.\");\r\n\t\treturn v;\r\n\t}\r\n\r\n\tfirstOrDefault(defaultValue:T = null):T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\treturn using(\r\n\t\t\tthis.getEnumerator(),\r\n\t\t\te=> e.moveNext() ? e.current : defaultValue\r\n\t\t);\r\n\t}\r\n\r\n\r\n\tsingle():T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\treturn using(\r\n\t\t\tthis.getEnumerator(),\r\n\t\t\te=>\r\n\t\t\t{\r\n\t\t\t\tif(e.moveNext())\r\n\t\t\t\t{\r\n\t\t\t\t\tvar value = e.current;\r\n\t\t\t\t\tif(!e.moveNext()) return value;\r\n\t\t\t\t\tthrow new Error(\"single:sequence contains more than one element.\");\r\n\t\t\t\t}\r\n\t\t\t\tthrow new Error(\"single:The sequence is empty.\");\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tsingleOrDefault(defaultValue:T = null):T\r\n\t{\r\n\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\treturn using(\r\n\t\t\tthis.getEnumerator(),\r\n\t\t\te=>\r\n\t\t\t{\r\n\t\t\t\tif(e.moveNext())\r\n\t\t\t\t{\r\n\t\t\t\t\tvar value = e.current;\r\n\t\t\t\t\tif(!e.moveNext()) return value;\r\n\t\t\t\t}\r\n\t\t\t\treturn defaultValue;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tany():boolean\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\treturn using(\r\n\t\t\tthis.getEnumerator(),\r\n\t\t\te=> e.moveNext()\r\n\t\t);\r\n\t}\r\n\r\n\tisEmpty():boolean\r\n\t{\r\n\t\treturn !this.any();\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\r\n\t// #region Projection and Filtering Methods\r\n\r\n\ttraverseBreadthFirst(\r\n\t\tchildrenSelector:(element:T) => IEnumerableOrArray<T>):Enumerable<T>;\r\n\r\n\ttraverseBreadthFirst<TNode>(\r\n\t\tchildrenSelector:(element:T|TNode) => IEnumerableOrArray<TNode>):Enumerable<TNode>;\r\n\r\n\ttraverseBreadthFirst<TResult>(\r\n\t\tchildrenSelector:(element:T) => IEnumerableOrArray<T>,\r\n\t\tresultSelector?:(element:T, nestLevel?:number) => TResult):Enumerable<TResult>;\r\n\r\n\ttraverseBreadthFirst<TNode, TResult>(\r\n\t\tchildrenSelector:(element:T|TNode) => IEnumerableOrArray<TNode>,\r\n\t\tresultSelector?:(element:TNode, nestLevel?:number) => TResult):Enumerable<TResult>;\r\n\r\n\ttraverseBreadthFirst<TNode>(\r\n\t\tchildrenSelector:(element:T|TNode) => IEnumerableOrArray<TNode>,\r\n\t\tresultSelector:(\r\n\t\t\telement:TNode,\r\n\t\t\tnestLevel?:number) => any = Functions.Identity):Enumerable<any>\r\n\t{\r\n\t\tvar _ = this, isEndless = _._isEndless || null; // Is endless is not affirmative if false.\r\n\r\n\r\n\t\treturn new Enumerable<any>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<any>;\r\n\t\t\t\tvar nestLevel:number = 0;\r\n\t\t\t\tvar buffer:any[], len:number;\r\n\r\n\t\t\t\treturn new EnumeratorBase<any>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tnestLevel = 0;\r\n\t\t\t\t\t\tbuffer = [];\r\n\t\t\t\t\t\tlen = 0;\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\twhile(true)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tif(enumerator.moveNext())\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tbuffer[len++] = enumerator.current;\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(resultSelector(enumerator.current, nestLevel));\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tif(!len)\r\n\t\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\r\n\t\t\t\t\t\t\tvar next = Enumerable\r\n\t\t\t\t\t\t\t\t.from(buffer)\r\n\t\t\t\t\t\t\t\t.selectMany(childrenSelector);\r\n\r\n\t\t\t\t\t\t\tif(!next.any())\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tnestLevel++;\r\n\t\t\t\t\t\t\t\tbuffer = [];\r\n\t\t\t\t\t\t\t\tlen = 0;\r\n\t\t\t\t\t\t\t\tenumerator.dispose();\r\n\t\t\t\t\t\t\t\tenumerator = next.getEnumerator();\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t\tbuffer.length = 0;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\tisEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\t\t\tnull,\r\n\r\n\t\t\tisEndless\r\n\t\t);\r\n\t}\r\n\r\n\r\n\ttraverseDepthFirst(\r\n\t\tchildrenSelector:(element:T) => IEnumerableOrArray<T>):Enumerable<T>;\r\n\r\n\ttraverseDepthFirst<TNode>(\r\n\t\tchildrenSelector:(element:T|TNode) => IEnumerableOrArray<TNode>):Enumerable<TNode>;\r\n\r\n\ttraverseDepthFirst<TResult>(\r\n\t\tchildrenSelector:(element:T) => IEnumerableOrArray<T>,\r\n\t\tresultSelector?:(element:T, nestLevel?:number) => TResult):Enumerable<TResult>;\r\n\r\n\ttraverseDepthFirst<TNode, TResult>(\r\n\t\tchildrenSelector:(element:T|TNode) => IEnumerableOrArray<TNode>,\r\n\t\tresultSelector?:(element:TNode, nestLevel?:number) => TResult):Enumerable<TResult>;\r\n\r\n\ttraverseDepthFirst<TNode>(\r\n\t\tchildrenSelector:(element:T|TNode) => IEnumerableOrArray<TNode>,\r\n\t\tresultSelector:(\r\n\t\t\telement:TNode,\r\n\t\t\tnestLevel?:number) => any = Functions.Identity):Enumerable<any>\r\n\t{\r\n\t\tvar _ = this, isEndless = _._isEndless || null; // Is endless is not affirmative if false.\r\n\r\n\t\treturn new Enumerable<any>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\t// Dev Note: May want to consider using an actual stack and not an array.\r\n\t\t\t\tvar enumeratorStack:IEnumerator<any>[] = [];\r\n\t\t\t\tvar enumerator:IEnumerator<any>;\r\n\t\t\t\tvar len:number; // Avoid using push/pop since they query .length every time and can be slower.\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tlen = 0;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\twhile(true)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tif(enumerator.moveNext())\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tlet value = resultSelector(enumerator.current, len);\r\n\t\t\t\t\t\t\t\tenumeratorStack[len++] = enumerator;\r\n\t\t\t\t\t\t\t\tlet e = Enumerable.fromAny<any>(childrenSelector(enumerator.current));\r\n\t\t\t\t\t\t\t\tenumerator = e ? e.getEnumerator() : EmptyEnumerator;\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(value);\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tif(len==0) return false;\r\n\r\n\t\t\t\t\t\t\tenumerator.dispose();\r\n\t\t\t\t\t\t\tenumerator = enumeratorStack[--len];\r\n\t\t\t\t\t\t\tenumeratorStack.length = len;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\ttry\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tfinally\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tdispose.these(enumeratorStack);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\tisEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\t\t\tnull,\r\n\t\t\tisEndless\r\n\t\t);\r\n\t}\r\n\r\n\r\n\tflatten():Enumerable<any>\r\n\t{\r\n\t\tvar _ = this, isEndless = _._isEndless || null; // Is endless is not affirmative if false.;\r\n\r\n\t\treturn new Enumerable<any>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<any>;\r\n\t\t\t\tvar middleEnumerator:IEnumerator<any> = null;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\twhile(true)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tif(middleEnumerator)\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tif(middleEnumerator.moveNext())\r\n\t\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\t\treturn yielder.yieldReturn(middleEnumerator.current);\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\t\tmiddleEnumerator.dispose();\r\n\t\t\t\t\t\t\t\t\tmiddleEnumerator = null;\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tif(enumerator.moveNext())\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tvar c = enumerator.current;\r\n\t\t\t\t\t\t\t\t// Because strings are enumerable, we can get stuck in an infinite loop.\r\n\t\t\t\t\t\t\t\t// Treat strings as primitives here.\r\n\t\t\t\t\t\t\t\tvar e = !Type.isString(c) && Enumerable.fromAny(c);\r\n\t\t\t\t\t\t\t\tif(e)\r\n\t\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\t\tmiddleEnumerator\r\n\t\t\t\t\t\t\t\t\t\t= e\r\n\t\t\t\t\t\t\t\t\t\t.selectMany(Functions.Identity)\r\n\t\t\t\t\t\t\t\t\t\t.flatten()\r\n\t\t\t\t\t\t\t\t\t\t.getEnumerator();\r\n\t\t\t\t\t\t\t\t\tcontinue;\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\t\treturn yielder.yieldReturn(c);\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator, middleEnumerator);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\tisEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\t\t\tnull,\r\n\t\t\tisEndless\r\n\t\t);\r\n\t}\r\n\r\n\r\n\tpairwise<TSelect>(selector:(prev:T, current:T) => TSelect):Enumerable<TSelect>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<TSelect>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TSelect>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tenumerator.moveNext();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar prev = enumerator.current;\r\n\t\t\t\t\t\treturn enumerator.moveNext()\r\n\t\t\t\t\t\t\t&& yielder.yieldReturn(selector(prev, enumerator.current));\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t_._isEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\t\t\tnull,\r\n\r\n\t\t\t_._isEndless\r\n\t\t);\r\n\t}\r\n\r\n\tscan(func:(a:T, b:T) => T, seed?:T):Enumerable<T>\r\n\t{\r\n\r\n\t\tvar isUseSeed = seed!==VOID0; // For now...\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar value:T;\r\n\t\t\t\tvar isFirst:boolean;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tisFirst = true;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tif(isFirst)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tisFirst = false;\r\n\t\t\t\t\t\t\t//noinspection JSUnusedAssignment\r\n\t\t\t\t\t\t\treturn isUseSeed\r\n\t\t\t\t\t\t\t\t? yielder.yieldReturn(value = seed)\r\n\t\t\t\t\t\t\t\t: enumerator.moveNext() && yielder.yieldReturn(value\r\n\t\t\t\t\t\t\t\t= enumerator.current);\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\treturn (enumerator.moveNext())\r\n\t\t\t\t\t\t\t? yielder.yieldReturn(value = func(value, enumerator.current))\r\n\t\t\t\t\t\t\t: false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t_._isEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\t\t\tnull,\r\n\r\n\t\t\t_._isEndless\r\n\t\t);\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\tselect<TResult>(selector:Selector<T, TResult>):InfiniteEnumerable<TResult>\r\n\t{\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<TResult>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TResult>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\treturn enumerator.moveNext()\r\n\t\t\t\t\t\t\t? yielder.yieldReturn(selector(enumerator.current, index++))\r\n\t\t\t\t\t\t\t: yielder.yieldBreak();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t_._isEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t},\r\n\r\n\t\t\t_._isEndless\r\n\t\t);\r\n\t}\r\n\r\n\t/*\r\n\tpublic static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(\r\n\t\tthis IEnumerable<TSource> source,\r\n\t\tFunc<TSource, IEnumerable<TCollection>> collectionSelector,\r\n\t\tFunc<TSource, TCollection, TResult> resultSelector)\r\n\t */\r\n\r\n\tprotected _selectMany<TElement, TResult>(\r\n\t\tcollectionSelector:Selector<T, IEnumerableOrArray<TElement>>,\r\n\t\tresultSelector?:(collection:T, element:TElement) => TResult):Enumerable<TResult>\r\n\t{\r\n\t\tvar _ = this, isEndless = _._isEndless || null; // Do second enumeration, it will be indeterminate if false.\r\n\t\tif(!resultSelector)\r\n\t\t\tresultSelector = (a:T, b:any) => <TResult>b;\r\n\r\n\t\treturn new Enumerable<TResult>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar middleEnumerator:IEnumerator<any>;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TResult>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tmiddleEnumerator = undefined;\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\r\n\t\t\t\t\t\t// Just started, and nothing to enumerate? End.\r\n\t\t\t\t\t\tif(middleEnumerator===VOID0 && !enumerator.moveNext())\r\n\t\t\t\t\t\t\treturn false;\r\n\r\n\t\t\t\t\t\t// moveNext has been called at least once...\r\n\t\t\t\t\t\tdo\r\n\t\t\t\t\t\t{\r\n\r\n\t\t\t\t\t\t\t// Initialize middle if there isn't one.\r\n\t\t\t\t\t\t\tif(!middleEnumerator)\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tvar middleSeq = collectionSelector(enumerator.current, index++);\r\n\r\n\t\t\t\t\t\t\t\t// Collection is null? Skip it...\r\n\t\t\t\t\t\t\t\tif(!middleSeq)\r\n\t\t\t\t\t\t\t\t\tcontinue;\r\n\r\n\t\t\t\t\t\t\t\tmiddleEnumerator = enumeratorFrom(middleSeq);\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tif(middleEnumerator.moveNext())\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(\r\n\t\t\t\t\t\t\t\t\tresultSelector(\r\n\t\t\t\t\t\t\t\t\t\tenumerator.current, middleEnumerator.current\r\n\t\t\t\t\t\t\t\t\t)\r\n\t\t\t\t\t\t\t\t);\r\n\r\n\t\t\t\t\t\t\t// else no more in this middle? Then clear and reset for next...\r\n\r\n\t\t\t\t\t\t\tmiddleEnumerator.dispose();\r\n\t\t\t\t\t\t\tmiddleEnumerator = null;\r\n\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\twhile(enumerator.moveNext());\r\n\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator, middleEnumerator);\r\n\t\t\t\t\t\tenumerator = null;\r\n\t\t\t\t\t\tmiddleEnumerator = null;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\tisEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\t\t\tnull,\r\n\r\n\t\t\tisEndless\r\n\t\t);\r\n\t}\r\n\r\n\tselectMany<TResult>(\r\n\t\tcollectionSelector:Selector<T, IEnumerableOrArray<TResult>>):InfiniteEnumerable<TResult>;\r\n\r\n\tselectMany<TElement, TResult>(\r\n\t\tcollectionSelector:Selector<T, IEnumerableOrArray<TElement>>,\r\n\t\tresultSelector:(collection:T, element:TElement) => TResult):InfiniteEnumerable<TResult>;\r\n\r\n\tselectMany<TResult>(\r\n\t\tcollectionSelector:Selector<T, IEnumerableOrArray<any>>,\r\n\t\tresultSelector?:(collection:T, element:any) => TResult):InfiniteEnumerable<TResult>\r\n\t{\r\n\t\treturn this._selectMany(collectionSelector, resultSelector);\r\n\t}\r\n\r\n\tprotected _choose<TResult>(selector:Selector<T, TResult>):Enumerable<TResult>\r\n\t{\r\n\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<TResult>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TResult>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tvar result = selector(enumerator.current, index++);\r\n\t\t\t\t\t\t\tif(result!==null && result!==VOID0)\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(result);\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t_._isEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t},\r\n\r\n\t\t\t_._isEndless\r\n\t\t);\r\n\t}\r\n\r\n\t/**\r\n\t * Returns selected values that are not null or undefined.\r\n\t */\r\n\tchoose():InfiniteEnumerable<T>;\r\n\tchoose<TResult>(selector?:Selector<T, TResult>):InfiniteEnumerable<TResult>\r\n\tchoose(selector:Selector<T, any> = Functions.Identity):InfiniteEnumerable<any>\r\n\t{\r\n\t\treturn this._choose(selector)\r\n\t}\r\n\r\n\twhere(predicate:Predicate<T>):InfiniteEnumerable<T>\r\n\t{\r\n\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tif(predicate(enumerator.current, index++))\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(enumerator.current);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t_._isEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t},\r\n\r\n\t\t\t_._isEndless\r\n\t\t);\r\n\r\n\t}\r\n\r\n\tofType<TType>(type:{ new (...params:any[]):TType }):InfiniteEnumerable<TType>;\r\n\tofType<TType>(type:any):InfiniteEnumerable<TType>\r\n\t{\r\n\t\tvar typeName:string;\r\n\t\tswitch(<any>type)\r\n\t\t{\r\n\t\t\tcase Number:\r\n\t\t\t\ttypeName = Type.NUMBER;\r\n\t\t\t\tbreak;\r\n\t\t\tcase String:\r\n\t\t\t\ttypeName = Type.STRING;\r\n\t\t\t\tbreak;\r\n\t\t\tcase Boolean:\r\n\t\t\t\ttypeName = Type.BOOLEAN;\r\n\t\t\t\tbreak;\r\n\t\t\tcase Function:\r\n\t\t\t\ttypeName = Type.FUNCTION;\r\n\t\t\t\tbreak;\r\n\t\t\tdefault:\r\n\t\t\t\treturn <Enumerable<any>>this\r\n\t\t\t\t\t.where(x=>x instanceof type);\r\n\t\t}\r\n\t\treturn <Enumerable<any>>this\r\n\t\t\t.choose()\r\n\t\t\t.where(x=>(typeof x)===typeName);\r\n\t}\r\n\r\n\texcept<TCompare>(\r\n\t\tsecond:IEnumerableOrArray<T>,\r\n\t\tcompareSelector?:Selector<T, TCompare>):InfiniteEnumerable<T>\r\n\t{\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar keys:Dictionary<T, boolean>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tkeys = new Dictionary<T, boolean>(compareSelector);\r\n\t\t\t\t\t\tif(second)\r\n\t\t\t\t\t\t\tforEach(second, key => keys.addByKeyValue(key, true));\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tvar current = enumerator.current;\r\n\t\t\t\t\t\t\tif(!keys.containsKey(current))\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tkeys.addByKeyValue(current, true);\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(current);\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t\tkeys.clear();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t_._isEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t},\r\n\r\n\t\t\t_._isEndless\r\n\t\t);\r\n\t}\r\n\r\n\tdistinct(compareSelector?:(value:T) => T):InfiniteEnumerable<T>\r\n\t{\r\n\t\treturn this.except(null, compareSelector);\r\n\t}\r\n\r\n\t// [0,0,0,1,1,1,2,2,2,0,0,0,1,1] results in [0,1,2,0,1];\r\n\tdistinctUntilChanged<TCompare>(compareSelector:Selector<T, TCompare> = Functions.Identity):InfiniteEnumerable<T>\r\n\t{\r\n\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar compareKey:TCompare;\r\n\t\t\t\tvar initial:boolean = true;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tvar key = compareSelector(enumerator.current);\r\n\r\n\t\t\t\t\t\t\tif(initial)\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tinitial = false;\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\telse if(Values.areEqual(compareKey, key))\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tcontinue;\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tcompareKey = key;\r\n\t\t\t\t\t\t\treturn yielder.yieldReturn(enumerator.current);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t_._isEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t},\r\n\r\n\t\t\t_._isEndless\r\n\t\t);\r\n\t}\r\n\r\n\r\n\t/**\r\n\t * Returns a single default value if empty.\r\n\t * @param defaultValue\r\n\t * @returns {Enumerable}\r\n\t */\r\n\tdefaultIfEmpty(defaultValue:T = null):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this, disposed:boolean = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar isFirst:boolean;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tisFirst = true;\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\tif(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tisFirst = false;\r\n\t\t\t\t\t\t\treturn yielder.yieldReturn(enumerator.current);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\telse if(isFirst)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tisFirst = false;\r\n\t\t\t\t\t\t\treturn yielder.yieldReturn(defaultValue);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t_._isEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\t\t\tnull,\r\n\r\n\t\t\t_._isEndless\r\n\t\t);\r\n\t}\r\n\r\n\tzip<TSecond, TResult>(\r\n\t\tsecond:IEnumerableOrArray<TSecond>,\r\n\t\tresultSelector:(first:T, second:TSecond, index?:number) => TResult):Enumerable<TResult>\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\r\n\t\treturn new Enumerable<TResult>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar firstEnumerator:IEnumerator<T>;\r\n\t\t\t\tvar secondEnumerator:IEnumerator<TSecond>;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TResult>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tfirstEnumerator = _.getEnumerator();\r\n\t\t\t\t\t\tsecondEnumerator = enumeratorFrom<TSecond>(second);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=> firstEnumerator.moveNext()\r\n\t\t\t\t\t&& secondEnumerator.moveNext()\r\n\t\t\t\t\t&& yielder.yieldReturn(resultSelector(firstEnumerator.current, secondEnumerator.current, index++)),\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(firstEnumerator, secondEnumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\r\n\tzipMultiple<TSecond, TResult>(\r\n\t\tsecond:IArray<IEnumerableOrArray<TSecond>>,\r\n\t\tresultSelector:(first:T, second:TSecond, index?:number) => TResult):Enumerable<TResult>\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tif(!second.length)\r\n\t\t\treturn Enumerable.empty<TResult>();\r\n\r\n\t\treturn new Enumerable<TResult>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar secondTemp:Queue<any>;\r\n\t\t\t\tvar firstEnumerator:IEnumerator<T>;\r\n\t\t\t\tvar secondEnumerator:IEnumerator<TSecond>;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TResult>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tsecondTemp = new Queue<any>(second);\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tfirstEnumerator = _.getEnumerator();\r\n\t\t\t\t\t\tsecondEnumerator = null;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tif(firstEnumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\twhile(true)\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\twhile(!secondEnumerator)\r\n\t\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\t\tif(secondTemp.count)\r\n\t\t\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\t\t\tvar next = secondTemp.dequeue();\r\n\t\t\t\t\t\t\t\t\t\tif(next) // In case by chance next is null, then try again.\r\n\t\t\t\t\t\t\t\t\t\t\tsecondEnumerator = enumeratorFrom<TSecond>(next);\r\n\t\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\t\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\t\tif(secondEnumerator.moveNext())\r\n\t\t\t\t\t\t\t\t\treturn yielder.yieldReturn(\r\n\t\t\t\t\t\t\t\t\t\tresultSelector(firstEnumerator.current, secondEnumerator.current, index++)\r\n\t\t\t\t\t\t\t\t\t);\r\n\r\n\t\t\t\t\t\t\t\tsecondEnumerator.dispose();\r\n\t\t\t\t\t\t\t\tsecondEnumerator = null;\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(firstEnumerator, secondTemp);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\r\n\t// #region Join Methods\r\n\r\n\tjoin<TInner, TKey, TResult, TCompare>(\r\n\t\tinner:IEnumerableOrArray<TInner>,\r\n\t\touterKeySelector:Selector<T, TKey>,\r\n\t\tinnerKeySelector:Selector<TInner, TKey>,\r\n\t\tresultSelector:(outer:T, inner:TInner) => TResult,\r\n\t\tcompareSelector:Selector<TKey, TCompare> = Functions.Identity):Enumerable<TResult>\r\n\t{\r\n\r\n\t\tvar _ = this;\r\n\t\treturn new Enumerable<TResult>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar outerEnumerator:IEnumerator<T>;\r\n\t\t\t\tvar lookup:ILookup<TKey,TInner>;\r\n\t\t\t\tvar innerElements:TInner[] = null;\r\n\t\t\t\tvar innerCount:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TResult>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\touterEnumerator = _.getEnumerator();\r\n\t\t\t\t\t\tlookup = Enumerable.from(inner)\r\n\t\t\t\t\t\t\t.toLookup(innerKeySelector, Functions.Identity, compareSelector);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\twhile(true)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tif(innerElements!=null)\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tvar innerElement = innerElements[innerCount++];\r\n\t\t\t\t\t\t\t\tif(innerElement!==VOID0)\r\n\t\t\t\t\t\t\t\t\treturn yielder.yieldReturn(resultSelector(outerEnumerator.current, innerElement));\r\n\r\n\t\t\t\t\t\t\t\tinnerElement = null;\r\n\t\t\t\t\t\t\t\tinnerCount = 0;\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tif(outerEnumerator.moveNext())\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tvar key = outerKeySelector(outerEnumerator.current);\r\n\t\t\t\t\t\t\t\tinnerElements = lookup.get(key);\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(outerEnumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tgroupJoin<TInner, TKey, TResult, TCompare>(\r\n\t\tinner:IEnumerableOrArray<TInner>,\r\n\t\touterKeySelector:Selector<T, TKey>,\r\n\t\tinnerKeySelector:Selector<TInner, TKey>,\r\n\t\tresultSelector:(outer:T, inner:TInner[]) => TResult,\r\n\t\tcompareSelector:Selector<TKey, TCompare> = Functions.Identity):Enumerable<TResult>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<TResult>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar lookup:ILookup<TKey, TInner> = null;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TResult>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tlookup = Enumerable.from(inner)\r\n\t\t\t\t\t\t\t.toLookup(innerKeySelector, Functions.Identity, compareSelector);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\tenumerator.moveNext()\r\n\t\t\t\t\t&& yielder.yieldReturn(\r\n\t\t\t\t\t\tresultSelector(\r\n\t\t\t\t\t\t\tenumerator.current,\r\n\t\t\t\t\t\t\tlookup.get(outerKeySelector(enumerator.current))\r\n\t\t\t\t\t\t)\r\n\t\t\t\t\t),\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\r\n\tmerge(enumerables:IArray<IEnumerableOrArray<T>>):InfiniteEnumerable<T>\r\n\t{\r\n\t\tvar _ = this, isEndless = _._isEndless || null;\r\n\r\n\t\tif(!enumerables || enumerables.length==0)\r\n\t\t\treturn _;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar queue:Queue<IEnumerableOrArray<T>>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\t// 1) First get our values...\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tqueue = new Queue<IEnumerableOrArray<T>>(enumerables);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder) =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\twhile(true)\r\n\t\t\t\t\t\t{\r\n\r\n\t\t\t\t\t\t\twhile(!enumerator && queue.count)\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tenumerator = enumeratorFrom<T>(queue.dequeue()); // 4) Keep going and on to step 2. Else fall through to yieldBreak().\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tif(enumerator && enumerator.moveNext()) // 2) Keep returning until done.\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(enumerator.current);\r\n\r\n\t\t\t\t\t\t\tif(enumerator) // 3) Dispose and reset for next.\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tenumerator.dispose();\r\n\t\t\t\t\t\t\t\tenumerator = null;\r\n\t\t\t\t\t\t\t\tcontinue;\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator, queue); // Just in case this gets disposed early.\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\tisEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\t\t\tnull,\r\n\t\t\tisEndless\r\n\t\t);\r\n\t}\r\n\r\n\tconcat(...enumerables:Array<IEnumerableOrArray<T>>):InfiniteEnumerable<T>\r\n\t{\r\n\t\treturn this.merge(enumerables);\r\n\t}\r\n\r\n\r\n\tunion<TCompare>(\r\n\t\tsecond:IEnumerableOrArray<T>,\r\n\t\tcompareSelector:Selector<T, TCompare> = Functions.Identity):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this, isEndless = _._isEndless || null;\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar firstEnumerator:IEnumerator<T>;\r\n\t\t\t\tvar secondEnumerator:IEnumerator<T>;\r\n\t\t\t\tvar keys:Dictionary<T, any>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tfirstEnumerator = _.getEnumerator();\r\n\t\t\t\t\t\tkeys = new Dictionary<T, any>(compareSelector); // Acting as a HashSet.\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar current:T;\r\n\t\t\t\t\t\tif(secondEnumerator===VOID0)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\twhile(firstEnumerator.moveNext())\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tcurrent = firstEnumerator.current;\r\n\t\t\t\t\t\t\t\tif(!keys.containsKey(current))\r\n\t\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\t\tkeys.addByKeyValue(current, null);\r\n\t\t\t\t\t\t\t\t\treturn yielder.yieldReturn(current);\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\tsecondEnumerator = enumeratorFrom(second);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\twhile(secondEnumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tcurrent = secondEnumerator.current;\r\n\t\t\t\t\t\t\tif(!keys.containsKey(current))\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tkeys.addByKeyValue(current, null);\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(current);\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(firstEnumerator, secondEnumerator);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\tisEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\t\t\tnull,\r\n\r\n\t\t\tisEndless\r\n\t\t);\r\n\t}\r\n\r\n\tinsertAt(index:number, other:IEnumerableOrArray<T>):Enumerable<T>\r\n\t{\r\n\t\tInteger.assertZeroOrGreater(index, 'index');\r\n\t\tvar n:number = index;\r\n\r\n\t\tvar _ = this, isEndless = _._isEndless || null;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\r\n\t\t\t\tvar firstEnumerator:IEnumerator<T>;\r\n\t\t\t\tvar secondEnumerator:IEnumerator<T>;\r\n\r\n\t\t\t\tvar count:number = 0;\r\n\t\t\t\tvar isEnumerated:boolean = false;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tcount = 0;\r\n\t\t\t\t\t\tfirstEnumerator = _.getEnumerator();\r\n\t\t\t\t\t\tsecondEnumerator = enumeratorFrom<T>(other);\r\n\t\t\t\t\t\tisEnumerated = false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder) =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tif(count==n)\r\n\t\t\t\t\t\t{ // Inserting?\r\n\t\t\t\t\t\t\tisEnumerated = true;\r\n\t\t\t\t\t\t\tif(secondEnumerator.moveNext())\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(secondEnumerator.current);\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tif(firstEnumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tcount++;\r\n\t\t\t\t\t\t\treturn yielder.yieldReturn(firstEnumerator.current);\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\treturn !isEnumerated\r\n\t\t\t\t\t\t\t&& secondEnumerator.moveNext()\r\n\t\t\t\t\t\t\t&& yielder.yieldReturn(secondEnumerator.current);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(firstEnumerator, secondEnumerator);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\tisEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\t\t\tnull,\r\n\r\n\t\t\tisEndless\r\n\t\t);\r\n\t}\r\n\r\n\r\n\talternateMultiple(sequence:IEnumerableOrArray<T>):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar buffer:T,\r\n\t\t\t\t mode:EnumerableAction,\r\n\t\t\t\t enumerator:IEnumerator<T>,\r\n\t\t\t\t alternateEnumerator:IEnumerator<T>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\t// Instead of recalling getEnumerator every time, just reset the existing one.\r\n\t\t\t\t\t\talternateEnumerator = new ArrayEnumerator(\r\n\t\t\t\t\t\t\tEnumerable.toArray<T>(sequence)\r\n\t\t\t\t\t\t); // Freeze\r\n\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\r\n\t\t\t\t\t\tvar hasAtLeastOne = enumerator.moveNext();\r\n\t\t\t\t\t\tmode = hasAtLeastOne\r\n\t\t\t\t\t\t\t? EnumerableAction.Return\r\n\t\t\t\t\t\t\t: EnumerableAction.Break;\r\n\r\n\t\t\t\t\t\tif(hasAtLeastOne)\r\n\t\t\t\t\t\t\tbuffer = enumerator.current;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tswitch(mode)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tcase EnumerableAction.Break: // We're done?\r\n\t\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\r\n\t\t\t\t\t\t\tcase EnumerableAction.Skip:\r\n\t\t\t\t\t\t\t\tif(alternateEnumerator.moveNext())\r\n\t\t\t\t\t\t\t\t\treturn yielder.yieldReturn(alternateEnumerator.current);\r\n\t\t\t\t\t\t\t\talternateEnumerator.reset();\r\n\t\t\t\t\t\t\t\tmode = EnumerableAction.Return;\r\n\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tvar latest = buffer;\r\n\r\n\t\t\t\t\t\t// Set up the next round...\r\n\r\n\t\t\t\t\t\t// Is there another one? Set the buffer and setup instruct for the next one to be the alternate.\r\n\t\t\t\t\t\tvar another = enumerator.moveNext();\r\n\t\t\t\t\t\tmode = another\r\n\t\t\t\t\t\t\t? EnumerableAction.Skip\r\n\t\t\t\t\t\t\t: EnumerableAction.Break;\r\n\r\n\t\t\t\t\t\tif(another)\r\n\t\t\t\t\t\t\tbuffer = enumerator.current;\r\n\r\n\t\t\t\t\t\treturn yielder.yieldReturn(latest);\r\n\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator, alternateEnumerator);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t_._isEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\t\t\tnull,\r\n\r\n\t\t\t_._isEndless\r\n\t\t);\r\n\t}\r\n\r\n\talternateSingle(value:T):Enumerable<T>\r\n\t{\r\n\t\treturn this.alternateMultiple(Enumerable.make(value));\r\n\t}\r\n\r\n\talternate(...sequence:T[]):Enumerable<T>\r\n\t{\r\n\t\treturn this.alternateMultiple(sequence);\r\n\t}\r\n\r\n\r\n\t// #region Error Handling\r\n\tcatchError(handler:(e:any) => void):InfiniteEnumerable<T>\r\n\t{\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\ttry\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tcatch(e)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t// Don't init...\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\ttry\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\t\tif(enumerator.moveNext())\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(enumerator.current);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tcatch(e)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\thandler(e);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tfinallyAction(action:() => void):InfiniteEnumerable<T>\r\n\t{\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\treturn (enumerator.moveNext())\r\n\t\t\t\t\t\t\t? yielder.yieldReturn(enumerator.current)\r\n\t\t\t\t\t\t\t: false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\ttry\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tfinally\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\taction();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\r\n\tbuffer(size:number):InfiniteEnumerable<T[]>\r\n\t{\r\n\t\tif(size<1 || !isFinite(size))\r\n\t\t\tthrow new Error(\"Invalid buffer size.\");\r\n\r\n\t\tInteger.assert(size, \"size\");\r\n\r\n\t\tvar _ = this, len:number;\r\n\r\n\t\treturn new Enumerable<T[]>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\treturn new EnumeratorBase<T[]>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar array:T[] = ArrayUtility.initialize<T>(size);\r\n\t\t\t\t\t\tlen = 0;\r\n\t\t\t\t\t\twhile(len<size && enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tarray[len++] = enumerator.current;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tarray.length = len;\r\n\t\t\t\t\t\treturn len && yielder.yieldReturn(array);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t_._isEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\t\t\tnull,\r\n\r\n\t\t\t_._isEndless\r\n\t\t);\r\n\t}\r\n\r\n\r\n\tshare():InfiniteEnumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar sharedEnumerator:IEnumerator<T>;\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\treturn sharedEnumerator || (sharedEnumerator = _.getEnumerator());\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdispose(sharedEnumerator);\r\n\t\t\t},\r\n\r\n\t\t\t_._isEndless\r\n\t\t);\r\n\t}\r\n\r\n\r\n}\r\n\r\n\r\n/**\r\n * Enumerable<T> is a wrapper class that allows more primitive enumerables to exhibit LINQ behavior.\r\n *\r\n * In C# Enumerable<T> is not an instance but has extensions for IEnumerable<T>.\r\n * In this case, we use Enumerable<T> as the underlying class that is being chained.\r\n */\r\nexport class Enumerable<T>\r\nextends InfiniteEnumerable<T>\r\n{\r\n\r\n\tconstructor(\r\n\t\tenumeratorFactory:() => IEnumerator<T>,\r\n\t\tfinalizer?:() => void,\r\n\t\tisEndless:boolean = null)\r\n\t{\r\n\t\tsuper(enumeratorFactory, finalizer);\r\n\t\tthis._isEndless = isEndless;\r\n\t}\r\n\r\n\t/**\r\n\t * Universal method for converting a primitive enumerables into a LINQ enabled ones.\r\n\t *\r\n\t * Is not limited to TypeScript usages.\r\n\t */\r\n\tstatic from<T>(source:IEnumerableOrArray<T>):Enumerable<T>\r\n\t{\r\n\t\tvar e = Enumerable.fromAny(source);\r\n\t\tif(!e) throw new UnsupportedEnumerableException();\r\n\t\treturn e;\r\n\t}\r\n\r\n\tstatic fromAny(\r\n\t\tsource:any):Enumerable<any>\r\n\r\n\tstatic fromAny<T>(\r\n\t\tsource:IEnumerableOrArray<T>,\r\n\t\tdefaultEnumerable?:Enumerable<T>):Enumerable<T>\r\n\r\n\tstatic fromAny<T>(\r\n\t\tsource:any,\r\n\t\tdefaultEnumerable?:Enumerable<T>):Enumerable<T>\r\n\r\n\tstatic fromAny<T>(\r\n\t\tsource:any,\r\n\t\tdefaultEnumerable:Enumerable<T> = null):Enumerable<T>\r\n\t{\r\n\t\tif(Type.isObject(source) || Type.isString(source))\r\n\t\t{\r\n\t\t\tif(source instanceof Enumerable)\r\n\t\t\t\treturn source;\r\n\r\n\t\t\tif(Type.isArrayLike<T>(source))\r\n\t\t\t\treturn new ArrayEnumerable<T>(source);\r\n\r\n\t\t\tif(isEnumerable<T>(source))\r\n\t\t\t\treturn new Enumerable<T>(\r\n\t\t\t\t\t()=>source.getEnumerator(),\r\n\t\t\t\t\tnull, source.isEndless);\r\n\t\t}\r\n\r\n\t\treturn defaultEnumerable;\r\n\t}\r\n\r\n\tstatic fromOrEmpty<T>(source:IEnumerableOrArray<T>):Enumerable<T>\r\n\t{\r\n\t\treturn Enumerable.fromAny(source) || Enumerable.empty<T>();\r\n\t}\r\n\r\n\t/**\r\n\t * Static helper for converting enumerables to an array.\r\n\t * @param source\r\n\t * @returns {any}\r\n\t */\r\n\tstatic toArray<T>(source:IEnumerableOrArray<T>):T[]\r\n\t{\r\n\t\tif(source instanceof Enumerable)\r\n\t\t\treturn source.toArray();\r\n\r\n\t\treturn toArray(source);\r\n\t}\r\n\r\n\r\n\t//////////////////////////////////////////\r\n\t// #region Static Methods...\r\n\tstatic choice<T>(values:IArray<T>):InfiniteEnumerable<T>\r\n\t{\r\n\t\tvar len = values && values.length;\r\n\t\t// We could return empty if no length, but that would break the typing and produce unexpected results.\r\n\t\t// Enforcing that there must be at least 1 choice is key.\r\n\t\tif(!len || !isFinite(len))\r\n\t\t\tthrow new ArgumentOutOfRangeException('length', length);\r\n\r\n\t\treturn new InfiniteEnumerable<T>(\r\n\t\t\t() => new EnumeratorBase<T>(\r\n\t\t\t\tnull,\r\n\t\t\t\t(yielder)=>\r\n\t\t\t\t\tyielder.yieldReturn(Integer.random.select(values)),\r\n\t\t\t\ttrue // Is endless!\r\n\t\t\t)\r\n\t\t);\r\n\t}\r\n\r\n\tstatic chooseFrom<T>(...args:T[]):InfiniteEnumerable<T>\r\n\t{\r\n\t\treturn Enumerable.choice(args);\r\n\t}\r\n\r\n\tstatic cycle<T>(values:IArray<T>):InfiniteEnumerable<T>\r\n\t{\r\n\t\tvar len = values && values.length;\r\n\t\t// We could return empty if no length, but that would break the typing and produce unexpected results.\r\n\t\t// Enforcing that there must be at least 1 choice is key.\r\n\t\tif(!len || !isFinite(len))\r\n\t\t\tthrow new ArgumentOutOfRangeException('length', length);\r\n\r\n\t\treturn new InfiniteEnumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar index:number = 0;\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t}, // Reinitialize the value just in case the enumerator is restarted.\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tif(index>=values.length) index = 0;\r\n\t\t\t\t\t\treturn yielder.yieldReturn(values[index++]);\r\n\t\t\t\t\t},\r\n\t\t\t\t\ttrue // Is endless!\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tstatic cycleThrough<T>(...args:T[]):InfiniteEnumerable<T>\r\n\t{\r\n\t\treturn Enumerable.cycle(args);\r\n\t}\r\n\r\n\tstatic empty<T>():FiniteEnumerable<T>\r\n\t{\r\n\t\t// Could be single static instance, but for safety, we'll make a new one.\r\n\t\treturn new FiniteEnumerable<T>(getEmptyEnumerator);\r\n\t}\r\n\r\n\tstatic repeat<T>(element:T):InfiniteEnumerable<T>;\r\n\tstatic repeat<T>(element:T, count:number):FiniteEnumerable<T>;\r\n\tstatic repeat<T>(element:T, count:number = Infinity):Enumerable<T>\r\n\t{\r\n\t\tif(!(count>0))\r\n\t\t\treturn Enumerable.empty<T>();\r\n\r\n\t\treturn isFinite(count) && Integer.assert(count, \"count\")\r\n\t\t\t? new FiniteEnumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar c:number = count;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() => { index = 0; },\r\n\t\t\t\t\t(yielder)=> (index++<c) && yielder.yieldReturn(element),\r\n\t\t\t\t\tnull,\r\n\t\t\t\t\tfalse\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t)\r\n\t\t\t: new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t\tnew EnumeratorBase<T>(\r\n\t\t\t\t\tnull,\r\n\t\t\t\t\t(yielder)=> yielder.yieldReturn(element),\r\n\t\t\t\t\ttrue // Is endless!\r\n\t\t\t\t)\r\n\t\t);\r\n\t}\r\n\r\n\t// Note: this enumeration is endless but can be disposed/cancelled and finalized.\r\n\tstatic repeatWithFinalize<T>(\r\n\t\tinitializer:() => T,\r\n\t\tfinalizer:(element:T) => void):InfiniteEnumerable<T>\r\n\t{\r\n\r\n\t\treturn new InfiniteEnumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar element:T;\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\telement = initializer();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=> yielder.yieldReturn(element),\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tfinalizer(element);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\ttrue // Is endless!\r\n\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t/**\r\n\t * Creates an enumerable of one element.\r\n\t * @param element\r\n\t * @returns {FiniteEnumerable<T>}\r\n\t */\r\n\tstatic make<T>(element:T):FiniteEnumerable<T>\r\n\t{\r\n\t\treturn Enumerable.repeat<T>(element, 1);\r\n\t}\r\n\r\n\t// start and step can be other than integer.\r\n\r\n\tstatic range(\r\n\t\tstart:number,\r\n\t\tcount:number,\r\n\t\tstep:number = 1):FiniteEnumerable<number>\r\n\t{\r\n\t\tif(!isFinite(start))\r\n\t\t\tthrow new ArgumentOutOfRangeException(\"start\", start, \"Must be a finite number.\");\r\n\r\n\t\tif(!(count>0))\r\n\t\t\treturn Enumerable.empty<number>();\r\n\r\n\t\tif(!step)\r\n\t\t\tthrow new ArgumentOutOfRangeException(\"step\", step, \"Must be a valid value\");\r\n\r\n\t\tif(!isFinite(step))\r\n\t\t\tthrow new ArgumentOutOfRangeException(\"step\", step, \"Must be a finite number.\");\r\n\r\n\t\tInteger.assert(count, \"count\");\r\n\r\n\t\treturn new FiniteEnumerable<number>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar value:number;\r\n\t\t\t\tvar c:number = count; // Force integer evaluation.\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<number>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tvalue = start;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar result:boolean =\r\n\t\t\t\t\t\t\t index++<c\r\n\t\t\t\t\t\t\t && yielder.yieldReturn(value);\r\n\r\n\t\t\t\t\t\tif(result && index<count)\r\n\t\t\t\t\t\t\tvalue += step;\r\n\r\n\t\t\t\t\t\treturn result;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\tfalse\r\n\t\t\t\t);\r\n\t\t\t});\r\n\t}\r\n\r\n\tstatic rangeDown(\r\n\t\tstart:number,\r\n\t\tcount:number,\r\n\t\tstep:number = 1):FiniteEnumerable<number>\r\n\t{\r\n\t\tstep = Math.abs(step)* -1;\r\n\r\n\t\treturn Enumerable.range(start, count, step);\r\n\t}\r\n\r\n\t// step = -1 behaves the same as toNegativeInfinity;\r\n\tstatic toInfinity(\r\n\t\tstart:number = 0,\r\n\t\tstep:number = 1):InfiniteEnumerable<number>\r\n\t{\r\n\t\tif(!isFinite(start))\r\n\t\t\tthrow new ArgumentOutOfRangeException(\"start\", start, \"Must be a finite number.\");\r\n\r\n\t\tif(!step)\r\n\t\t\tthrow new ArgumentOutOfRangeException(\"step\", step, \"Must be a valid value\");\r\n\r\n\t\tif(!isFinite(step))\r\n\t\t\tthrow new ArgumentOutOfRangeException(\"step\", step, \"Must be a finite number.\");\r\n\r\n\t\treturn new InfiniteEnumerable<number>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar value:number;\r\n\r\n\t\t\t\treturn new EnumeratorBase<number>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvalue = start;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar current:number = value;\r\n\t\t\t\t\t\tvalue += step;\r\n\t\t\t\t\t\treturn yielder.yieldReturn(current);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\ttrue // Is endless!\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tstatic toNegativeInfinity(\r\n\t\tstart:number = 0,\r\n\t\tstep:number = 1):InfiniteEnumerable<number>\r\n\t{\r\n\t\treturn Enumerable.toInfinity(start, -step);\r\n\t}\r\n\r\n\tstatic rangeTo(\r\n\t\tstart:number,\r\n\t\tto:number,\r\n\t\tstep:number = 1):FiniteEnumerable<number>\r\n\t{\r\n\t\tif(isNaN(to) || !isFinite(to))\r\n\t\t\tthrow new ArgumentOutOfRangeException(\"to\", to, \"Must be a finite number.\");\r\n\r\n\t\tif(step && !isFinite(step))\r\n\t\t\tthrow new ArgumentOutOfRangeException(\"step\", step, \"Must be a finite non-zero number.\");\r\n\r\n\t\t// This way we adjust for the delta from start and to so the user can say +/- step and it will work as expected.\r\n\t\tstep = Math.abs(step);\r\n\r\n\t\treturn new FiniteEnumerable<number>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar value:number;\r\n\r\n\t\t\t\treturn new EnumeratorBase<number>(() => { value = start; },\r\n\t\t\t\t\tstart<to\r\n\t\t\t\t\t\t?\r\n\t\t\t\t\t\tyielder=>\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tvar result:boolean = value<=to && yielder.yieldReturn(value);\r\n\r\n\t\t\t\t\t\t\tif(result)\r\n\t\t\t\t\t\t\t\tvalue += step;\r\n\r\n\t\t\t\t\t\t\treturn result;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\t:\r\n\t\t\t\t\t\tyielder=>\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tvar result:boolean = value>=to && yielder.yieldReturn(value);\r\n\r\n\t\t\t\t\t\t\tif(result)\r\n\t\t\t\t\t\t\t\tvalue -= step;\r\n\r\n\t\t\t\t\t\t\treturn result;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t, false);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tstatic matches(input:string, pattern:any, flags:string = \"\"):FiniteEnumerable<RegExpExecArray>\r\n\t{\r\n\t\tif(input===null || input===VOID0)\r\n\t\t\tthrow new ArgumentNullException(\"input\");\r\n\t\tvar type = typeof input;\r\n\t\tif(type!=Type.STRING)\r\n\t\t\tthrow new Error(\"Cannot exec RegExp matches of type '\" + type + \"'.\");\r\n\r\n\t\tif(pattern instanceof RegExp)\r\n\t\t{\r\n\t\t\tflags += (pattern.ignoreCase) ? \"i\" : \"\";\r\n\t\t\tflags += (pattern.multiline) ? \"m\" : \"\";\r\n\t\t\tpattern = pattern.source;\r\n\t\t}\r\n\r\n\t\tif(flags.indexOf(\"g\")=== -1) flags += \"g\";\r\n\r\n\t\treturn new FiniteEnumerable<RegExpExecArray>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar regex:RegExp;\r\n\t\t\t\treturn new EnumeratorBase<RegExpExecArray>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tregex = new RegExp(pattern, flags);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\t// Calling regex.exec consecutively on the same input uses the lastIndex to start the next match.\r\n\t\t\t\t\t\tvar match = regex.exec(input);\r\n\t\t\t\t\t\treturn (match!==null) ? yielder.yieldReturn(match) : false;\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tstatic generate<T>(factory:(index?:number) => T):InfiniteEnumerable<T>;\r\n\tstatic generate<T>(factory:(index?:number) => T, count:number):FiniteEnumerable<T>;\r\n\tstatic generate<T>(factory:(index?:number) => T, count:number = Infinity):InfiniteEnumerable<T>\r\n\t{\r\n\r\n\t\tif(isNaN(count) || count<=0)\r\n\t\t\treturn Enumerable.empty<T>();\r\n\r\n\t\treturn isFinite(count) && Integer.assert(count, \"count\")\r\n\t\t\t?\r\n\t\t\tnew FiniteEnumerable<T>(\r\n\t\t\t\t() =>\r\n\t\t\t\t{\r\n\t\t\t\t\tvar c:number = count;\r\n\t\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t\t() =>\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\t},\r\n\r\n\t\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tvar current:number = index++;\r\n\t\t\t\t\t\t\treturn current<c && yielder.yieldReturn(factory(current));\r\n\t\t\t\t\t\t},\r\n\r\n\t\t\t\t\t\tfalse\r\n\t\t\t\t\t);\r\n\t\t\t\t})\r\n\t\t\t:\r\n\t\t\tnew InfiniteEnumerable<T>(\r\n\t\t\t\t() =>\r\n\t\t\t\t{\r\n\t\t\t\t\tvar index:number = 0;\r\n\t\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t\t() =>\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\t},\r\n\r\n\t\t\t\t\t\t(yielder)=> yielder.yieldReturn(factory(index++)),\r\n\r\n\t\t\t\t\t\ttrue // Is endless!\r\n\t\t\t\t\t);\r\n\t\t\t\t});\r\n\t}\r\n\r\n\tstatic unfold<T>(\r\n\t\tseed:T,\r\n\t\tvalueFactory:Selector<T, T>,\r\n\t\tskipSeed:Boolean = false):InfiniteEnumerable<T>\r\n\t{\r\n\t\treturn new InfiniteEnumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar index:number = 0;\r\n\t\t\t\tvar value:T;\r\n\t\t\t\tvar isFirst:boolean;\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tvalue = seed;\r\n\t\t\t\t\t\tisFirst = !skipSeed;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar i = index++;\r\n\t\t\t\t\t\tif(isFirst)\r\n\t\t\t\t\t\t\tisFirst = false;\r\n\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\tvalue = valueFactory(value, i);\r\n\t\t\t\t\t\treturn yielder.yieldReturn(value);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\ttrue // Is endless!\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tstatic forEach<T>(\r\n\t\tenumerable:IEnumerableOrArray<T>,\r\n\t\taction:(element:T, index?:number) => any):void\r\n\t{\r\n\t\t// Will properly dispose created enumerable.\r\n\t\t// Will throw if enumerable is endless.\r\n\t\tforEach(enumerable, action);\r\n\t}\r\n\r\n\tstatic map<T,TResult>(\r\n\t\tenumerable:IEnumerableOrArray<T>,\r\n\t\tselector:Selector<T,TResult>):TResult[]\r\n\t{\r\n\t\t// Will properly dispose created enumerable.\r\n\t\t// Will throw if enumerable is endless.\r\n\t\treturn map(enumerable, selector);\r\n\r\n\t}\r\n\r\n\t// Slightly optimized versions for numbers.\r\n\tstatic max(values:FiniteEnumerable<number>):number\r\n\t{\r\n\t\treturn values\r\n\t\t\t.takeUntil(v=> v== +Infinity, true)\r\n\t\t\t.aggregate(Functions.Greater);\r\n\t}\r\n\r\n\tstatic min(values:FiniteEnumerable<number>):number\r\n\t{\r\n\t\treturn values\r\n\t\t\t.takeUntil(v=> v== -Infinity, true)\r\n\t\t\t.aggregate(Functions.Lesser);\r\n\t}\r\n\r\n\r\n\t/**\r\n\t * Takes any set of collections of the same type and weaves them together.\r\n\t * @param enumerables\r\n\t * @returns {Enumerable<T>}\r\n\t */\r\n\tstatic weave<T>(\r\n\t\tenumerables:IEnumerableOrArray<IEnumerableOrArray<T>>):Enumerable<T>\r\n\t{\r\n\t\tif(!enumerables)\r\n\t\t\tthrow new ArgumentNullException('enumerables');\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar queue:Queue<IEnumerator<T>>;\r\n\t\t\t\tvar mainEnumerator:IEnumerator<IEnumerableOrArray<T>>;\r\n\t\t\t\tvar index:number;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tqueue = new Queue<IEnumerator<T>>();\r\n\t\t\t\t\t\tmainEnumerator = enumeratorFrom(enumerables);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tlet e:IEnumerator<T>;\r\n\r\n\t\t\t\t\t\t// First pass...\r\n\t\t\t\t\t\tif(mainEnumerator)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\twhile(!e && mainEnumerator.moveNext())\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tlet c = mainEnumerator.current;\r\n\t\t\t\t\t\t\t\te = nextEnumerator(queue, c && enumeratorFrom(c));\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tif(!e)\r\n\t\t\t\t\t\t\t\tmainEnumerator = null;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\twhile(!e && queue.count)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\te = nextEnumerator(queue, queue.dequeue());\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\treturn e\r\n\t\t\t\t\t\t\t? yielder.yieldReturn(e.current)\r\n\t\t\t\t\t\t\t: yielder.yieldBreak();\r\n\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose.these(queue.dump());\r\n\t\t\t\t\t\tdispose(mainEnumerator, queue);\r\n\t\t\t\t\t\tmainEnumerator = null;\r\n\t\t\t\t\t\tqueue = null;\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\tdoAction(\r\n\t\taction:Action<T>|Predicate<T>|Selector<T, number>|Selector<T, EnumerableAction>,\r\n\t\tinitializer?:()=>void,\r\n\t\tisEndless:boolean = this.isEndless):Enumerable<T>\r\n\t{\r\n\t\treturn <Enumerable<T>>super.doAction(action, initializer, isEndless);\r\n\t}\r\n\r\n// #region Indexing/Paging methods.\r\n\r\n\tskip(count:number):Enumerable<T>\r\n\t{\r\n\t\treturn <Enumerable<T>>super.skip(count);\r\n\t}\r\n\r\n\tskipWhile(predicate:Predicate<T>):Enumerable<T>\r\n\t{\r\n\t\tthis.throwIfDisposed();\r\n\t\treturn this.doAction(\r\n\t\t\t(element:T, index?:number) =>\r\n\t\t\t\tpredicate(element, index)\r\n\t\t\t\t\t? EnumerableAction.Skip\r\n\t\t\t\t\t: EnumerableAction.Return\r\n\t\t);\r\n\t}\r\n\r\n\ttakeWhile(predicate:Predicate<T>):Enumerable<T>\r\n\t{\r\n\t\tthis.throwIfDisposed();\r\n\r\n\t\tif(!predicate)\r\n\t\t\tthrow new ArgumentNullException('predicate');\r\n\r\n\t\treturn this.doAction(\r\n\t\t\t(element:T, index?:number) =>\r\n\t\t\t\tpredicate(element, index)\r\n\t\t\t\t\t? EnumerableAction.Return\r\n\t\t\t\t\t: EnumerableAction.Break,\r\n\t\t\tnull,\r\n\t\t\tnull // We don't know the state if it is endless or not.\r\n\t\t);\r\n\t}\r\n\r\n\t// Is like the inverse of take While with the ability to return the value identified by the predicate.\r\n\ttakeUntil(predicate:Predicate<T>, includeUntilValue?:boolean):Enumerable<T>\r\n\t{\r\n\t\tthis.throwIfDisposed();\r\n\r\n\t\tif(!predicate)\r\n\t\t\tthrow new ArgumentNullException('predicate');\r\n\r\n\t\tif(!includeUntilValue)\r\n\t\t\treturn this.doAction(\r\n\t\t\t\t(element:T, index?:number) =>\r\n\t\t\t\t\tpredicate(element, index)\r\n\t\t\t\t\t\t? EnumerableAction.Break\r\n\t\t\t\t\t\t: EnumerableAction.Return,\r\n\t\t\t\tnull,\r\n\t\t\t\tnull // We don't know the state if it is endless or not.\r\n\t\t\t);\r\n\r\n\t\tvar found:boolean = false;\r\n\t\treturn this.doAction(\r\n\t\t\t(element:T, index?:number) =>\r\n\t\t\t{\r\n\t\t\t\tif(found)\r\n\t\t\t\t\treturn EnumerableAction.Break;\r\n\r\n\t\t\t\tfound = predicate(element, index);\r\n\t\t\t\treturn EnumerableAction.Return;\r\n\t\t\t},\r\n\t\t\t()=>\r\n\t\t\t{\r\n\t\t\t\tfound = false;\r\n\t\t\t},\r\n\t\t\tnull // We don't know the state if it is endless or not.\r\n\t\t);\r\n\t}\r\n\r\n\r\n\tforEach(action:Predicate<T> | Action<T>):void\r\n\t{\r\n\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\t\tthrowIfEndless(_.isEndless);\r\n\r\n\t\tvar index:number = 0;\r\n\t\t// Return value of action can be anything, but if it is (===) false then the forEach will discontinue.\r\n\t\tusing(\r\n\t\t\t_.getEnumerator(), e=>\r\n\t\t\t{\r\n\t\t\t\tthrowIfEndless(e.isEndless);\r\n\r\n\t\t\t\t// It is possible that subsequently 'action' could cause the enumeration to dispose, so we have to check each time.\r\n\t\t\t\twhile(_.throwIfDisposed() && e.moveNext())\r\n\t\t\t\t{\r\n\t\t\t\t\tif(action(e.current, index++)===false)\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t// #region Conversion Methods\r\n\ttoArray(predicate?:Predicate<T>):T[]\r\n\t{\r\n\t\treturn predicate\r\n\t\t\t? this.where(predicate).toArray()\r\n\t\t\t: this.copyTo([]);\r\n\t}\r\n\r\n\tcopyTo(target:T[], index:number = 0):T[]\r\n\t{\r\n\t\tthis.throwIfDisposed();\r\n\t\tif(!target) throw new ArgumentNullException(\"target\");\r\n\t\tInteger.assertZeroOrGreater(index);\r\n\r\n\t\t// If not exposing an action that could cause dispose, then use forEach utility instead.\r\n\t\tforEach<T>(this, (x, i)=>\r\n\t\t{\r\n\t\t\ttarget[i + index] = x\r\n\t\t});\r\n\r\n\t\treturn target;\r\n\t}\r\n\r\n\ttoLookup<TKey, TValue, TCompare>(\r\n\t\tkeySelector:Selector<T, TKey>,\r\n\t\telementSelector:Selector<T, TValue> = Functions.Identity,\r\n\t\tcompareSelector:Selector<TKey, TCompare> = Functions.Identity):ILookup<TKey, TValue>\r\n\t{\r\n\t\tvar dict:Dictionary<TKey, TValue[]> = new Dictionary<TKey, TValue[]>(compareSelector);\r\n\t\tthis.forEach(\r\n\t\t\tx=>\r\n\t\t\t{\r\n\t\t\t\tvar key = keySelector(x);\r\n\t\t\t\tvar element = elementSelector(x);\r\n\r\n\t\t\t\tvar array = dict.getValue(key);\r\n\t\t\t\tif(array!==VOID0) array.push(element);\r\n\t\t\t\telse dict.addByKeyValue(key, [element]);\r\n\t\t\t}\r\n\t\t);\r\n\t\treturn new Lookup<TKey, TValue>(dict);\r\n\t}\r\n\r\n\ttoMap<TResult>(\r\n\t\tkeySelector:Selector<T, string>,\r\n\t\telementSelector:Selector<T, TResult>):IMap<TResult>\r\n\t{\r\n\t\tvar obj:IMap<TResult> = {};\r\n\t\tthis.forEach((x, i)=>\r\n\t\t{\r\n\t\t\tobj[keySelector(x, i)] = elementSelector(x, i);\r\n\t\t});\r\n\t\treturn obj;\r\n\t}\r\n\r\n\ttoDictionary<TKey, TValue, TCompare>(\r\n\t\tkeySelector:Selector<T, TKey>,\r\n\t\telementSelector:Selector<T, TValue>,\r\n\t\tcompareSelector:Selector<TKey, TCompare> = Functions.Identity):Dictionary<TKey, TValue>\r\n\t{\r\n\t\tvar dict:Dictionary<TKey, TValue> = new Dictionary<TKey, TValue>(compareSelector);\r\n\t\tthis.forEach((x, i)=> dict.addByKeyValue(keySelector(x, i), elementSelector(x, i)));\r\n\t\treturn dict;\r\n\t}\r\n\r\n\ttoJoinedString(separator:string = \"\", selector:Selector<T, string> = Functions.Identity)\r\n\t{\r\n\t\treturn this.select(selector).toArray().join(separator);\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\r\n\ttakeExceptLast(count:number = 1):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\tif(!(count>0)) // Out of bounds?\r\n\t\t\treturn _;\r\n\r\n\t\tif(!isFinite(count)) // +Infinity equals skip all so return empty.\r\n\t\t\treturn Enumerable.empty<T>();\r\n\r\n\t\tInteger.assert(count, \"count\");\r\n\t\tvar c = count;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar q:Queue<T>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tq = new Queue<T>();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t// Add the next one to the queue.\r\n\t\t\t\t\t\t\tq.enqueue(enumerator.current);\r\n\r\n\t\t\t\t\t\t\t// Did we reach our quota?\r\n\t\t\t\t\t\t\tif(q.count>c)\r\n\t\t\t\t\t\t\t// Okay then, start returning results.\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(q.dequeue());\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator, q);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tskipToLast(count:number):Enumerable<T>\r\n\t{\r\n\t\tif(!(count>0)) // Out of bounds? Empty.\r\n\t\t\treturn Enumerable.empty<T>();\r\n\r\n\t\tvar _ = this;\r\n\r\n\t\tif(!isFinite(count)) // Infinity means return all.\r\n\t\t\treturn _;\r\n\r\n\t\tInteger.assert(count, \"count\");\r\n\r\n\t\t// This sets up the query so nothing is done until move next is called.\r\n\t\treturn _.reverse()\r\n\t\t\t.take(count)\r\n\t\t\t.reverse();\r\n\t}\r\n\r\n\t// To help with type guarding.\r\n\r\n\twhere(predicate:Predicate<T>):Enumerable<T>\r\n\t{\r\n\t\treturn <Enumerable<T>>super.where(predicate);\r\n\t}\r\n\r\n\tselect<TResult>(selector:Selector<T, TResult>):Enumerable<TResult>\r\n\t{\r\n\t\treturn <Enumerable<TResult>>super.select(selector);\r\n\t}\r\n\r\n\tselectMany<TResult>(\r\n\t\tcollectionSelector:Selector<T, IEnumerableOrArray<TResult>>):Enumerable<TResult>;\r\n\r\n\r\n\tselectMany<TElement, TResult>(\r\n\t\tcollectionSelector:Selector<T, IEnumerableOrArray<TElement>>,\r\n\t\tresultSelector:(collection:T, element:TElement)=>TResult):Enumerable<TResult>;\r\n\r\n\tselectMany<TResult>(\r\n\t\tcollectionSelector:Selector<T, IEnumerableOrArray<any>>,\r\n\t\tresultSelector?:(collection:T, element:any)=>TResult):Enumerable<TResult>\r\n\t{\r\n\t\treturn this._selectMany(collectionSelector, resultSelector);\r\n\t}\r\n\r\n\tchoose():Enumerable<T>;\r\n\tchoose<TResult>(selector?:Selector<T, TResult>):Enumerable<TResult>\r\n\tchoose(selector:Selector<T, any> = Functions.Identity):Enumerable<any>\r\n\t{\r\n\t\treturn this._choose(selector);\r\n\t}\r\n\r\n\treverse():Enumerable<T>\r\n\t{\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\t\tthrowIfEndless(_._isEndless); // Cannot reverse an endless collection...\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar buffer:T[];\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\tbuffer = _.toArray();\r\n\t\t\t\t\t\tindex = buffer.length;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=> index && yielder.yieldReturn(buffer[--index]),\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tbuffer.length = 0;\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tshuffle():Enumerable<T>\r\n\t{\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\t\tthrowIfEndless(_._isEndless); // Cannot shuffle an endless collection...\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar buffer:T[];\r\n\t\t\t\tvar capacity:number;\r\n\t\t\t\tvar len:number;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\tbuffer = _.toArray();\r\n\t\t\t\t\t\tcapacity = len = buffer.length;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\t// Avoid using major array operations like .slice();\r\n\t\t\t\t\t\tif(!len)\r\n\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\r\n\t\t\t\t\t\tvar selectedIndex = Integer.random(len);\r\n\t\t\t\t\t\tvar selectedValue = buffer[selectedIndex];\r\n\r\n\t\t\t\t\t\tbuffer[selectedIndex] = buffer[--len]; // Take the last one and put it here.\r\n\t\t\t\t\t\tbuffer[len] = null; // clear possible reference.\r\n\r\n\t\t\t\t\t\tif(len%32==0) // Shrink?\r\n\t\t\t\t\t\t\tbuffer.length = len;\r\n\r\n\t\t\t\t\t\treturn yielder.yieldReturn(selectedValue);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tbuffer.length = 0;\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tcount(predicate?:Predicate<T>):number\r\n\t{\r\n\t\tvar count:number = 0;\r\n\t\tthis.forEach(\r\n\t\t\tpredicate\r\n\r\n\t\t\t\t?\r\n\t\t\t\t(x, i) =>\r\n\t\t\t\t{\r\n\t\t\t\t\tif(predicate(x, i))++count;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t:\r\n\t\t\t\t() =>\r\n\t\t\t\t{\r\n\t\t\t\t\t++count;\r\n\t\t\t\t}\r\n\t\t);\r\n\r\n\t\treturn count;\r\n\t}\r\n\r\n\t// Akin to '.every' on an array.\r\n\tall(predicate:Predicate<T>):boolean\r\n\t{\r\n\t\tif(!predicate)\r\n\t\t\tthrow new ArgumentNullException(\"predicate\");\r\n\r\n\t\tvar result = true;\r\n\t\tthis.forEach((x, i) =>\r\n\t\t{\r\n\t\t\tif(!predicate(x, i))\r\n\t\t\t{\r\n\t\t\t\tresult = false;\r\n\t\t\t\treturn false; // break\r\n\t\t\t}\r\n\t\t});\r\n\t\treturn result;\r\n\t}\r\n\r\n\t// 'every' has been added here for parity/compatibility with an array.\r\n\tevery(predicate:Predicate<T>):boolean\r\n\t{\r\n\t\treturn this.all(predicate);\r\n\t}\r\n\r\n\t// Akin to '.some' on an array.\r\n\tany(predicate?:Predicate<T>):boolean\r\n\t{\r\n\t\tif(!predicate)\r\n\t\t\treturn super.any();\r\n\r\n\t\tvar result = false;\r\n\t\t// Splitting the forEach up this way reduces iterative processing.\r\n\t\t// forEach handles the generation and disposal of the enumerator.\r\n\t\tthis.forEach(\r\n\t\t\t(x, i) =>\r\n\t\t\t{\r\n\t\t\t\tresult = predicate(x, i); // false = not found and therefore it should continue. true = found and break;\r\n\t\t\t\treturn !result;\r\n\t\t\t});\r\n\t\treturn result;\r\n\r\n\t}\r\n\r\n\t// 'some' has been added here for parity/compatibility with an array.\r\n\tsome(predicate:Predicate<T>):boolean\r\n\t{\r\n\t\treturn this.any(predicate);\r\n\t}\r\n\r\n\r\n\tcontains<TCompare>(value:T, compareSelector?:Selector<T, TCompare>):boolean\r\n\t{\r\n\t\treturn compareSelector\r\n\t\t\t? this.any(v=> compareSelector(v)===compareSelector(value))\r\n\t\t\t: this.any(v=> v===value);\r\n\t}\r\n\r\n\t// Originally has an overload for a predicate,\r\n\t// but that's a bad idea since this could be an enumeration of functions and therefore fail the intent.\r\n\t// Better to chain a where statement first to be more explicit.\r\n\tindexOf<TCompare>(value:T, compareSelector?:Selector<T, TCompare>):number\r\n\t{\r\n\t\tvar found:number = -1;\r\n\t\tthis.forEach(\r\n\t\t\tcompareSelector\r\n\t\t\t\t?\r\n\t\t\t\t(element:T, i?:number) =>\r\n\t\t\t\t{\r\n\t\t\t\t\tif(Values.areEqual(compareSelector(element, i), compareSelector(value, i), true))\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tfound = i;\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\t:\r\n\t\t\t\t(element:T, i?:number) =>\r\n\t\t\t\t{\r\n\t\t\t\t\t// Why? Because NaN doesn't equal NaN. :P\r\n\t\t\t\t\tif(Values.areEqual(element, value, true))\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tfound = i;\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t}\r\n\t\t\t\t});\r\n\r\n\r\n\t\treturn found;\r\n\t}\r\n\r\n\tlastIndexOf<TCompare>(value:T, compareSelector?:Selector<T, TCompare>):number\r\n\t{\r\n\t\tvar result:number = -1;\r\n\t\tthis.forEach(\r\n\t\t\tcompareSelector\r\n\t\t\t\t?\r\n\t\t\t\t(element:T, i?:number) =>\r\n\t\t\t\t{\r\n\t\t\t\t\tif(Values.areEqual(compareSelector(element, i), compareSelector(value, i), true)) result\r\n\t\t\t\t\t\t= i;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t:\r\n\t\t\t\t(element:T, i?:number) =>\r\n\t\t\t\t{\r\n\t\t\t\t\tif(Values.areEqual(element, value, true)) result = i;\r\n\t\t\t\t});\r\n\r\n\t\treturn result;\r\n\t}\r\n\r\n\tmerge(enumerables:IArray<IEnumerableOrArray<T>>):Enumerable<T>\r\n\t{\r\n\t\treturn <Enumerable<T>>super.merge(enumerables);\r\n\t}\r\n\r\n\tconcat(...enumerables:Array<IEnumerableOrArray<T>>):Enumerable<T>\r\n\t{\r\n\t\treturn this.merge(enumerables);\r\n\t}\r\n\r\n\r\n\tintersect<TCompare>(\r\n\t\tsecond:IEnumerableOrArray<T>,\r\n\t\tcompareSelector?:Selector<T, TCompare>):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar keys:Dictionary<T,boolean>;\r\n\t\t\t\tvar outs:Dictionary<T,boolean>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\r\n\t\t\t\t\t\tkeys = new Dictionary<T, boolean>(compareSelector);\r\n\t\t\t\t\t\touts = new Dictionary<T, boolean>(compareSelector);\r\n\r\n\t\t\t\t\t\tforEach(second, key=>\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tkeys.addByKeyValue(key, true);\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tvar current = enumerator.current;\r\n\t\t\t\t\t\t\tif(!outs.containsKey(current) && keys.containsKey(current))\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\touts.addByKeyValue(current, true);\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(current);\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator, keys, outs);\r\n\t\t\t\t\t},\r\n\t\t\t\t\t_._isEndless\r\n\t\t\t\t);\r\n\t\t\t},\r\n\t\t\tnull,\r\n\t\t\t_._isEndless\r\n\t\t);\r\n\t}\r\n\r\n\tsequenceEqual(\r\n\t\tsecond:IEnumerableOrArray<T>,\r\n\t\tequalityComparer:EqualityComparison<T> = Values.areEqual):boolean\r\n\t{\r\n\t\treturn using(\r\n\t\t\tthis.getEnumerator(),\r\n\t\t\te1=> using(\r\n\t\t\t\tenumeratorFrom(second),\r\n\t\t\t\te2=>\r\n\t\t\t\t{\r\n\t\t\t\t\t// if both are endless, this will never evaluate.\r\n\t\t\t\t\tthrowIfEndless(e1.isEndless && e2.isEndless);\r\n\r\n\t\t\t\t\twhile(e1.moveNext())\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tif(!e2.moveNext() || !equalityComparer(e1.current, e2.current))\r\n\t\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\treturn !e2.moveNext();\r\n\t\t\t\t}\r\n\t\t\t)\r\n\t\t);\r\n\t}\r\n\r\n\t//isEquivalent(second:IEnumerableOrArray<T>,\r\n\t//\tequalityComparer:EqualityComparison<T> = Values.areEqual):boolean\r\n\t//{\r\n\t//\treturn this\r\n\t//\t\t.orderBy(keySelector)\r\n\t//\t\t.sequenceEqual(Enumerable.from(second).orderBy(keySelector))\r\n\t//}\r\n\r\n\r\n\t// #endregion\r\n\r\n\r\n\tofType<TType>(type:{ new (...params:any[]):TType }):Enumerable<TType>;\r\n\tofType<TType>(type:any):Enumerable<TType>\r\n\t{\r\n\t\treturn <Enumerable<TType>>super.ofType(type);\r\n\t}\r\n\r\n\texcept<TCompare>(\r\n\t\tsecond:IEnumerableOrArray<T>,\r\n\t\tcompareSelector?:Selector<T, TCompare>):Enumerable<T>\r\n\t{\r\n\t\treturn <Enumerable<T>>super.except(second, compareSelector);\r\n\t}\r\n\r\n\tdistinct(compareSelector?:(value:T)=>T):Enumerable<T>\r\n\t{\r\n\t\treturn <Enumerable<T>>super.distinct(compareSelector);\r\n\t}\r\n\r\n\tdistinctUntilChanged<TCompare>(compareSelector:Selector<T, TCompare> = Functions.Identity):Enumerable<T>\r\n\t{\r\n\t\treturn <Enumerable<T>>super.distinctUntilChanged(compareSelector);\r\n\t}\r\n\r\n// #region Ordering Methods\r\n\r\n\torderBy<TKey extends Comparable>(keySelector:Selector<T, TKey> = Functions.Identity):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn new OrderedEnumerable<T,TKey>(this, keySelector, Order.Ascending);\r\n\t}\r\n\r\n\torderUsing(comparison:Comparison<T>):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn new OrderedEnumerable<T,any>(this, null, Order.Ascending, null, comparison);\r\n\t}\r\n\r\n\torderUsingReversed(comparison:Comparison<T>):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn new OrderedEnumerable<T,any>(this, null, Order.Descending, null, comparison);\r\n\t}\r\n\r\n\torderByDescending<TKey extends Comparable>(keySelector:Selector<T, TKey> = Functions.Identity):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn new OrderedEnumerable<T,TKey>(this, keySelector, Order.Descending);\r\n\t}\r\n\r\n\t/*\r\n\t\t weightedSample(weightSelector) {\r\n\t\t weightSelector = Utils.createLambda(weightSelector);\r\n\t\t var source = this;\r\n\r\n\t\t return new Enumerable<T>(() => {\r\n\t\t var sortedByBound;\r\n\t\t var totalWeight = 0;\r\n\r\n\t\t return new EnumeratorBase<T>(\r\n\t\t () => {\r\n\t\t sortedByBound = source\r\n\t\t .choose(function (x) {\r\n\t\t var weight = weightSelector(x);\r\n\t\t if (weight <= 0) return null; // ignore 0\r\n\r\n\t\t totalWeight += weight;\r\n\t\t return { value: x, bound: totalWeight }\r\n\t\t })\r\n\t\t .toArray();\r\n\t\t },\r\n\t\t () => {\r\n\t\t if (sortedByBound.length > 0) {\r\n\t\t var draw = (Math.random() * totalWeight) + 1;\r\n\r\n\t\t var lower = -1;\r\n\t\t var upper = sortedByBound.length;\r\n\t\t while (upper - lower > 1) {\r\n\t\t var index = ((lower + upper) / 2);\r\n\t\t if (sortedByBound[index].bound >= draw) {\r\n\t\t upper = index;\r\n\t\t }\r\n\t\t else {\r\n\t\t lower = index;\r\n\t\t }\r\n\t\t }\r\n\r\n\t\t return (<any>this).yieldReturn(sortedByBound[upper].value);\r\n\t\t }\r\n\r\n\t\t return (<any>this).yieldBreak();\r\n\t\t },\r\n\t\t Functions.Blank);\r\n\t\t });\r\n\t\t }\r\n\t\t */\r\n\t// #endregion\r\n\r\n\tbuffer(size:number):Enumerable<T[]>\r\n\t{\r\n\t\treturn <Enumerable<T[]>>super.buffer(size);\r\n\t}\r\n\r\n\t// #region Grouping Methods\r\n\r\n\t// Originally contained a result selector (not common use), but this could be done simply by a select statement after.\r\n\r\n\r\n\tgroupBy<TKey>(keySelector:Selector<T, TKey>):Enumerable<IGrouping<TKey, T>>;\r\n\tgroupBy<TKey, TCompare>(\r\n\t\tkeySelector:Selector<T, TKey>,\r\n\t\telementSelector?:Selector<T, T>,\r\n\t\tcompareSelector?:Selector<TKey, TCompare>):Enumerable<IGrouping<TKey, T>>;\r\n\tgroupBy<TKey, TElement, TCompare>(\r\n\t\tkeySelector:Selector<T, TKey>,\r\n\t\telementSelector?:Selector<T, TElement>,\r\n\t\tcompareSelector?:Selector<TKey, TCompare>):Enumerable<IGrouping<TKey, TElement>>\r\n\t{\r\n\t\tif(!elementSelector) elementSelector = Functions.Identity; // Allow for 'null' and not just undefined.\r\n\t\treturn new Enumerable<IGrouping<TKey, TElement>>(\r\n\t\t\t() => this.toLookup(keySelector, elementSelector, compareSelector)\r\n\t\t\t\t.getEnumerator()\r\n\t\t);\r\n\t}\r\n\r\n\tpartitionBy<TKey>(keySelector:Selector<T, TKey>):Enumerable<IGrouping<TKey, T>>;\r\n\tpartitionBy<TKey, TElement, TCompare>(\r\n\t\tkeySelector:Selector<T, TKey>,\r\n\t\telementSelector:Selector<T, TElement>,\r\n\t\tresultSelector?:(key:TKey, element:TElement[]) => IGrouping<TKey, TElement>,\r\n\t\tcompareSelector?:Selector<TKey, TCompare>):Enumerable<IGrouping<TKey, TElement>>;\r\n\tpartitionBy<TKey, TElement, TCompare>(\r\n\t\tkeySelector:Selector<T, TKey>,\r\n\t\telementSelector?:Selector<T, TElement>,\r\n\t\tresultSelector:(key:TKey, element:TElement[]) => IGrouping<TKey, TElement>\r\n\t\t\t= (key:TKey, elements:TElement[]) => new Grouping<TKey, TElement>(key, elements),\r\n\t\tcompareSelector:Selector<TKey, TCompare>\r\n\t\t\t= Functions.Identity):Enumerable<IGrouping<TKey, T>>|Enumerable<IGrouping<TKey, TElement>>\r\n\t{\r\n\r\n\t\tvar _ = this;\r\n\t\tif(!elementSelector) elementSelector = Functions.Identity; // Allow for 'null' and not just undefined.\r\n\t\treturn new Enumerable<IGrouping<TKey, TElement>>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar key:TKey;\r\n\t\t\t\tvar compareKey:TCompare;\r\n\t\t\t\tvar group:TElement[];\r\n\t\t\t\tvar len:number;\r\n\r\n\t\t\t\treturn new EnumeratorBase<IGrouping<TKey, TElement>>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tif(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tkey = keySelector(enumerator.current);\r\n\t\t\t\t\t\t\tcompareKey = compareSelector(key);\r\n\t\t\t\t\t\t\tgroup = [elementSelector(enumerator.current)];\r\n\t\t\t\t\t\t\tlen = 1;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\tgroup = null;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tif(!group)\r\n\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\r\n\t\t\t\t\t\tvar hasNext:boolean, c:T;\r\n\t\t\t\t\t\twhile((hasNext = enumerator.moveNext()))\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tc = enumerator.current;\r\n\t\t\t\t\t\t\tif(compareKey===compareSelector(keySelector(c)))\r\n\t\t\t\t\t\t\t\tgroup[len++] = elementSelector(c);\r\n\t\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tvar result:IGrouping<TKey, TElement>\r\n\t\t\t\t\t\t\t = resultSelector(key, group);\r\n\r\n\t\t\t\t\t\tif(hasNext)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tc = enumerator.current;\r\n\t\t\t\t\t\t\tkey = keySelector(c);\r\n\t\t\t\t\t\t\tcompareKey = compareSelector(key);\r\n\t\t\t\t\t\t\tgroup = [elementSelector(c)];\r\n\t\t\t\t\t\t\tlen = 1;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\telse\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tgroup = null;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\treturn yielder.yieldReturn(result);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t\tgroup = null;\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\t// #region Aggregate Methods\r\n\r\n\taggregate(\r\n\t\tfunc:(a:T, b:T) => T,\r\n\t\tseed?:T):T\r\n\t{\r\n\t\treturn this.scan(func, seed).lastOrDefault();\r\n\t}\r\n\r\n\taverage(selector:Selector<T, number> = Type.numberOrNaN):number\r\n\t{\r\n\t\tvar count = 0;\r\n\t\tvar sum = this.sum((e, i)=>\r\n\t\t{\r\n\t\t\tcount++;\r\n\t\t\treturn selector(e, i);\r\n\t\t});\r\n\r\n\t\treturn (isNaN(sum) || !count)\r\n\t\t\t? NaN\r\n\t\t\t: (sum/count);\r\n\t}\r\n\r\n\t// If using numbers, it may be useful to call .takeUntil(v=>v==Infinity,true) before calling max. See static versions for numbers.\r\n\tmax():T\r\n\t{\r\n\t\treturn this.aggregate(Functions.Greater);\r\n\t}\r\n\r\n\tmin():T\r\n\t{\r\n\t\treturn this.aggregate(Functions.Lesser);\r\n\t}\r\n\r\n\tmaxBy<TCompare>(keySelector:Selector<T, TCompare> = Functions.Identity):T\r\n\t{\r\n\t\treturn this.aggregate((a:T, b:T) => (keySelector(a)>keySelector(b)) ? a : b);\r\n\t}\r\n\r\n\tminBy<TCompare>(keySelector:Selector<T, TCompare> = Functions.Identity):T\r\n\t{\r\n\t\treturn this.aggregate((a:T, b:T) => (keySelector(a)<keySelector(b)) ? a : b);\r\n\t}\r\n\r\n\t// Addition... Only works with numerical enumerations.\r\n\tsum(selector:Selector<T, number> = Type.numberOrNaN):number\r\n\t{\r\n\t\tvar sum = 0;\r\n\r\n\t\t// This allows for infinity math that doesn't destroy the other values.\r\n\t\tvar sumInfinite = 0; // Needs more investigation since we are really trying to retain signs.\r\n\r\n\t\tthis.forEach(\r\n\t\t\tx=>\r\n\t\t\t{\r\n\t\t\t\tvar value = selector(x);\r\n\t\t\t\tif(isNaN(value))\r\n\t\t\t\t{\r\n\t\t\t\t\tsum = NaN;\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\t\t\tif(isFinite(value))\r\n\t\t\t\t\tsum += value;\r\n\t\t\t\telse\r\n\t\t\t\t\tsumInfinite +=\r\n\t\t\t\t\t\tvalue>0 ?\r\n\t\t\t\t\t\t\t(+1) :\r\n\t\t\t\t\t\t\t(-1);\r\n\t\t\t}\r\n\t\t);\r\n\r\n\t\treturn isNaN(sum) ? NaN : (sumInfinite ? (sumInfinite*Infinity) : sum);\r\n\t}\r\n\r\n\t// Multiplication...\r\n\tproduct(selector:Selector<T, number> = Type.numberOrNaN):number\r\n\t{\r\n\t\tvar result = 1, exists:boolean = false;\r\n\r\n\t\tthis.forEach(\r\n\t\t\t(x, i)=>\r\n\t\t\t{\r\n\t\t\t\texists = true;\r\n\t\t\t\tvar value = selector(x, i);\r\n\t\t\t\tif(isNaN(value))\r\n\t\t\t\t{\r\n\t\t\t\t\tresult = NaN;\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tif(value==0)\r\n\t\t\t\t{\r\n\t\t\t\t\tresult = 0; // Multiplying by zero will always end in zero.\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Multiplication can never recover from infinity and simply must retain signs.\r\n\t\t\t\t// You could cancel out infinity with 1/infinity but no available representation exists.\r\n\t\t\t\tresult *= value;\r\n\t\t\t}\r\n\t\t);\r\n\r\n\t\treturn (exists && isNaN(result)) ? NaN : result;\r\n\t}\r\n\r\n\t/**\r\n\t * Takes the first number and divides it by all following.\r\n\t * @param selector\r\n\t * @returns {number}\r\n\t */\r\n\tquotient(selector:Selector<T, number> = Type.numberOrNaN):number\r\n\t{\r\n\t\tvar count = 0;\r\n\t\tvar result:number = NaN;\r\n\r\n\t\tthis.forEach(\r\n\t\t\t(x, i)=>\r\n\t\t\t{\r\n\t\t\t\tvar value = selector(x, i);\r\n\t\t\t\tcount++;\r\n\r\n\t\t\t\tif(count===1)\r\n\t\t\t\t{\r\n\t\t\t\t\tresult = value;\r\n\t\t\t\t}\r\n\t\t\t\telse\r\n\t\t\t\t{\r\n\t\t\t\t\tif(isNaN(value) || value===0 || !isFinite(value))\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tresult = NaN;\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tresult /= value;\r\n\t\t\t\t}\r\n\r\n\t\t\t}\r\n\t\t);\r\n\r\n\t\tif(count===1)\r\n\t\t\tresult = NaN;\r\n\r\n\t\treturn result;\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\t// #region Single Value Return...\r\n\r\n\tlast():T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar value:T = undefined;\r\n\t\tvar found:boolean = false;\r\n\t\t_.forEach(\r\n\t\t\tx =>\r\n\t\t\t{\r\n\t\t\t\tfound = true;\r\n\t\t\t\tvalue = x;\r\n\t\t\t}\r\n\t\t);\r\n\r\n\t\tif(!found) throw new Error(\"last:No element satisfies the condition.\");\r\n\t\treturn value;\r\n\t}\r\n\r\n\tlastOrDefault(defaultValue:T = null):T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar value:T = undefined;\r\n\t\tvar found:boolean = false;\r\n\t\t_.forEach(\r\n\t\t\tx=>\r\n\t\t\t{\r\n\t\t\t\tfound = true;\r\n\t\t\t\tvalue = x;\r\n\t\t\t}\r\n\t\t);\r\n\t\treturn (!found) ? defaultValue : value;\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\tshare():Enumerable<T>\r\n\t{\r\n\t\treturn <Enumerable<T>>super.share();\r\n\t}\r\n\r\n\r\n\tcatchError(handler:(e:any)=>void):Enumerable<T>\r\n\t{\r\n\t\treturn <Enumerable<T>>super.catchError(handler);\r\n\t}\r\n\r\n\r\n\tfinallyAction(action:()=>void):Enumerable<T>\r\n\t{\r\n\t\treturn <Enumerable<T>>super.finallyAction(action);\r\n\t}\r\n\r\n\tmemoize():Enumerable<T>\r\n\t{\r\n\t\tvar _ = this, disposed:boolean = !_.throwIfDisposed();\r\n\r\n\t\tvar cache:T[];\r\n\t\tvar enumerator:IEnumerator<T>;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\tif(!enumerator)\r\n\t\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tif(!cache)\r\n\t\t\t\t\t\t\tcache = [];\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\tvar i = index++;\r\n\r\n\t\t\t\t\t\tif(i>=cache.length)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\treturn (enumerator.moveNext())\r\n\t\t\t\t\t\t\t\t? yielder.yieldReturn(cache[i] = enumerator.current)\r\n\t\t\t\t\t\t\t\t: false;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\treturn yielder.yieldReturn(cache[i]);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t\tif(cache)\r\n\t\t\t\t\tcache.length = 0;\r\n\t\t\t\tcache = null;\r\n\r\n\t\t\t\tdispose(enumerator);\r\n\t\t\t\tenumerator = null;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\r\n}\r\n\r\n\r\n// Provided for type guarding.\r\nexport class FiniteEnumerable<T>\r\nextends Enumerable<T>\r\n{\r\n\tconstructor(\r\n\t\tenumeratorFactory:() => IEnumerator<T>,\r\n\t\tfinalizer?:() => void)\r\n\t{\r\n\t\tsuper(enumeratorFactory, finalizer, false);\r\n\t}\r\n\r\n}\r\n\r\nclass ArrayEnumerable<T>\r\nextends FiniteEnumerable<T>\r\n{\r\n\tprivate _source:IArray<T>;\r\n\r\n\tconstructor(source:IArray<T>)\r\n\t{\r\n\t\tsuper(() =>\r\n\t\t{\r\n\t\t\t_.throwIfDisposed();\r\n\t\t\treturn new ArrayEnumerator<T>(() =>\r\n\t\t\t{\r\n\t\t\t\t_.throwIfDisposed(\"The underlying ArrayEnumerable was disposed.\", \"ArrayEnumerator\");\r\n\r\n\t\t\t\treturn _._source; // Should never be null, but ArrayEnumerable if not disposed simply treats null as empty array.\r\n\t\t\t});\r\n\t\t});\r\n\r\n\t\tvar _ = this;\r\n\t\t_._disposableObjectName = \"ArrayEnumerable\";\r\n\t\t_._source = source;\r\n\r\n\t}\r\n\r\n\tprotected _onDispose():void\r\n\t{\r\n\t\tsuper._onDispose();\r\n\t\tthis._source = <any>null;\r\n\t}\r\n\r\n\tget source():IArray<T>\r\n\t{\r\n\t\treturn this._source;\r\n\t}\r\n\r\n\ttoArray():T[]\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\treturn toArray(_._source);\r\n\t}\r\n\r\n\tasEnumerable():ArrayEnumerable<T>\r\n\t{\r\n\t\treturn new ArrayEnumerable<T>(this._source);\r\n\t}\r\n\r\n\t// Optimize forEach so that subsequent usage is optimized.\r\n\tforEach(action:Predicate<T> | Action<T>):void\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tforEach(_._source, action);\r\n\t}\r\n\r\n\t// These methods should ALWAYS check for array length before attempting anything.\r\n\r\n\tany(predicate?:Predicate<T>):boolean\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar source = _._source, len = source.length;\r\n\t\treturn len && (!predicate || super.any(predicate));\r\n\t}\r\n\r\n\tcount(predicate?:Predicate<T>):number\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar source = _._source, len = source.length;\r\n\t\treturn len && (predicate ? super.count(predicate) : len);\r\n\t}\r\n\r\n\telementAtOrDefault(index:number, defaultValue:T = null):T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\t\tInteger.assertZeroOrGreater(index, 'index');\r\n\r\n\t\tvar source = _._source;\r\n\t\treturn index<source.length\r\n\t\t\t? source[index]\r\n\t\t\t: defaultValue;\r\n\t}\r\n\r\n\tlast():T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar source = _._source, len = source.length;\r\n\t\treturn (len)\r\n\t\t\t? source[len - 1]\r\n\t\t\t: super.last();\r\n\t}\r\n\r\n\tlastOrDefault(defaultValue:T = null):T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar source = _._source, len = source.length;\r\n\t\treturn len\r\n\t\t\t? source[len - 1]\r\n\t\t\t: defaultValue;\r\n\t}\r\n\r\n\tskip(count:number):Enumerable<T>\r\n\t{\r\n\r\n\t\tvar _ = this;\r\n\r\n\t\tif(!(count>0))\r\n\t\t\treturn _;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() => new ArrayEnumerator<T>(() => _._source, count)\r\n\t\t);\r\n\t}\r\n\r\n\ttakeExceptLast(count:number = 1):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\t\treturn _.take(_._source.length - count);\r\n\t}\r\n\r\n\tskipToLast(count:number):Enumerable<T>\r\n\t{\r\n\t\tif(!(count>0))\r\n\t\t\treturn Enumerable.empty<T>();\r\n\r\n\t\tvar _ = this;\r\n\t\tif(!isFinite(count))\r\n\t\t\treturn _;\r\n\r\n\t\tvar len = _._source\r\n\t\t\t? _._source.length\r\n\t\t\t: 0;\r\n\r\n\t\treturn _.skip(len - count);\r\n\t}\r\n\r\n\treverse():Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() => new ArrayEnumerator<T>(\r\n\t\t\t\t() => _._source, _._source\r\n\t\t\t\t\t? (_._source.length - 1)\r\n\t\t\t\t\t: 0, -1\r\n\t\t\t)\r\n\t\t);\r\n\t}\r\n\r\n\tmemoize():ArrayEnumerable<T>\r\n\t{\r\n\t\treturn this.asEnumerable();\r\n\t}\r\n\r\n\tsequenceEqual(\r\n\t\tsecond:IEnumerableOrArray<T>,\r\n\t\tequalityComparer:EqualityComparison<T> = Values.areEqual):boolean\r\n\t{\r\n\t\tif(Type.isArrayLike(second))\r\n\t\t\treturn Arrays.areEqual(this.source, second, true, equalityComparer);\r\n\r\n\t\tif(second instanceof ArrayEnumerable)\r\n\t\t\treturn second.sequenceEqual(this.source, equalityComparer);\r\n\r\n\t\treturn super.sequenceEqual(second, equalityComparer);\r\n\t}\r\n\r\n\r\n\ttoJoinedString(separator:string = \"\", selector:Selector<T, string> = Functions.Identity)\r\n\t{\r\n\t\tvar s = this._source;\r\n\t\treturn !selector && Array.isArray(s)\r\n\t\t\t? (<Array<T>>s).join(separator)\r\n\t\t\t: super.toJoinedString(separator, selector);\r\n\t}\r\n\r\n}\r\n\r\n\r\nexport interface IGrouping<TKey, TElement>\r\nextends Enumerable<TElement>\r\n{\r\n\tkey:TKey;\r\n}\r\n\r\nclass Grouping<TKey, TElement>\r\nextends ArrayEnumerable<TElement> implements IGrouping<TKey, TElement>\r\n{\r\n\r\n\tconstructor(private _groupKey:TKey, elements:TElement[])\r\n\t{\r\n\t\tsuper(elements);\r\n\t}\r\n\r\n\tget key():TKey\r\n\t{\r\n\t\treturn this._groupKey;\r\n\t}\r\n}\r\n\r\n\r\nexport interface ILookup<TKey, TElement>\r\nextends IEnumerable<IGrouping<TKey, TElement>>\r\n{\r\n\tcount:number;\r\n\tget(key:TKey):TElement[];\r\n\tcontains(key:TKey):boolean;\r\n}\r\n\r\nclass Lookup<TKey, TElement>\r\nimplements ILookup<TKey, TElement>\r\n{\r\n\r\n\tconstructor(private _dictionary:Dictionary<TKey, TElement[]>)\r\n\t{\r\n\t}\r\n\r\n\tget count():number\r\n\t{\r\n\t\treturn this._dictionary.count;\r\n\t}\r\n\r\n\tget(key:TKey):TElement[]\r\n\t{\r\n\t\treturn this._dictionary.getValue(key);\r\n\t}\r\n\r\n\tcontains(key:TKey):boolean\r\n\t{\r\n\t\treturn this._dictionary.containsKey(key);\r\n\t}\r\n\r\n\tgetEnumerator():IEnumerator<Grouping<TKey, TElement>>\r\n\t{\r\n\r\n\t\tvar _ = this;\r\n\t\tvar enumerator:IEnumerator<IKeyValuePair<TKey, TElement[]>>;\r\n\r\n\t\treturn new EnumeratorBase<Grouping<TKey, TElement>>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tenumerator = _._dictionary.getEnumerator();\r\n\t\t\t},\r\n\t\t\t(yielder)=>\r\n\t\t\t{\r\n\r\n\t\t\t\tif(!enumerator.moveNext())\r\n\t\t\t\t\treturn false;\r\n\r\n\t\t\t\tvar current = enumerator.current;\r\n\r\n\t\t\t\treturn yielder.yieldReturn(new Grouping<TKey, TElement>(current.key, current.value));\r\n\t\t\t},\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdispose(enumerator);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n}\r\n\r\n\r\nexport interface IOrderedEnumerable<T>\r\nextends FiniteEnumerable<T>\r\n{\r\n\tthenBy(keySelector:(value:T) => any):IOrderedEnumerable<T>;\r\n\tthenByDescending(keySelector:(value:T) => any):IOrderedEnumerable<T>;\r\n\tthenUsing(comparison:Comparison<T>):IOrderedEnumerable<T>;\r\n\tthenUsingReversed(comparison:Comparison<T>):IOrderedEnumerable<T>\r\n}\r\n\r\nclass OrderedEnumerable<T,TOrderBy extends Comparable>\r\nextends FiniteEnumerable<T> implements IOrderedEnumerable<T>\r\n{\r\n\r\n\tconstructor(\r\n\t\tprivate source:IEnumerable<T>,\r\n\t\tpublic keySelector:(value:T) => TOrderBy,\r\n\t\tpublic order:Order,\r\n\t\tpublic parent?:OrderedEnumerable<T,any>,\r\n\t\tpublic comparer:Comparison<T> = Values.compare)\r\n\t{\r\n\t\tsuper(null);\r\n\t\tthrowIfEndless(source && source.isEndless);\r\n\t}\r\n\r\n\tprivate createOrderedEnumerable(\r\n\t\tkeySelector:(value:T) => TOrderBy,\r\n\t\torder:Order):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn new OrderedEnumerable<T,TOrderBy>(this.source, keySelector, order, this);\r\n\t}\r\n\r\n\tthenBy(keySelector:(value:T) => TOrderBy):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn this.createOrderedEnumerable(keySelector, Order.Ascending);\r\n\t}\r\n\r\n\tthenUsing(comparison:Comparison<T>):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn new OrderedEnumerable<T,any>(this.source, null, Order.Ascending, this, comparison);\r\n\t}\r\n\r\n\tthenByDescending(keySelector:(value:T) => TOrderBy):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn this.createOrderedEnumerable(keySelector, Order.Descending);\r\n\t}\r\n\r\n\tthenUsingReversed(comparison:Comparison<T>):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn new OrderedEnumerable<T,any>(this.source, null, Order.Descending, this, comparison);\r\n\t}\r\n\r\n\tgetEnumerator():EnumeratorBase<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\t\tvar buffer:T[];\r\n\t\tvar indexes:number[];\r\n\t\tvar index:number = 0;\r\n\r\n\t\treturn new EnumeratorBase<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tindex = 0;\r\n\t\t\t\tbuffer = Enumerable.toArray(_.source);\r\n\t\t\t\tindexes = createSortContext(_).generateSortedIndexes(buffer);\r\n\t\t\t},\r\n\r\n\t\t\t(yielder)=>\r\n\t\t\t{\r\n\t\t\t\treturn (index<indexes.length)\r\n\t\t\t\t\t? yielder.yieldReturn(buffer[indexes[index++]])\r\n\t\t\t\t\t: false;\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tif(buffer)\r\n\t\t\t\t\tbuffer.length = 0;\r\n\t\t\t\tbuffer = null;\r\n\t\t\t\tif(indexes)\r\n\t\t\t\t\tindexes.length = 0;\r\n\t\t\t\tindexes = null;\r\n\t\t\t},\r\n\r\n\t\t\tfalse\r\n\t\t);\r\n\t}\r\n\r\n\tprotected _onDispose():void\r\n\t{\r\n\t\tsuper._onDispose();\r\n\t\tthis.source = null;\r\n\t\tthis.keySelector = null;\r\n\t\tthis.order = null;\r\n\t\tthis.parent = null;\r\n\t}\r\n\r\n}\r\n\r\n// A private static helper for the weave function.\r\nfunction nextEnumerator<T>(queue:Queue<IEnumerator<T>>, e:IEnumerator<T>):IEnumerator<T>\r\n{\r\n\tif(e)\r\n\t{\r\n\t\tif(e.moveNext())\r\n\t\t{\r\n\t\t\tqueue.enqueue(e);\r\n\t\t}\r\n\t\telse\r\n\t\t{\r\n\t\t\tdispose(e);\r\n\t\t\te = null;\r\n\t\t}\r\n\t}\r\n\treturn e;\r\n}\r\n\r\n/**\r\n * Recursively builds a SortContext chain.\r\n * @param orderedEnumerable\r\n * @param currentContext\r\n * @returns {any}\r\n */\r\nfunction createSortContext<T, TOrderBy extends Comparable>(\r\n\torderedEnumerable:OrderedEnumerable<T,TOrderBy>,\r\n\tcurrentContext:IComparer<T> = null):KeySortedContext<T, TOrderBy>\r\n{\r\n\r\n\tvar context = new KeySortedContext<T, TOrderBy>(\r\n\t\tcurrentContext,\r\n\t\torderedEnumerable.keySelector,\r\n\t\torderedEnumerable.order,\r\n\t\torderedEnumerable.comparer);\r\n\r\n\tif(orderedEnumerable.parent)\r\n\t\treturn createSortContext(orderedEnumerable.parent, context);\r\n\r\n\treturn context;\r\n}\r\n\r\n// #region Helper Functions...\r\n// This allows for the use of a boolean instead of calling this.throwIfDisposed()\r\n// since there is a strong chance of introducing a circular reference.\r\nfunction throwIfDisposed(disposed:boolean):void\r\n{\r\n\tif(disposed) throw new ObjectDisposedException(\"Enumerable\");\r\n}\r\n// #endregion\r\n\r\nexport default Enumerable;\r\n"]}