{"version":3,"sources":["webpack:///./node_modules/linq/linq.js","webpack:///(webpack)/buildin/amd-options.js"],"names":["root","undefined","Functions","Identity","x","True","Blank","Types","Boolean","Number","String","Object","Undefined","Function","funcCache","Utils","createLambda","expression","f","indexOf","match","regexp","RegExp","maxLength","exec","paramNumber","length","argArray","i","dollar","j","push","args","Array","prototype","join","call","expr","isIEnumerable","obj","Enumerator","e","defineProperty","defineProperties","target","methodName","value","enumerable","configurable","writable","compare","a","b","dispose","hasNativeIteratorSupport","Symbol","iterator","State","Before","Running","After","IEnumerator","initialize","tryGetNext","yielder","Yielder","state","this","current","moveNext","apply","yieldReturn","yieldBreak","Enumerable","getEnumerator","createEnumerable","createEnumerator","extendTo","type","enumerableProto","typeProto","ArrayEnumerable","from","func","recallFrom","getSource","choice","arguments","toArray","Math","floor","random","cycle","index","empty","repeat","charAt","next","done","enumerator","isFirst","atEnd","item","Windows","first","array","key","hasOwnProperty","make","element","matches","input","pattern","flags","source","regex","range","start","count","step","rangeDown","rangeTo","to","take","repeatWithFinalize","initializer","finalizer","generate","toInfinity","toNegativeInfinity","unfold","seed","defer","enumerableFactory","traverseBreadthFirst","resultSelector","nestLevel","buffer","selectMany","any","traverseDepthFirst","enumeratorStack","pop","forEach","s","flatten","middleEnumerator","pairwise","selector","prev","scan","isUseSeed","select","WhereSelectEnumerable","collectionSelector","middleSeq","where","predicate","WhereEnumerable","choose","result","ofType","typeName","zip","second","firstEnumerator","secondEnumerator","enumerators","concat","takeExceptLast","all","merge","splice","inner","outerKeySelector","innerKeySelector","compareSelector","outerEnumerator","lookup","innerElements","innerCount","toLookup","innerElement","get","groupJoin","isEmpty","insert","isEnumerated","alternate","alternateValueOrSequence","alternateSequence","alternateEnumerator","retVal","contains","defaultIfEmpty","defaultValue","distinct","except","distinctUntilChanged","compareKey","initial","keys","Dictionary","add","intersect","outs","sequenceEqual","union","orderBy","keySelector","comparer","OrderedEnumerable","orderByDescending","reverse","shuffle","weightedSample","weightSelector","sortedByBound","totalWeight","weight","bound","draw","lower","upper","groupBy","elementSelector","toEnumerable","partitionBy","hasResultSelector","group","Grouping","hasNext","aggregate","last","average","sum","max","min","maxBy","minBy","elementAt","found","Error","elementAtOrDefault","firstOrDefault","lastOrDefault","single","singleOrDefault","skip","skipWhile","isSkipEnd","takeWhile","q","shift","takeFromLast","sourceEnumerator","lastIndexOf","cast","asEnumerable","dict","Lookup","toObject","toDictionary","toJSONString","replacer","space","JSON","stringify","toJoinedString","separator","doAction","action","write","document","writeLine","writeln","force","letBind","share","sharedEnumerator","disposed","DisposableEnumerable","memoize","cache","catchError","handler","finallyAction","log","console","trace","message","descending","parent","createOrderedEnumerable","thenBy","thenByDescending","indexes","self","sortContext","SortContext","create","GenerateKeys","sort","child","orderedEnumerable","currentContext","context","len","index1","index2","comparison","prevSource","prevPredicate","composedPredicate","prevSelector","composedSelector","callHasOwnProperty","computeHashCode","toString","HashEntry","EntryList","addLast","entry","replace","newEntry","remove","countField","entryList","buckets","hash","set","clear","currentEntry","dictionary","kvp","groupKey","elements","module","exports","__webpack_amd_options__"],"mappings":"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","file":"js/chunk-6a10cbfe.49abfd1e.js","sourcesContent":["/*--------------------------------------------------------------------------\r\n * linq.js - LINQ for JavaScript\r\n * licensed under MIT License\r\n *------------------------------------------------------------------------*/\r\n\r\n(function (root, undefined) {\r\n    // ReadOnly Function\r\n    var Functions = {\r\n        Identity: function (x) { return x; },\r\n        True: function () { return true; },\r\n        Blank: function () { }\r\n    };\r\n\r\n    // const Type\r\n    var Types = {\r\n        Boolean: typeof true,\r\n        Number: typeof 0,\r\n        String: typeof \"\",\r\n        Object: typeof {},\r\n        Undefined: typeof undefined,\r\n        Function: typeof function () { }\r\n    };\r\n\r\n    // createLambda cache\r\n    var funcCache = { \"\": Functions.Identity };\r\n\r\n    // private utility methods\r\n    var Utils = {\r\n        // Create anonymous function from lambda expression string\r\n        createLambda: function (expression) {\r\n            if (expression == null) return Functions.Identity;\r\n            if (typeof expression === Types.String) {\r\n                // get from cache\r\n                var f = funcCache[expression];\r\n                if (f != null) {\r\n                    return f;\r\n                }\r\n\r\n                if (expression.indexOf(\"=>\") === -1) {\r\n                    var regexp = new RegExp(\"[$]+\", \"g\");\r\n\r\n                    var maxLength = 0;\r\n                    var match;\r\n                    while ((match = regexp.exec(expression)) != null) {\r\n                        var paramNumber = match[0].length;\r\n                        if (paramNumber > maxLength) {\r\n                            maxLength = paramNumber;\r\n                        }\r\n                    }\r\n\r\n                    var argArray = [];\r\n                    for (var i = 1; i <= maxLength; i++) {\r\n                        var dollar = \"\";\r\n                        for (var j = 0; j < i; j++) {\r\n                            dollar += \"$\";\r\n                        }\r\n                        argArray.push(dollar);\r\n                    }\r\n\r\n                    var args = Array.prototype.join.call(argArray, \",\");\r\n\r\n                    f = new Function(args, \"return \" + expression);\r\n                    funcCache[expression] = f;\r\n                    return f;\r\n                }\r\n                else {\r\n                    var expr = expression.match(/^[(\\s]*([^()]*?)[)\\s]*=>(.*)/);\r\n                    f = new Function(expr[1], (expr[2].match(/\\breturn\\b/) ? expr[2] : \"return \" + expr[2]));\r\n                    funcCache[expression] = f;\r\n                    return f;\r\n                }\r\n            }\r\n            return expression;\r\n        },\r\n\r\n        isIEnumerable: function (obj) {\r\n            if (typeof Enumerator !== Types.Undefined) {\r\n                try {\r\n                    new Enumerator(obj); // check JScript(IE)'s Enumerator\r\n                    return true;\r\n                }\r\n                catch (e) { }\r\n            }\r\n\r\n            return false;\r\n        },\r\n\r\n        // IE8's defineProperty is defined but cannot use, therefore check defineProperties\r\n        defineProperty: (Object.defineProperties != null)\r\n            ? function (target, methodName, value) {\r\n                Object.defineProperty(target, methodName, {\r\n                    enumerable: false,\r\n                    configurable: true,\r\n                    writable: true,\r\n                    value: value\r\n                })\r\n            }\r\n            : function (target, methodName, value) {\r\n                target[methodName] = value;\r\n            },\r\n\r\n        compare: function (a, b) {\r\n            return (a === b) ? 0\r\n                 : (a > b) ? 1\r\n                 : -1;\r\n        },\r\n\r\n        dispose: function (obj) {\r\n            if (obj != null) obj.dispose();\r\n        },\r\n\r\n        hasNativeIteratorSupport: function () {\r\n            return typeof Symbol !== 'undefined' && typeof Symbol.iterator !== 'undefined';\r\n        }\r\n    };\r\n\r\n    // IEnumerator State\r\n    var State = { Before: 0, Running: 1, After: 2 };\r\n\r\n    // \"Enumerator\" is conflict JScript's \"Enumerator\"\r\n    var IEnumerator = function (initialize, tryGetNext, dispose) {\r\n        var yielder = new Yielder();\r\n        var state = State.Before;\r\n\r\n        this.current = yielder.current;\r\n\r\n        this.moveNext = function () {\r\n            try {\r\n                switch (state) {\r\n                    case State.Before:\r\n                        state = State.Running;\r\n                        initialize();\r\n                        // fall through\r\n                    case State.Running:\r\n                        if (tryGetNext.apply(yielder)) {\r\n                            return true;\r\n                        }\r\n                        else {\r\n                            this.dispose();\r\n                            return false;\r\n                        }\r\n                    case State.After:\r\n                        return false;\r\n                }\r\n            }\r\n            catch (e) {\r\n                this.dispose();\r\n                throw e;\r\n            }\r\n        };\r\n\r\n        this.dispose = function () {\r\n            if (state != State.Running) return;\r\n\r\n            try {\r\n                dispose();\r\n            }\r\n            finally {\r\n                state = State.After;\r\n            }\r\n        };\r\n    };\r\n\r\n    // for tryGetNext\r\n    var Yielder = function () {\r\n        var current = null;\r\n        this.current = function () { return current; };\r\n        this.yieldReturn = function (value) {\r\n            current = value;\r\n            return true;\r\n        };\r\n        this.yieldBreak = function () {\r\n            return false;\r\n        };\r\n    };\r\n\r\n    // Enumerable constuctor\r\n    var Enumerable = function (getEnumerator) {\r\n        this.getEnumerator = getEnumerator;\r\n    };\r\n\r\n    // Utility\r\n\r\n    Enumerable.Utils = {}; // container\r\n\r\n    Enumerable.Utils.createLambda = function (expression) {\r\n        return Utils.createLambda(expression);\r\n    };\r\n\r\n    Enumerable.Utils.createEnumerable = function (getEnumerator) {\r\n        return new Enumerable(getEnumerator);\r\n    };\r\n\r\n    Enumerable.Utils.createEnumerator = function (initialize, tryGetNext, dispose) {\r\n        return new IEnumerator(initialize, tryGetNext, dispose);\r\n    };\r\n\r\n    Enumerable.Utils.extendTo = function (type) {\r\n        var typeProto = type.prototype;\r\n        var enumerableProto;\r\n\r\n        if (type === Array) {\r\n            enumerableProto = ArrayEnumerable.prototype;\r\n            Utils.defineProperty(typeProto, \"getSource\", function () {\r\n                return this;\r\n            });\r\n        }\r\n        else {\r\n            enumerableProto = Enumerable.prototype;\r\n            Utils.defineProperty(typeProto, \"getEnumerator\", function () {\r\n                return Enumerable.from(this).getEnumerator();\r\n            });\r\n        }\r\n\r\n        for (var methodName in enumerableProto) {\r\n            var func = enumerableProto[methodName];\r\n\r\n            // already extended\r\n            if (typeProto[methodName] == func) continue;\r\n\r\n            // already defined(example Array#reverse/join/forEach...)\r\n            if (typeProto[methodName] != null) {\r\n                methodName = methodName + \"ByLinq\";\r\n                if (typeProto[methodName] == func) continue; // recheck\r\n            }\r\n\r\n            if (func instanceof Function) {\r\n                Utils.defineProperty(typeProto, methodName, func);\r\n            }\r\n        }\r\n    };\r\n\r\n    Enumerable.Utils.recallFrom = function (type) {\r\n        var typeProto = type.prototype;\r\n        var enumerableProto;\r\n\r\n        if (type === Array) {\r\n            enumerableProto = ArrayEnumerable.prototype;\r\n            delete typeProto.getSource;\r\n        }\r\n        else {\r\n            enumerableProto = Enumerable.prototype;\r\n            delete typeProto.getEnumerator;\r\n        }\r\n\r\n        for (var methodName in enumerableProto) {\r\n            var func = enumerableProto[methodName];\r\n\r\n            if (typeProto[methodName + 'ByLinq']) {\r\n                delete typeProto[methodName + 'ByLinq'];\r\n            }\r\n            else if (typeProto[methodName] == func && func instanceof Function) {\r\n                delete typeProto[methodName];\r\n            }\r\n        }\r\n    };\r\n\r\n    // Generator\r\n\r\n    Enumerable.choice = function () // variable argument\r\n    {\r\n        var args = arguments;\r\n\r\n        return new Enumerable(function () {\r\n            return new IEnumerator(\r\n                function () {\r\n                    args = (args[0] instanceof Array) ? args[0]\r\n                        : (args[0].getEnumerator != null) ? args[0].toArray()\r\n                        : args;\r\n                },\r\n                function () {\r\n                    return this.yieldReturn(args[Math.floor(Math.random() * args.length)]);\r\n                },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    Enumerable.cycle = function () // variable argument\r\n    {\r\n        var args = arguments;\r\n\r\n        return new Enumerable(function () {\r\n            var index = 0;\r\n            return new IEnumerator(\r\n                function () {\r\n                    args = (args[0] instanceof Array) ? args[0]\r\n                        : (args[0].getEnumerator != null) ? args[0].toArray()\r\n                        : args;\r\n                },\r\n                function () {\r\n                    if (index >= args.length) index = 0;\r\n                    return this.yieldReturn(args[index++]);\r\n                },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    Enumerable.empty = function () {\r\n        return new Enumerable(function () {\r\n            return new IEnumerator(\r\n                Functions.Blank,\r\n                function () { return false; },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    Enumerable.from = function (obj) {\r\n        if (obj == null) {\r\n            return Enumerable.empty();\r\n        }\r\n        if (obj instanceof Enumerable) {\r\n            return obj;\r\n        }\r\n        if (typeof obj == Types.Number || typeof obj == Types.Boolean) {\r\n            return Enumerable.repeat(obj, 1);\r\n        }\r\n        if (typeof obj == Types.String) {\r\n            return new Enumerable(function () {\r\n                var index = 0;\r\n                return new IEnumerator(\r\n                    Functions.Blank,\r\n                    function () {\r\n                        return (index < obj.length) ? this.yieldReturn(obj.charAt(index++)) : false;\r\n                    },\r\n                    Functions.Blank);\r\n            });\r\n        }\r\n        if (typeof obj != Types.Function) {\r\n            // array or array like object\r\n            if (typeof obj.length == Types.Number) {\r\n                return new ArrayEnumerable(obj);\r\n            }\r\n\r\n            // iterable object\r\n            if (typeof Symbol !== 'undefined' && typeof obj[Symbol.iterator] !== 'undefined') {\r\n                return new Enumerable(function () {\r\n                    return new IEnumerator(\r\n                        Functions.Blank,\r\n                        function () {\r\n                            var next = obj.next();\r\n                            return (next.done ? false : (this.yieldReturn(next.value)));\r\n                        },\r\n                        Functions.Blank);\r\n                });\r\n            }\r\n\r\n            // JScript's IEnumerable\r\n            if (!(obj instanceof Object) && Utils.isIEnumerable(obj)) {\r\n                return new Enumerable(function () {\r\n                    var isFirst = true;\r\n                    var enumerator;\r\n                    return new IEnumerator(\r\n                        function () { enumerator = new Enumerator(obj); },\r\n                        function () {\r\n                            if (isFirst) isFirst = false;\r\n                            else enumerator.moveNext();\r\n\r\n                            return (enumerator.atEnd()) ? false : this.yieldReturn(enumerator.item());\r\n                        },\r\n                        Functions.Blank);\r\n                });\r\n            }\r\n\r\n            // WinMD IIterable<T>\r\n            if (typeof Windows === Types.Object && typeof obj.first === Types.Function) {\r\n                return new Enumerable(function () {\r\n                    var isFirst = true;\r\n                    var enumerator;\r\n                    return new IEnumerator(\r\n                        function () { enumerator = obj.first(); },\r\n                        function () {\r\n                            if (isFirst) isFirst = false;\r\n                            else enumerator.moveNext();\r\n\r\n                            return (enumerator.hasCurrent) ? this.yieldReturn(enumerator.current) : this.yieldBreak();\r\n                        },\r\n                        Functions.Blank);\r\n                });\r\n            }\r\n        }\r\n\r\n        // case function/object : Create keyValuePair[]\r\n        return new Enumerable(function () {\r\n            var array = [];\r\n            var index = 0;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    for (var key in obj) {\r\n                        var value = obj[key];\r\n                        if (!(value instanceof Function) && Object.prototype.hasOwnProperty.call(obj, key)) {\r\n                            array.push({ key: key, value: value });\r\n                        }\r\n                    }\r\n                },\r\n                function () {\r\n                    return (index < array.length)\r\n                        ? this.yieldReturn(array[index++])\r\n                        : false;\r\n                },\r\n                Functions.Blank);\r\n        });\r\n    },\r\n\r\n    Enumerable.make = function (element) {\r\n        return Enumerable.repeat(element, 1);\r\n    };\r\n\r\n    // Overload:function(input, pattern)\r\n    // Overload:function(input, pattern, flags)\r\n    Enumerable.matches = function (input, pattern, flags) {\r\n        if (flags == null) flags = \"\";\r\n        if (pattern instanceof RegExp) {\r\n            flags += (pattern.ignoreCase) ? \"i\" : \"\";\r\n            flags += (pattern.multiline) ? \"m\" : \"\";\r\n            pattern = pattern.source;\r\n        }\r\n        if (flags.indexOf(\"g\") === -1) flags += \"g\";\r\n\r\n        return new Enumerable(function () {\r\n            var regex;\r\n            return new IEnumerator(\r\n                function () { regex = new RegExp(pattern, flags); },\r\n                function () {\r\n                    var match = regex.exec(input);\r\n                    return (match) ? this.yieldReturn(match) : false;\r\n                },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    // Overload:function(start, count)\r\n    // Overload:function(start, count, step)\r\n    Enumerable.range = function (start, count, step) {\r\n        if (step == null) step = 1;\r\n\r\n        return new Enumerable(function () {\r\n            var value;\r\n            var index = 0;\r\n\r\n            return new IEnumerator(\r\n                function () { value = start - step; },\r\n                function () {\r\n                    return (index++ < count)\r\n                        ? this.yieldReturn(value += step)\r\n                        : this.yieldBreak();\r\n                },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    // Overload:function(start, count)\r\n    // Overload:function(start, count, step)\r\n    Enumerable.rangeDown = function (start, count, step) {\r\n        if (step == null) step = 1;\r\n\r\n        return new Enumerable(function () {\r\n            var value;\r\n            var index = 0;\r\n\r\n            return new IEnumerator(\r\n                function () { value = start + step; },\r\n                function () {\r\n                    return (index++ < count)\r\n                        ? this.yieldReturn(value -= step)\r\n                        : this.yieldBreak();\r\n                },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    // Overload:function(start, to)\r\n    // Overload:function(start, to, step)\r\n    Enumerable.rangeTo = function (start, to, step) {\r\n        if (step == null) step = 1;\r\n\r\n        if (start < to) {\r\n            return new Enumerable(function () {\r\n                var value;\r\n\r\n                return new IEnumerator(\r\n                function () { value = start - step; },\r\n                function () {\r\n                    var next = value += step;\r\n                    return (next <= to)\r\n                        ? this.yieldReturn(next)\r\n                        : this.yieldBreak();\r\n                },\r\n                Functions.Blank);\r\n            });\r\n        }\r\n        else {\r\n            return new Enumerable(function () {\r\n                var value;\r\n\r\n                return new IEnumerator(\r\n                function () { value = start + step; },\r\n                function () {\r\n                    var next = value -= step;\r\n                    return (next >= to)\r\n                        ? this.yieldReturn(next)\r\n                        : this.yieldBreak();\r\n                },\r\n                Functions.Blank);\r\n            });\r\n        }\r\n    };\r\n\r\n    // Overload:function(element)\r\n    // Overload:function(element, count)\r\n    Enumerable.repeat = function (element, count) {\r\n        if (count != null) return Enumerable.repeat(element).take(count);\r\n\r\n        return new Enumerable(function () {\r\n            return new IEnumerator(\r\n                Functions.Blank,\r\n                function () { return this.yieldReturn(element); },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    Enumerable.repeatWithFinalize = function (initializer, finalizer) {\r\n        initializer = Utils.createLambda(initializer);\r\n        finalizer = Utils.createLambda(finalizer);\r\n\r\n        return new Enumerable(function () {\r\n            var element;\r\n            return new IEnumerator(\r\n                function () { element = initializer(); },\r\n                function () { return this.yieldReturn(element); },\r\n                function () {\r\n                    if (element != null) {\r\n                        finalizer(element);\r\n                        element = null;\r\n                    }\r\n                });\r\n        });\r\n    };\r\n\r\n    // Overload:function(func)\r\n    // Overload:function(func, count)\r\n    Enumerable.generate = function (func, count) {\r\n        if (count != null) return Enumerable.generate(func).take(count);\r\n        func = Utils.createLambda(func);\r\n\r\n        return new Enumerable(function () {\r\n            return new IEnumerator(\r\n                Functions.Blank,\r\n                function () { return this.yieldReturn(func()); },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(start)\r\n    // Overload:function(start, step)\r\n    Enumerable.toInfinity = function (start, step) {\r\n        if (start == null) start = 0;\r\n        if (step == null) step = 1;\r\n\r\n        return new Enumerable(function () {\r\n            var value;\r\n            return new IEnumerator(\r\n                function () { value = start - step; },\r\n                function () { return this.yieldReturn(value += step); },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(start)\r\n    // Overload:function(start, step)\r\n    Enumerable.toNegativeInfinity = function (start, step) {\r\n        if (start == null) start = 0;\r\n        if (step == null) step = 1;\r\n\r\n        return new Enumerable(function () {\r\n            var value;\r\n            return new IEnumerator(\r\n                function () { value = start + step; },\r\n                function () { return this.yieldReturn(value -= step); },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    Enumerable.unfold = function (seed, func) {\r\n        func = Utils.createLambda(func);\r\n\r\n        return new Enumerable(function () {\r\n            var isFirst = true;\r\n            var value;\r\n            return new IEnumerator(\r\n                Functions.Blank,\r\n                function () {\r\n                    if (isFirst) {\r\n                        isFirst = false;\r\n                        value = seed;\r\n                        return this.yieldReturn(value);\r\n                    }\r\n                    value = func(value);\r\n                    return this.yieldReturn(value);\r\n                },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    Enumerable.defer = function (enumerableFactory) {\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = Enumerable.from(enumerableFactory()).getEnumerator(); },\r\n                function () {\r\n                    return (enumerator.moveNext())\r\n                        ? this.yieldReturn(enumerator.current())\r\n                        : this.yieldBreak();\r\n                },\r\n                function () {\r\n                    Utils.dispose(enumerator);\r\n                });\r\n        });\r\n    };\r\n\r\n    // Extension Methods\r\n\r\n    /* Projection and Filtering Methods */\r\n\r\n    // Overload:function(func)\r\n    // Overload:function(func, resultSelector<element>)\r\n    // Overload:function(func, resultSelector<element, nestLevel>)\r\n    Enumerable.prototype.traverseBreadthFirst = function (func, resultSelector) {\r\n        var source = this;\r\n        func = Utils.createLambda(func);\r\n        resultSelector = Utils.createLambda(resultSelector);\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var nestLevel = 0;\r\n            var buffer = [];\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    while (true) {\r\n                        if (enumerator.moveNext()) {\r\n                            buffer.push(enumerator.current());\r\n                            return this.yieldReturn(resultSelector(enumerator.current(), nestLevel));\r\n                        }\r\n\r\n                        var next = Enumerable.from(buffer).selectMany(function (x) { return func(x); });\r\n                        if (!next.any()) {\r\n                            return false;\r\n                        }\r\n                        else {\r\n                            nestLevel++;\r\n                            buffer = [];\r\n                            Utils.dispose(enumerator);\r\n                            enumerator = next.getEnumerator();\r\n                        }\r\n                    }\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    // Overload:function(func)\r\n    // Overload:function(func, resultSelector<element>)\r\n    // Overload:function(func, resultSelector<element, nestLevel>)\r\n    Enumerable.prototype.traverseDepthFirst = function (func, resultSelector) {\r\n        var source = this;\r\n        func = Utils.createLambda(func);\r\n        resultSelector = Utils.createLambda(resultSelector);\r\n\r\n        return new Enumerable(function () {\r\n            var enumeratorStack = [];\r\n            var enumerator;\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    while (true) {\r\n                        if (enumerator.moveNext()) {\r\n                            var value = resultSelector(enumerator.current(), enumeratorStack.length);\r\n                            enumeratorStack.push(enumerator);\r\n                            enumerator = Enumerable.from(func(enumerator.current())).getEnumerator();\r\n                            return this.yieldReturn(value);\r\n                        }\r\n\r\n                        if (enumeratorStack.length <= 0) return false;\r\n                        Utils.dispose(enumerator);\r\n                        enumerator = enumeratorStack.pop();\r\n                    }\r\n                },\r\n                function () {\r\n                    try {\r\n                        Utils.dispose(enumerator);\r\n                    }\r\n                    finally {\r\n                        Enumerable.from(enumeratorStack).forEach(function (s) { s.dispose(); });\r\n                    }\r\n                });\r\n        });\r\n    };\r\n\r\n    Enumerable.prototype.flatten = function () {\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var middleEnumerator = null;\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    while (true) {\r\n                        if (middleEnumerator != null) {\r\n                            if (middleEnumerator.moveNext()) {\r\n                                return this.yieldReturn(middleEnumerator.current());\r\n                            }\r\n                            else {\r\n                                middleEnumerator = null;\r\n                            }\r\n                        }\r\n\r\n                        if (enumerator.moveNext()) {\r\n                            if (enumerator.current() instanceof Array) {\r\n                                Utils.dispose(middleEnumerator);\r\n                                middleEnumerator = Enumerable.from(enumerator.current())\r\n                                    .selectMany(Functions.Identity)\r\n                                    .flatten()\r\n                                    .getEnumerator();\r\n                                continue;\r\n                            }\r\n                            else {\r\n                                return this.yieldReturn(enumerator.current());\r\n                            }\r\n                        }\r\n\r\n                        return false;\r\n                    }\r\n                },\r\n                function () {\r\n                    try {\r\n                        Utils.dispose(enumerator);\r\n                    }\r\n                    finally {\r\n                        Utils.dispose(middleEnumerator);\r\n                    }\r\n                });\r\n        });\r\n    };\r\n\r\n    Enumerable.prototype.pairwise = function (selector) {\r\n        var source = this;\r\n        selector = Utils.createLambda(selector);\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    enumerator = source.getEnumerator();\r\n                    enumerator.moveNext();\r\n                },\r\n                function () {\r\n                    var prev = enumerator.current();\r\n                    return (enumerator.moveNext())\r\n                        ? this.yieldReturn(selector(prev, enumerator.current()))\r\n                        : false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    // Overload:function(func)\r\n    // Overload:function(seed,func<value,element>)\r\n    Enumerable.prototype.scan = function (seed, func) {\r\n        var isUseSeed;\r\n        if (func == null) {\r\n            func = Utils.createLambda(seed); // arguments[0]\r\n            isUseSeed = false;\r\n        } else {\r\n            func = Utils.createLambda(func);\r\n            isUseSeed = true;\r\n        }\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var value;\r\n            var isFirst = true;\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    if (isFirst) {\r\n                        isFirst = false;\r\n                        if (!isUseSeed) {\r\n                            if (enumerator.moveNext()) {\r\n                                return this.yieldReturn(value = enumerator.current());\r\n                            }\r\n                        }\r\n                        else {\r\n                            return this.yieldReturn(value = seed);\r\n                        }\r\n                    }\r\n\r\n                    return (enumerator.moveNext())\r\n                        ? this.yieldReturn(value = func(value, enumerator.current()))\r\n                        : false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    // Overload:function(selector<element>)\r\n    // Overload:function(selector<element,index>)\r\n    Enumerable.prototype.select = function (selector) {\r\n        selector = Utils.createLambda(selector);\r\n\r\n        if (selector.length <= 1) {\r\n            return new WhereSelectEnumerable(this, null, selector);\r\n        }\r\n        else {\r\n            var source = this;\r\n\r\n            return new Enumerable(function () {\r\n                var enumerator;\r\n                var index = 0;\r\n\r\n                return new IEnumerator(\r\n                    function () { enumerator = source.getEnumerator(); },\r\n                    function () {\r\n                        return (enumerator.moveNext())\r\n                            ? this.yieldReturn(selector(enumerator.current(), index++))\r\n                            : false;\r\n                    },\r\n                    function () { Utils.dispose(enumerator); });\r\n            });\r\n        }\r\n    };\r\n\r\n    // Overload:function(collectionSelector<element>)\r\n    // Overload:function(collectionSelector<element,index>)\r\n    // Overload:function(collectionSelector<element>,resultSelector)\r\n    // Overload:function(collectionSelector<element,index>,resultSelector)\r\n    Enumerable.prototype.selectMany = function (collectionSelector, resultSelector) {\r\n        var source = this;\r\n        collectionSelector = Utils.createLambda(collectionSelector);\r\n        if (resultSelector == null) resultSelector = function (a, b) { return b; };\r\n        resultSelector = Utils.createLambda(resultSelector);\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var middleEnumerator = undefined;\r\n            var index = 0;\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    if (middleEnumerator === undefined) {\r\n                        if (!enumerator.moveNext()) return false;\r\n                    }\r\n                    do {\r\n                        if (middleEnumerator == null) {\r\n                            var middleSeq = collectionSelector(enumerator.current(), index++);\r\n                            middleEnumerator = Enumerable.from(middleSeq).getEnumerator();\r\n                        }\r\n                        if (middleEnumerator.moveNext()) {\r\n                            return this.yieldReturn(resultSelector(enumerator.current(), middleEnumerator.current()));\r\n                        }\r\n                        Utils.dispose(middleEnumerator);\r\n                        middleEnumerator = null;\r\n                    } while (enumerator.moveNext());\r\n                    return false;\r\n                },\r\n                function () {\r\n                    try {\r\n                        Utils.dispose(enumerator);\r\n                    }\r\n                    finally {\r\n                        Utils.dispose(middleEnumerator);\r\n                    }\r\n                });\r\n        });\r\n    };\r\n\r\n    // Overload:function(predicate<element>)\r\n    // Overload:function(predicate<element,index>)\r\n    Enumerable.prototype.where = function (predicate) {\r\n        predicate = Utils.createLambda(predicate);\r\n\r\n        if (predicate.length <= 1) {\r\n            return new WhereEnumerable(this, predicate);\r\n        }\r\n        else {\r\n            var source = this;\r\n\r\n            return new Enumerable(function () {\r\n                var enumerator;\r\n                var index = 0;\r\n\r\n                return new IEnumerator(\r\n                    function () { enumerator = source.getEnumerator(); },\r\n                    function () {\r\n                        while (enumerator.moveNext()) {\r\n                            if (predicate(enumerator.current(), index++)) {\r\n                                return this.yieldReturn(enumerator.current());\r\n                            }\r\n                        }\r\n                        return false;\r\n                    },\r\n                    function () { Utils.dispose(enumerator); });\r\n            });\r\n        }\r\n    };\r\n\r\n\r\n    // Overload:function(selector<element>)\r\n    // Overload:function(selector<element,index>)\r\n    Enumerable.prototype.choose = function (selector) {\r\n        selector = Utils.createLambda(selector);\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var index = 0;\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    while (enumerator.moveNext()) {\r\n                        var result = selector(enumerator.current(), index++);\r\n                        if (result != null) {\r\n                            return this.yieldReturn(result);\r\n                        }\r\n                    }\r\n                    return this.yieldBreak();\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    Enumerable.prototype.ofType = function (type) {\r\n        var typeName;\r\n        switch (type) {\r\n            case Number:\r\n                typeName = Types.Number;\r\n                break;\r\n            case String:\r\n                typeName = Types.String;\r\n                break;\r\n            case Boolean:\r\n                typeName = Types.Boolean;\r\n                break;\r\n            case Function:\r\n                typeName = Types.Function;\r\n                break;\r\n            default:\r\n                typeName = null;\r\n                break;\r\n        }\r\n        return (typeName === null)\r\n            ? this.where(function (x) { return x instanceof type; })\r\n            : this.where(function (x) { return typeof x === typeName; });\r\n    };\r\n\r\n    // mutiple arguments, last one is selector, others are enumerable\r\n    Enumerable.prototype.zip = function () {\r\n        var args = arguments;\r\n        var selector = Utils.createLambda(arguments[arguments.length - 1]);\r\n\r\n        var source = this;\r\n        // optimized case:argument is 2\r\n        if (arguments.length == 2) {\r\n            var second = arguments[0];\r\n\r\n            return new Enumerable(function () {\r\n                var firstEnumerator;\r\n                var secondEnumerator;\r\n                var index = 0;\r\n\r\n                return new IEnumerator(\r\n                function () {\r\n                    firstEnumerator = source.getEnumerator();\r\n                    secondEnumerator = Enumerable.from(second).getEnumerator();\r\n                },\r\n                function () {\r\n                    if (firstEnumerator.moveNext() && secondEnumerator.moveNext()) {\r\n                        return this.yieldReturn(selector(firstEnumerator.current(), secondEnumerator.current(), index++));\r\n                    }\r\n                    return false;\r\n                },\r\n                function () {\r\n                    try {\r\n                        Utils.dispose(firstEnumerator);\r\n                    } finally {\r\n                        Utils.dispose(secondEnumerator);\r\n                    }\r\n                });\r\n            });\r\n        }\r\n        else {\r\n            return new Enumerable(function () {\r\n                var enumerators;\r\n                var index = 0;\r\n\r\n                return new IEnumerator(\r\n                function () {\r\n                    var array = Enumerable.make(source)\r\n                        .concat(Enumerable.from(args).takeExceptLast().select(Enumerable.from))\r\n                        .select(function (x) { return x.getEnumerator() })\r\n                        .toArray();\r\n                    enumerators = Enumerable.from(array);\r\n                },\r\n                function () {\r\n                    if (enumerators.all(function (x) { return x.moveNext() })) {\r\n                        var array = enumerators\r\n                            .select(function (x) { return x.current() })\r\n                            .toArray();\r\n                        array.push(index++);\r\n                        return this.yieldReturn(selector.apply(null, array));\r\n                    }\r\n                    else {\r\n                        return this.yieldBreak();\r\n                    }\r\n                },\r\n                function () {\r\n                    Enumerable.from(enumerators).forEach(Utils.dispose);\r\n                });\r\n            });\r\n        }\r\n    };\r\n\r\n    // mutiple arguments\r\n    Enumerable.prototype.merge = function () {\r\n        var args = arguments;\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerators;\r\n            var index = -1;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    enumerators = Enumerable.make(source)\r\n                        .concat(Enumerable.from(args).select(Enumerable.from))\r\n                        .select(function (x) { return x.getEnumerator() })\r\n                        .toArray();\r\n                },\r\n                function () {\r\n                    while (enumerators.length > 0) {\r\n                        index = (index >= enumerators.length - 1) ? 0 : index + 1;\r\n                        var enumerator = enumerators[index];\r\n\r\n                        if (enumerator.moveNext()) {\r\n                            return this.yieldReturn(enumerator.current());\r\n                        }\r\n                        else {\r\n                            enumerator.dispose();\r\n                            enumerators.splice(index--, 1);\r\n                        }\r\n                    }\r\n                    return this.yieldBreak();\r\n                },\r\n                function () {\r\n                    Enumerable.from(enumerators).forEach(Utils.dispose);\r\n                });\r\n        });\r\n    };\r\n\r\n    /* Join Methods */\r\n\r\n    // Overload:function (inner, outerKeySelector, innerKeySelector, resultSelector)\r\n    // Overload:function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector)\r\n    Enumerable.prototype.join = function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector) {\r\n        outerKeySelector = Utils.createLambda(outerKeySelector);\r\n        innerKeySelector = Utils.createLambda(innerKeySelector);\r\n        resultSelector = Utils.createLambda(resultSelector);\r\n        compareSelector = Utils.createLambda(compareSelector);\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var outerEnumerator;\r\n            var lookup;\r\n            var innerElements = null;\r\n            var innerCount = 0;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    outerEnumerator = source.getEnumerator();\r\n                    lookup = Enumerable.from(inner).toLookup(innerKeySelector, Functions.Identity, compareSelector);\r\n                },\r\n                function () {\r\n                    while (true) {\r\n                        if (innerElements != null) {\r\n                            var innerElement = innerElements[innerCount++];\r\n                            if (innerElement !== undefined) {\r\n                                return this.yieldReturn(resultSelector(outerEnumerator.current(), innerElement));\r\n                            }\r\n\r\n                            innerElement = null;\r\n                            innerCount = 0;\r\n                        }\r\n\r\n                        if (outerEnumerator.moveNext()) {\r\n                            var key = outerKeySelector(outerEnumerator.current());\r\n                            innerElements = lookup.get(key).toArray();\r\n                        } else {\r\n                            return false;\r\n                        }\r\n                    }\r\n                },\r\n                function () { Utils.dispose(outerEnumerator); });\r\n        });\r\n    };\r\n\r\n    // Overload:function (inner, outerKeySelector, innerKeySelector, resultSelector)\r\n    // Overload:function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector)\r\n    Enumerable.prototype.groupJoin = function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector) {\r\n        outerKeySelector = Utils.createLambda(outerKeySelector);\r\n        innerKeySelector = Utils.createLambda(innerKeySelector);\r\n        resultSelector = Utils.createLambda(resultSelector);\r\n        compareSelector = Utils.createLambda(compareSelector);\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator = source.getEnumerator();\r\n            var lookup = null;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    enumerator = source.getEnumerator();\r\n                    lookup = Enumerable.from(inner).toLookup(innerKeySelector, Functions.Identity, compareSelector);\r\n                },\r\n                function () {\r\n                    if (enumerator.moveNext()) {\r\n                        var innerElement = lookup.get(outerKeySelector(enumerator.current()));\r\n                        return this.yieldReturn(resultSelector(enumerator.current(), innerElement));\r\n                    }\r\n                    return false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    /* Set Methods */\r\n\r\n    Enumerable.prototype.all = function (predicate) {\r\n        predicate = Utils.createLambda(predicate);\r\n\r\n        var result = true;\r\n        this.forEach(function (x) {\r\n            if (!predicate(x)) {\r\n                result = false;\r\n                return false; // break\r\n            }\r\n        });\r\n        return result;\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(predicate)\r\n    Enumerable.prototype.any = function (predicate) {\r\n        predicate = Utils.createLambda(predicate);\r\n\r\n        var enumerator = this.getEnumerator();\r\n        try {\r\n            if (arguments.length == 0) return enumerator.moveNext(); // case:function()\r\n\r\n            while (enumerator.moveNext()) // case:function(predicate)\r\n            {\r\n                if (predicate(enumerator.current())) return true;\r\n            }\r\n            return false;\r\n        }\r\n        finally {\r\n            Utils.dispose(enumerator);\r\n        }\r\n    };\r\n\r\n    Enumerable.prototype.isEmpty = function () {\r\n        return !this.any();\r\n    };\r\n\r\n    // multiple arguments\r\n    Enumerable.prototype.concat = function () {\r\n        var source = this;\r\n\r\n        if (arguments.length == 1) {\r\n            var second = arguments[0];\r\n\r\n            return new Enumerable(function () {\r\n                var firstEnumerator;\r\n                var secondEnumerator;\r\n\r\n                return new IEnumerator(\r\n                function () { firstEnumerator = source.getEnumerator(); },\r\n                function () {\r\n                    if (secondEnumerator == null) {\r\n                        if (firstEnumerator.moveNext()) return this.yieldReturn(firstEnumerator.current());\r\n                        secondEnumerator = Enumerable.from(second).getEnumerator();\r\n                    }\r\n                    if (secondEnumerator.moveNext()) return this.yieldReturn(secondEnumerator.current());\r\n                    return false;\r\n                },\r\n                function () {\r\n                    try {\r\n                        Utils.dispose(firstEnumerator);\r\n                    }\r\n                    finally {\r\n                        Utils.dispose(secondEnumerator);\r\n                    }\r\n                });\r\n            });\r\n        }\r\n        else {\r\n            var args = arguments;\r\n\r\n            return new Enumerable(function () {\r\n                var enumerators;\r\n\r\n                return new IEnumerator(\r\n                    function () {\r\n                        enumerators = Enumerable.make(source)\r\n                            .concat(Enumerable.from(args).select(Enumerable.from))\r\n                            .select(function (x) { return x.getEnumerator() })\r\n                            .toArray();\r\n                    },\r\n                    function () {\r\n                        while (enumerators.length > 0) {\r\n                            var enumerator = enumerators[0];\r\n\r\n                            if (enumerator.moveNext()) {\r\n                                return this.yieldReturn(enumerator.current());\r\n                            }\r\n                            else {\r\n                                enumerator.dispose();\r\n                                enumerators.splice(0, 1);\r\n                            }\r\n                        }\r\n                        return this.yieldBreak();\r\n                    },\r\n                    function () {\r\n                        Enumerable.from(enumerators).forEach(Utils.dispose);\r\n                    });\r\n            });\r\n        }\r\n    };\r\n\r\n    Enumerable.prototype.insert = function (index, second) {\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var firstEnumerator;\r\n            var secondEnumerator;\r\n            var count = 0;\r\n            var isEnumerated = false;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    firstEnumerator = source.getEnumerator();\r\n                    secondEnumerator = Enumerable.from(second).getEnumerator();\r\n                },\r\n                function () {\r\n                    if (count == index && secondEnumerator.moveNext()) {\r\n                        isEnumerated = true;\r\n                        return this.yieldReturn(secondEnumerator.current());\r\n                    }\r\n                    if (firstEnumerator.moveNext()) {\r\n                        count++;\r\n                        return this.yieldReturn(firstEnumerator.current());\r\n                    }\r\n                    if (!isEnumerated && secondEnumerator.moveNext()) {\r\n                        return this.yieldReturn(secondEnumerator.current());\r\n                    }\r\n                    return false;\r\n                },\r\n                function () {\r\n                    try {\r\n                        Utils.dispose(firstEnumerator);\r\n                    }\r\n                    finally {\r\n                        Utils.dispose(secondEnumerator);\r\n                    }\r\n                });\r\n        });\r\n    };\r\n\r\n    Enumerable.prototype.alternate = function (alternateValueOrSequence) {\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var buffer;\r\n            var enumerator;\r\n            var alternateSequence;\r\n            var alternateEnumerator;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    if (alternateValueOrSequence instanceof Array || alternateValueOrSequence.getEnumerator != null) {\r\n                        alternateSequence = Enumerable.from(Enumerable.from(alternateValueOrSequence).toArray()); // freeze\r\n                    }\r\n                    else {\r\n                        alternateSequence = Enumerable.make(alternateValueOrSequence);\r\n                    }\r\n                    enumerator = source.getEnumerator();\r\n                    if (enumerator.moveNext()) buffer = enumerator.current();\r\n                },\r\n                function () {\r\n                    while (true) {\r\n                        if (alternateEnumerator != null) {\r\n                            if (alternateEnumerator.moveNext()) {\r\n                                return this.yieldReturn(alternateEnumerator.current());\r\n                            }\r\n                            else {\r\n                                alternateEnumerator = null;\r\n                            }\r\n                        }\r\n\r\n                        if (buffer == null && enumerator.moveNext()) {\r\n                            buffer = enumerator.current(); // hasNext\r\n                            alternateEnumerator = alternateSequence.getEnumerator();\r\n                            continue; // GOTO\r\n                        }\r\n                        else if (buffer != null) {\r\n                            var retVal = buffer;\r\n                            buffer = null;\r\n                            return this.yieldReturn(retVal);\r\n                        }\r\n\r\n                        return this.yieldBreak();\r\n                    }\r\n                },\r\n                function () {\r\n                    try {\r\n                        Utils.dispose(enumerator);\r\n                    }\r\n                    finally {\r\n                        Utils.dispose(alternateEnumerator);\r\n                    }\r\n                });\r\n        });\r\n    };\r\n\r\n    // Overload:function(value)\r\n    // Overload:function(value, compareSelector)\r\n    Enumerable.prototype.contains = function (value, compareSelector) {\r\n        compareSelector = Utils.createLambda(compareSelector);\r\n        var enumerator = this.getEnumerator();\r\n        try {\r\n            while (enumerator.moveNext()) {\r\n                if (compareSelector(enumerator.current()) === value) return true;\r\n            }\r\n            return false;\r\n        }\r\n        finally {\r\n            Utils.dispose(enumerator);\r\n        }\r\n    };\r\n\r\n    Enumerable.prototype.defaultIfEmpty = function (defaultValue) {\r\n        var source = this;\r\n        if (defaultValue === undefined) defaultValue = null;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var isFirst = true;\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    if (enumerator.moveNext()) {\r\n                        isFirst = false;\r\n                        return this.yieldReturn(enumerator.current());\r\n                    }\r\n                    else if (isFirst) {\r\n                        isFirst = false;\r\n                        return this.yieldReturn(defaultValue);\r\n                    }\r\n                    return false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(compareSelector)\r\n    Enumerable.prototype.distinct = function (compareSelector) {\r\n        return this.except(Enumerable.empty(), compareSelector);\r\n    };\r\n\r\n    Enumerable.prototype.distinctUntilChanged = function (compareSelector) {\r\n        compareSelector = Utils.createLambda(compareSelector);\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var compareKey;\r\n            var initial;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    enumerator = source.getEnumerator();\r\n                },\r\n                function () {\r\n                    while (enumerator.moveNext()) {\r\n                        var key = compareSelector(enumerator.current());\r\n\r\n                        if (initial) {\r\n                            initial = false;\r\n                            compareKey = key;\r\n                            return this.yieldReturn(enumerator.current());\r\n                        }\r\n\r\n                        if (compareKey === key) {\r\n                            continue;\r\n                        }\r\n\r\n                        compareKey = key;\r\n                        return this.yieldReturn(enumerator.current());\r\n                    }\r\n                    return this.yieldBreak();\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    // Overload:function(second)\r\n    // Overload:function(second, compareSelector)\r\n    Enumerable.prototype.except = function (second, compareSelector) {\r\n        compareSelector = Utils.createLambda(compareSelector);\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var keys;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    enumerator = source.getEnumerator();\r\n                    keys = new Dictionary(compareSelector);\r\n                    Enumerable.from(second).forEach(function (key) { keys.add(key); });\r\n                },\r\n                function () {\r\n                    while (enumerator.moveNext()) {\r\n                        var current = enumerator.current();\r\n                        if (!keys.contains(current)) {\r\n                            keys.add(current);\r\n                            return this.yieldReturn(current);\r\n                        }\r\n                    }\r\n                    return false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    // Overload:function(second)\r\n    // Overload:function(second, compareSelector)\r\n    Enumerable.prototype.intersect = function (second, compareSelector) {\r\n        compareSelector = Utils.createLambda(compareSelector);\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var keys;\r\n            var outs;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    enumerator = source.getEnumerator();\r\n\r\n                    keys = new Dictionary(compareSelector);\r\n                    Enumerable.from(second).forEach(function (key) { keys.add(key); });\r\n                    outs = new Dictionary(compareSelector);\r\n                },\r\n                function () {\r\n                    while (enumerator.moveNext()) {\r\n                        var current = enumerator.current();\r\n                        if (!outs.contains(current) && keys.contains(current)) {\r\n                            outs.add(current);\r\n                            return this.yieldReturn(current);\r\n                        }\r\n                    }\r\n                    return false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    // Overload:function(second)\r\n    // Overload:function(second, compareSelector)\r\n    Enumerable.prototype.sequenceEqual = function (second, compareSelector) {\r\n        compareSelector = Utils.createLambda(compareSelector);\r\n\r\n        var firstEnumerator = this.getEnumerator();\r\n        try {\r\n            var secondEnumerator = Enumerable.from(second).getEnumerator();\r\n            try {\r\n                while (firstEnumerator.moveNext()) {\r\n                    if (!secondEnumerator.moveNext()\r\n                    || compareSelector(firstEnumerator.current()) !== compareSelector(secondEnumerator.current())) {\r\n                        return false;\r\n                    }\r\n                }\r\n\r\n                if (secondEnumerator.moveNext()) return false;\r\n                return true;\r\n            }\r\n            finally {\r\n                Utils.dispose(secondEnumerator);\r\n            }\r\n        }\r\n        finally {\r\n            Utils.dispose(firstEnumerator);\r\n        }\r\n    };\r\n\r\n    Enumerable.prototype.union = function (second, compareSelector) {\r\n        compareSelector = Utils.createLambda(compareSelector);\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var firstEnumerator;\r\n            var secondEnumerator;\r\n            var keys;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    firstEnumerator = source.getEnumerator();\r\n                    keys = new Dictionary(compareSelector);\r\n                },\r\n                function () {\r\n                    var current;\r\n                    if (secondEnumerator === undefined) {\r\n                        while (firstEnumerator.moveNext()) {\r\n                            current = firstEnumerator.current();\r\n                            if (!keys.contains(current)) {\r\n                                keys.add(current);\r\n                                return this.yieldReturn(current);\r\n                            }\r\n                        }\r\n                        secondEnumerator = Enumerable.from(second).getEnumerator();\r\n                    }\r\n                    while (secondEnumerator.moveNext()) {\r\n                        current = secondEnumerator.current();\r\n                        if (!keys.contains(current)) {\r\n                            keys.add(current);\r\n                            return this.yieldReturn(current);\r\n                        }\r\n                    }\r\n                    return false;\r\n                },\r\n                function () {\r\n                    try {\r\n                        Utils.dispose(firstEnumerator);\r\n                    }\r\n                    finally {\r\n                        Utils.dispose(secondEnumerator);\r\n                    }\r\n                });\r\n        });\r\n    };\r\n\r\n    /* Ordering Methods */\r\n\r\n    Enumerable.prototype.orderBy = function (keySelector, comparer) {\r\n        return new OrderedEnumerable(this, keySelector, comparer, false);\r\n    };\r\n\r\n    Enumerable.prototype.orderByDescending = function (keySelector, comparer) {\r\n        return new OrderedEnumerable(this, keySelector, comparer, true);\r\n    };\r\n\r\n    Enumerable.prototype.reverse = function () {\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var buffer;\r\n            var index;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    buffer = source.toArray();\r\n                    index = buffer.length;\r\n                },\r\n                function () {\r\n                    return (index > 0)\r\n                        ? this.yieldReturn(buffer[--index])\r\n                        : false;\r\n                },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    Enumerable.prototype.shuffle = function () {\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var buffer;\r\n\r\n            return new IEnumerator(\r\n                function () { buffer = source.toArray(); },\r\n                function () {\r\n                    if (buffer.length > 0) {\r\n                        var i = Math.floor(Math.random() * buffer.length);\r\n                        return this.yieldReturn(buffer.splice(i, 1)[0]);\r\n                    }\r\n                    return false;\r\n                },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    Enumerable.prototype.weightedSample = function (weightSelector) {\r\n        weightSelector = Utils.createLambda(weightSelector);\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var sortedByBound;\r\n            var totalWeight = 0;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    sortedByBound = source\r\n                        .choose(function (x) {\r\n                            var weight = weightSelector(x);\r\n                            if (weight <= 0) return null; // ignore 0\r\n\r\n                            totalWeight += weight;\r\n                            return { value: x, bound: totalWeight };\r\n                        })\r\n                        .toArray();\r\n                },\r\n                function () {\r\n                    if (sortedByBound.length > 0) {\r\n                        var draw = Math.floor(Math.random() * totalWeight) + 1;\r\n\r\n                        var lower = -1;\r\n                        var upper = sortedByBound.length;\r\n                        while (upper - lower > 1) {\r\n                            var index = Math.floor((lower + upper) / 2);\r\n                            if (sortedByBound[index].bound >= draw) {\r\n                                upper = index;\r\n                            }\r\n                            else {\r\n                                lower = index;\r\n                            }\r\n                        }\r\n\r\n                        return this.yieldReturn(sortedByBound[upper].value);\r\n                    }\r\n\r\n                    return this.yieldBreak();\r\n                },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    /* Grouping Methods */\r\n\r\n    // Overload:function(keySelector)\r\n    // Overload:function(keySelector,elementSelector)\r\n    // Overload:function(keySelector,elementSelector,resultSelector)\r\n    // Overload:function(keySelector,elementSelector,resultSelector,compareSelector)\r\n    Enumerable.prototype.groupBy = function (keySelector, elementSelector, resultSelector, compareSelector) {\r\n        var source = this;\r\n        keySelector = Utils.createLambda(keySelector);\r\n        elementSelector = Utils.createLambda(elementSelector);\r\n        if (resultSelector != null) resultSelector = Utils.createLambda(resultSelector);\r\n        compareSelector = Utils.createLambda(compareSelector);\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    enumerator = source.toLookup(keySelector, elementSelector, compareSelector)\r\n                        .toEnumerable()\r\n                        .getEnumerator();\r\n                },\r\n                function () {\r\n                    while (enumerator.moveNext()) {\r\n                        return (resultSelector == null)\r\n                            ? this.yieldReturn(enumerator.current())\r\n                            : this.yieldReturn(resultSelector(enumerator.current().key(), enumerator.current()));\r\n                    }\r\n                    return false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    // Overload:function(keySelector)\r\n    // Overload:function(keySelector,elementSelector)\r\n    // Overload:function(keySelector,elementSelector,resultSelector)\r\n    // Overload:function(keySelector,elementSelector,resultSelector,compareSelector)\r\n    Enumerable.prototype.partitionBy = function (keySelector, elementSelector, resultSelector, compareSelector) {\r\n\r\n        var source = this;\r\n        keySelector = Utils.createLambda(keySelector);\r\n        elementSelector = Utils.createLambda(elementSelector);\r\n        compareSelector = Utils.createLambda(compareSelector);\r\n        var hasResultSelector;\r\n        if (resultSelector == null) {\r\n            hasResultSelector = false;\r\n            resultSelector = function (key, group) { return new Grouping(key, group); };\r\n        }\r\n        else {\r\n            hasResultSelector = true;\r\n            resultSelector = Utils.createLambda(resultSelector);\r\n        }\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var key;\r\n            var compareKey;\r\n            var group = [];\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    enumerator = source.getEnumerator();\r\n                    if (enumerator.moveNext()) {\r\n                        key = keySelector(enumerator.current());\r\n                        compareKey = compareSelector(key);\r\n                        group.push(elementSelector(enumerator.current()));\r\n                    }\r\n                },\r\n                function () {\r\n                    var hasNext;\r\n                    while ((hasNext = enumerator.moveNext()) == true) {\r\n                        if (compareKey === compareSelector(keySelector(enumerator.current()))) {\r\n                            group.push(elementSelector(enumerator.current()));\r\n                        }\r\n                        else break;\r\n                    }\r\n\r\n                    if (group.length > 0) {\r\n                        var result = (hasResultSelector)\r\n                            ? resultSelector(key, Enumerable.from(group))\r\n                            : resultSelector(key, group);\r\n                        if (hasNext) {\r\n                            key = keySelector(enumerator.current());\r\n                            compareKey = compareSelector(key);\r\n                            group = [elementSelector(enumerator.current())];\r\n                        }\r\n                        else group = [];\r\n\r\n                        return this.yieldReturn(result);\r\n                    }\r\n\r\n                    return false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    Enumerable.prototype.buffer = function (count) {\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    var array = [];\r\n                    var index = 0;\r\n                    while (enumerator.moveNext()) {\r\n                        array.push(enumerator.current());\r\n                        if (++index >= count) return this.yieldReturn(array);\r\n                    }\r\n                    if (array.length > 0) return this.yieldReturn(array);\r\n                    return false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    /* Aggregate Methods */\r\n\r\n    // Overload:function(func)\r\n    // Overload:function(seed,func)\r\n    // Overload:function(seed,func,resultSelector)\r\n    Enumerable.prototype.aggregate = function (seed, func, resultSelector) {\r\n        resultSelector = Utils.createLambda(resultSelector);\r\n        return resultSelector(this.scan(seed, func, resultSelector).last());\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(selector)\r\n    Enumerable.prototype.average = function (selector) {\r\n        selector = Utils.createLambda(selector);\r\n\r\n        var sum = 0;\r\n        var count = 0;\r\n        this.forEach(function (x) {\r\n            sum += selector(x);\r\n            ++count;\r\n        });\r\n\r\n        return sum / count;\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(predicate)\r\n    Enumerable.prototype.count = function (predicate) {\r\n        predicate = (predicate == null) ? Functions.True : Utils.createLambda(predicate);\r\n\r\n        var count = 0;\r\n        this.forEach(function (x, i) {\r\n            if (predicate(x, i))++count;\r\n        });\r\n        return count;\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(selector)\r\n    Enumerable.prototype.max = function (selector) {\r\n        if (selector == null) selector = Functions.Identity;\r\n        return this.select(selector).aggregate(function (a, b) { return (a > b) ? a : b; });\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(selector)\r\n    Enumerable.prototype.min = function (selector) {\r\n        if (selector == null) selector = Functions.Identity;\r\n        return this.select(selector).aggregate(function (a, b) { return (a < b) ? a : b; });\r\n    };\r\n\r\n    Enumerable.prototype.maxBy = function (keySelector) {\r\n        keySelector = Utils.createLambda(keySelector);\r\n        return this.aggregate(function (a, b) { return (keySelector(a) > keySelector(b)) ? a : b; });\r\n    };\r\n\r\n    Enumerable.prototype.minBy = function (keySelector) {\r\n        keySelector = Utils.createLambda(keySelector);\r\n        return this.aggregate(function (a, b) { return (keySelector(a) < keySelector(b)) ? a : b; });\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(selector)\r\n    Enumerable.prototype.sum = function (selector) {\r\n        if (selector == null) selector = Functions.Identity;\r\n        return this.select(selector).aggregate(0, function (a, b) { return a + b; });\r\n    };\r\n\r\n    /* Paging Methods */\r\n\r\n    Enumerable.prototype.elementAt = function (index) {\r\n        var value;\r\n        var found = false;\r\n        this.forEach(function (x, i) {\r\n            if (i == index) {\r\n                value = x;\r\n                found = true;\r\n                return false;\r\n            }\r\n        });\r\n\r\n        if (!found) throw new Error(\"index is less than 0 or greater than or equal to the number of elements in source.\");\r\n        return value;\r\n    };\r\n\r\n    Enumerable.prototype.elementAtOrDefault = function (index, defaultValue) {\r\n        if (defaultValue === undefined) defaultValue = null;\r\n        var value;\r\n        var found = false;\r\n        this.forEach(function (x, i) {\r\n            if (i == index) {\r\n                value = x;\r\n                found = true;\r\n                return false;\r\n            }\r\n        });\r\n\r\n        return (!found) ? defaultValue : value;\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(predicate)\r\n    Enumerable.prototype.first = function (predicate) {\r\n        if (predicate != null) return this.where(predicate).first();\r\n\r\n        var value;\r\n        var found = false;\r\n        this.forEach(function (x) {\r\n            value = x;\r\n            found = true;\r\n            return false;\r\n        });\r\n\r\n        if (!found) throw new Error(\"first:No element satisfies the condition.\");\r\n        return value;\r\n    };\r\n\r\n    Enumerable.prototype.firstOrDefault = function (predicate, defaultValue) {\r\n        if (predicate !== undefined) {\r\n            if (typeof predicate === Types.Function || typeof Utils.createLambda(predicate) === Types.Function) {\r\n                return this.where(predicate).firstOrDefault(undefined, defaultValue);\r\n            }\r\n            defaultValue = predicate;\r\n        }\r\n\r\n        var value;\r\n        var found = false;\r\n        this.forEach(function (x) {\r\n            value = x;\r\n            found = true;\r\n            return false;\r\n        });\r\n        return (!found) ? defaultValue : value;\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(predicate)\r\n    Enumerable.prototype.last = function (predicate) {\r\n        if (predicate != null) return this.where(predicate).last();\r\n\r\n        var value;\r\n        var found = false;\r\n        this.forEach(function (x) {\r\n            found = true;\r\n            value = x;\r\n        });\r\n\r\n        if (!found) throw new Error(\"last:No element satisfies the condition.\");\r\n        return value;\r\n    };\r\n\r\n    Enumerable.prototype.lastOrDefault = function (predicate, defaultValue) {\r\n        if (predicate !== undefined) {\r\n            if (typeof predicate === Types.Function || typeof Utils.createLambda(predicate) === Types.Function) {\r\n                return this.where(predicate).lastOrDefault(undefined, defaultValue);\r\n            }\r\n            defaultValue = predicate;\r\n        }\r\n\r\n        var value;\r\n        var found = false;\r\n        this.forEach(function (x) {\r\n            found = true;\r\n            value = x;\r\n        });\r\n        return (!found) ? defaultValue : value;\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(predicate)\r\n    Enumerable.prototype.single = function (predicate) {\r\n        if (predicate != null) return this.where(predicate).single();\r\n\r\n        var value;\r\n        var found = false;\r\n        this.forEach(function (x) {\r\n            if (!found) {\r\n                found = true;\r\n                value = x;\r\n            } else throw new Error(\"single:sequence contains more than one element.\");\r\n        });\r\n\r\n        if (!found) throw new Error(\"single:No element satisfies the condition.\");\r\n        return value;\r\n    };\r\n\r\n    // Overload:function(defaultValue)\r\n    // Overload:function(defaultValue,predicate)\r\n    Enumerable.prototype.singleOrDefault = function (predicate, defaultValue) {\r\n        if (defaultValue === undefined) defaultValue = null;\r\n        if (predicate != null) return this.where(predicate).singleOrDefault(null, defaultValue);\r\n\r\n        var value;\r\n        var found = false;\r\n        this.forEach(function (x) {\r\n            if (!found) {\r\n                found = true;\r\n                value = x;\r\n            } else throw new Error(\"single:sequence contains more than one element.\");\r\n        });\r\n\r\n        return (!found) ? defaultValue : value;\r\n    };\r\n\r\n    Enumerable.prototype.skip = function (count) {\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var index = 0;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    enumerator = source.getEnumerator();\r\n                    while (index++ < count && enumerator.moveNext()) {\r\n                    }\r\n                    ;\r\n                },\r\n                function () {\r\n                    return (enumerator.moveNext())\r\n                        ? this.yieldReturn(enumerator.current())\r\n                        : false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    // Overload:function(predicate<element>)\r\n    // Overload:function(predicate<element,index>)\r\n    Enumerable.prototype.skipWhile = function (predicate) {\r\n        predicate = Utils.createLambda(predicate);\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var index = 0;\r\n            var isSkipEnd = false;\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    while (!isSkipEnd) {\r\n                        if (enumerator.moveNext()) {\r\n                            if (!predicate(enumerator.current(), index++)) {\r\n                                isSkipEnd = true;\r\n                                return this.yieldReturn(enumerator.current());\r\n                            }\r\n                            continue;\r\n                        } else return false;\r\n                    }\r\n\r\n                    return (enumerator.moveNext())\r\n                        ? this.yieldReturn(enumerator.current())\r\n                        : false;\r\n\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    Enumerable.prototype.take = function (count) {\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var index = 0;\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    return (index++ < count && enumerator.moveNext())\r\n                        ? this.yieldReturn(enumerator.current())\r\n                        : false;\r\n                },\r\n                function () { Utils.dispose(enumerator); }\r\n            );\r\n        });\r\n    };\r\n\r\n    // Overload:function(predicate<element>)\r\n    // Overload:function(predicate<element,index>)\r\n    Enumerable.prototype.takeWhile = function (predicate) {\r\n        predicate = Utils.createLambda(predicate);\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var index = 0;\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    return (enumerator.moveNext() && predicate(enumerator.current(), index++))\r\n                        ? this.yieldReturn(enumerator.current())\r\n                        : false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(count)\r\n    Enumerable.prototype.takeExceptLast = function (count) {\r\n        if (count == null) count = 1;\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            if (count <= 0) return source.getEnumerator(); // do nothing\r\n\r\n            var enumerator;\r\n            var q = [];\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    while (enumerator.moveNext()) {\r\n                        if (q.length == count) {\r\n                            q.push(enumerator.current());\r\n                            return this.yieldReturn(q.shift());\r\n                        }\r\n                        q.push(enumerator.current());\r\n                    }\r\n                    return false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    Enumerable.prototype.takeFromLast = function (count) {\r\n        if (count <= 0 || count == null) return Enumerable.empty();\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var sourceEnumerator;\r\n            var enumerator;\r\n            var q = [];\r\n\r\n            return new IEnumerator(\r\n                function () { sourceEnumerator = source.getEnumerator(); },\r\n                function () {\r\n                    while (sourceEnumerator.moveNext()) {\r\n                        if (q.length == count) q.shift();\r\n                        q.push(sourceEnumerator.current());\r\n                    }\r\n                    if (enumerator == null) {\r\n                        enumerator = Enumerable.from(q).getEnumerator();\r\n                    }\r\n                    return (enumerator.moveNext())\r\n                        ? this.yieldReturn(enumerator.current())\r\n                        : false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    // Overload:function(item)\r\n    // Overload:function(predicate)\r\n    Enumerable.prototype.indexOf = function (item) {\r\n        var found = null;\r\n\r\n        // item as predicate\r\n        if (typeof (item) === Types.Function) {\r\n            this.forEach(function (x, i) {\r\n                if (item(x, i)) {\r\n                    found = i;\r\n                    return false;\r\n                }\r\n            });\r\n        }\r\n        else {\r\n            this.forEach(function (x, i) {\r\n                if (x === item) {\r\n                    found = i;\r\n                    return false;\r\n                }\r\n            });\r\n        }\r\n\r\n        return (found !== null) ? found : -1;\r\n    };\r\n\r\n    // Overload:function(item)\r\n    // Overload:function(predicate)\r\n    Enumerable.prototype.lastIndexOf = function (item) {\r\n        var result = -1;\r\n\r\n        // item as predicate\r\n        if (typeof (item) === Types.Function) {\r\n            this.forEach(function (x, i) {\r\n                if (item(x, i)) result = i;\r\n            });\r\n        }\r\n        else {\r\n            this.forEach(function (x, i) {\r\n                if (x === item) result = i;\r\n            });\r\n        }\r\n\r\n        return result;\r\n    };\r\n\r\n    /* Convert Methods */\r\n\r\n    Enumerable.prototype.cast = function () {\r\n        return this;\r\n    };\r\n\r\n    Enumerable.prototype.asEnumerable = function () {\r\n        return Enumerable.from(this);\r\n    };\r\n\r\n    Enumerable.prototype.toArray = function () {\r\n        var array = [];\r\n        this.forEach(function (x) { array.push(x); });\r\n        return array;\r\n    };\r\n\r\n    // Overload:function(keySelector)\r\n    // Overload:function(keySelector, elementSelector)\r\n    // Overload:function(keySelector, elementSelector, compareSelector)\r\n    Enumerable.prototype.toLookup = function (keySelector, elementSelector, compareSelector) {\r\n        keySelector = Utils.createLambda(keySelector);\r\n        elementSelector = Utils.createLambda(elementSelector);\r\n        compareSelector = Utils.createLambda(compareSelector);\r\n\r\n        var dict = new Dictionary(compareSelector);\r\n        this.forEach(function (x) {\r\n            var key = keySelector(x);\r\n            var element = elementSelector(x);\r\n\r\n            var array = dict.get(key);\r\n            if (array !== undefined) array.push(element);\r\n            else dict.add(key, [element]);\r\n        });\r\n        return new Lookup(dict);\r\n    };\r\n\r\n    Enumerable.prototype.toObject = function (keySelector, elementSelector) {\r\n        keySelector = Utils.createLambda(keySelector);\r\n        elementSelector = Utils.createLambda(elementSelector);\r\n\r\n        var obj = {};\r\n        this.forEach(function (x) {\r\n            obj[keySelector(x)] = elementSelector(x);\r\n        });\r\n        return obj;\r\n    };\r\n\r\n    // Overload:function(keySelector, elementSelector)\r\n    // Overload:function(keySelector, elementSelector, compareSelector)\r\n    Enumerable.prototype.toDictionary = function (keySelector, elementSelector, compareSelector) {\r\n        keySelector = Utils.createLambda(keySelector);\r\n        elementSelector = Utils.createLambda(elementSelector);\r\n        compareSelector = Utils.createLambda(compareSelector);\r\n\r\n        var dict = new Dictionary(compareSelector);\r\n        this.forEach(function (x) {\r\n            dict.add(keySelector(x), elementSelector(x));\r\n        });\r\n        return dict;\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(replacer)\r\n    // Overload:function(replacer, space)\r\n    Enumerable.prototype.toJSONString = function (replacer, space) {\r\n        if (typeof JSON === Types.Undefined || JSON.stringify == null) {\r\n            throw new Error(\"toJSONString can't find JSON.stringify. This works native JSON support Browser or include json2.js\");\r\n        }\r\n        return JSON.stringify(this.toArray(), replacer, space);\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(separator)\r\n    // Overload:function(separator,selector)\r\n    Enumerable.prototype.toJoinedString = function (separator, selector) {\r\n        if (separator == null) separator = \"\";\r\n        if (selector == null) selector = Functions.Identity;\r\n\r\n        return this.select(selector).toArray().join(separator);\r\n    };\r\n\r\n\r\n    /* Action Methods */\r\n\r\n    // Overload:function(action<element>)\r\n    // Overload:function(action<element,index>)\r\n    Enumerable.prototype.doAction = function (action) {\r\n        var source = this;\r\n        action = Utils.createLambda(action);\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n            var index = 0;\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    if (enumerator.moveNext()) {\r\n                        action(enumerator.current(), index++);\r\n                        return this.yieldReturn(enumerator.current());\r\n                    }\r\n                    return false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    // Overload:function(action<element>)\r\n    // Overload:function(action<element,index>)\r\n    // Overload:function(func<element,bool>)\r\n    // Overload:function(func<element,index,bool>)\r\n    Enumerable.prototype.forEach = function (action) {\r\n        action = Utils.createLambda(action);\r\n\r\n        var index = 0;\r\n        var enumerator = this.getEnumerator();\r\n        try {\r\n            while (enumerator.moveNext()) {\r\n                if (action(enumerator.current(), index++) === false) break;\r\n            }\r\n        } finally {\r\n            Utils.dispose(enumerator);\r\n        }\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(separator)\r\n    // Overload:function(separator,selector)\r\n    Enumerable.prototype.write = function (separator, selector) {\r\n        if (separator == null) separator = \"\";\r\n        selector = Utils.createLambda(selector);\r\n\r\n        var isFirst = true;\r\n        this.forEach(function (item) {\r\n            if (isFirst) isFirst = false;\r\n            else document.write(separator);\r\n            document.write(selector(item));\r\n        });\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(selector)\r\n    Enumerable.prototype.writeLine = function (selector) {\r\n        selector = Utils.createLambda(selector);\r\n\r\n        this.forEach(function (item) {\r\n            document.writeln(selector(item) + \"<br />\");\r\n        });\r\n    };\r\n\r\n    Enumerable.prototype.force = function () {\r\n        var enumerator = this.getEnumerator();\r\n\r\n        try {\r\n            while (enumerator.moveNext()) {\r\n            }\r\n        }\r\n        finally {\r\n            Utils.dispose(enumerator);\r\n        }\r\n    };\r\n\r\n    /* Functional Methods */\r\n\r\n    Enumerable.prototype.letBind = function (func) {\r\n        func = Utils.createLambda(func);\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    enumerator = Enumerable.from(func(source)).getEnumerator();\r\n                },\r\n                function () {\r\n                    return (enumerator.moveNext())\r\n                        ? this.yieldReturn(enumerator.current())\r\n                        : false;\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    Enumerable.prototype.share = function () {\r\n        var source = this;\r\n        var sharedEnumerator;\r\n        var disposed = false;\r\n\r\n        return new DisposableEnumerable(function () {\r\n            return new IEnumerator(\r\n                function () {\r\n                    if (sharedEnumerator == null) {\r\n                        sharedEnumerator = source.getEnumerator();\r\n                    }\r\n                },\r\n                function () {\r\n                    if (disposed) throw new Error(\"enumerator is disposed\");\r\n\r\n                    return (sharedEnumerator.moveNext())\r\n                        ? this.yieldReturn(sharedEnumerator.current())\r\n                        : false;\r\n                },\r\n                Functions.Blank\r\n            );\r\n        }, function () {\r\n            disposed = true;\r\n            Utils.dispose(sharedEnumerator);\r\n        });\r\n    };\r\n\r\n    Enumerable.prototype.memoize = function () {\r\n        var source = this;\r\n        var cache;\r\n        var enumerator;\r\n        var disposed = false;\r\n\r\n        return new DisposableEnumerable(function () {\r\n            var index = -1;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    if (enumerator == null) {\r\n                        enumerator = source.getEnumerator();\r\n                        cache = [];\r\n                    }\r\n                },\r\n                function () {\r\n                    if (disposed) throw new Error(\"enumerator is disposed\");\r\n\r\n                    index++;\r\n                    if (cache.length <= index) {\r\n                        return (enumerator.moveNext())\r\n                            ? this.yieldReturn(cache[index] = enumerator.current())\r\n                            : false;\r\n                    }\r\n\r\n                    return this.yieldReturn(cache[index]);\r\n                },\r\n                Functions.Blank\r\n            );\r\n        }, function () {\r\n            disposed = true;\r\n            Utils.dispose(enumerator);\r\n            cache = null;\r\n        });\r\n    };\r\n\r\n    /* Iterator (ES6 for..of) support */\r\n    if (Utils.hasNativeIteratorSupport()) {\r\n        Enumerable.prototype[Symbol.iterator] = function () {\r\n            return {\r\n                enumerator: this.getEnumerator(),\r\n                next: function () {\r\n                    if (this.enumerator.moveNext()) {\r\n                        return {\r\n                            done: false,\r\n                            value: this.enumerator.current()\r\n                        };\r\n                    } else {\r\n                        return { done: true };\r\n                    }\r\n                }\r\n            };\r\n        };\r\n    }\r\n\r\n    /* Error Handling Methods */\r\n\r\n    Enumerable.prototype.catchError = function (handler) {\r\n        handler = Utils.createLambda(handler);\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    try {\r\n                        return (enumerator.moveNext())\r\n                            ? this.yieldReturn(enumerator.current())\r\n                            : false;\r\n                    } catch (e) {\r\n                        handler(e);\r\n                        return false;\r\n                    }\r\n                },\r\n                function () { Utils.dispose(enumerator); });\r\n        });\r\n    };\r\n\r\n    Enumerable.prototype.finallyAction = function (finallyAction) {\r\n        finallyAction = Utils.createLambda(finallyAction);\r\n        var source = this;\r\n\r\n        return new Enumerable(function () {\r\n            var enumerator;\r\n\r\n            return new IEnumerator(\r\n                function () { enumerator = source.getEnumerator(); },\r\n                function () {\r\n                    return (enumerator.moveNext())\r\n                        ? this.yieldReturn(enumerator.current())\r\n                        : false;\r\n                },\r\n                function () {\r\n                    try {\r\n                        Utils.dispose(enumerator);\r\n                    } finally {\r\n                        finallyAction();\r\n                    }\r\n                });\r\n        });\r\n    };\r\n\r\n    /* For Debug Methods */\r\n\r\n    // Overload:function()\r\n    // Overload:function(selector)\r\n    Enumerable.prototype.log = function (selector) {\r\n        selector = Utils.createLambda(selector);\r\n\r\n        return this.doAction(function (item) {\r\n            if (typeof console !== Types.Undefined) {\r\n                console.log(selector(item));\r\n            }\r\n        });\r\n    };\r\n\r\n    // Overload:function()\r\n    // Overload:function(message)\r\n    // Overload:function(message,selector)\r\n    Enumerable.prototype.trace = function (message, selector) {\r\n        if (message == null) message = \"Trace\";\r\n        selector = Utils.createLambda(selector);\r\n\r\n        return this.doAction(function (item) {\r\n            if (typeof console !== Types.Undefined) {\r\n                console.log(message, selector(item));\r\n            }\r\n        });\r\n    };\r\n\r\n    // private\r\n\r\n    var OrderedEnumerable = function (source, keySelector, comparer, descending, parent) {\r\n        this.source = source;\r\n        this.keySelector = Utils.createLambda(keySelector);\r\n        this.descending = descending;\r\n        this.parent = parent;\r\n\r\n        if (comparer)\r\n            this.comparer = Utils.createLambda(comparer);\r\n    };\r\n    OrderedEnumerable.prototype = new Enumerable();\r\n\r\n    OrderedEnumerable.prototype.createOrderedEnumerable = function (keySelector, comparer, descending) {\r\n        return new OrderedEnumerable(this.source, keySelector, comparer, descending, this);\r\n    };\r\n\r\n    OrderedEnumerable.prototype.thenBy = function (keySelector, comparer) {\r\n        return this.createOrderedEnumerable(keySelector, comparer, false);\r\n    };\r\n\r\n    OrderedEnumerable.prototype.thenByDescending = function (keySelector, comparer) {\r\n        return this.createOrderedEnumerable(keySelector, comparer, true);\r\n    };\r\n\r\n    OrderedEnumerable.prototype.getEnumerator = function () {\r\n        var self = this;\r\n        var buffer;\r\n        var indexes;\r\n        var index = 0;\r\n\r\n        return new IEnumerator(\r\n            function () {\r\n                buffer = [];\r\n                indexes = [];\r\n                self.source.forEach(function (item, index) {\r\n                    buffer.push(item);\r\n                    indexes.push(index);\r\n                });\r\n                var sortContext = SortContext.create(self, null);\r\n                sortContext.GenerateKeys(buffer);\r\n\r\n                indexes.sort(function (a, b) { return sortContext.compare(a, b); });\r\n            },\r\n            function () {\r\n                return (index < indexes.length)\r\n                    ? this.yieldReturn(buffer[indexes[index++]])\r\n                    : false;\r\n            },\r\n            Functions.Blank\r\n        );\r\n    };\r\n\r\n    var SortContext = function (keySelector, comparer, descending, child) {\r\n        this.keySelector = keySelector;\r\n        this.descending = descending;\r\n        this.child = child;\r\n        this.comparer = comparer;\r\n        this.keys = null;\r\n    };\r\n\r\n    SortContext.create = function (orderedEnumerable, currentContext) {\r\n        var context = new SortContext(\r\n            orderedEnumerable.keySelector, orderedEnumerable.comparer, orderedEnumerable.descending, currentContext\r\n        );\r\n\r\n        if (orderedEnumerable.parent != null) return SortContext.create(orderedEnumerable.parent, context);\r\n        return context;\r\n    };\r\n\r\n    SortContext.prototype.GenerateKeys = function (source) {\r\n        var len = source.length;\r\n        var keySelector = this.keySelector;\r\n        var keys = new Array(len);\r\n        for (var i = 0; i < len; i++) keys[i] = keySelector(source[i]);\r\n        this.keys = keys;\r\n\r\n        if (this.child != null) this.child.GenerateKeys(source);\r\n    };\r\n\r\n    SortContext.prototype.compare = function (index1, index2) {\r\n        var comparison = this.comparer ?\r\n            this.comparer(this.keys[index1], this.keys[index2]) :\r\n            Utils.compare(this.keys[index1], this.keys[index2]);\r\n\r\n        if (comparison == 0) {\r\n            if (this.child != null) return this.child.compare(index1, index2);\r\n            return Utils.compare(index1, index2);\r\n        }\r\n\r\n        return (this.descending) ? -comparison : comparison;\r\n    };\r\n\r\n    var DisposableEnumerable = function (getEnumerator, dispose) {\r\n        this.dispose = dispose;\r\n        Enumerable.call(this, getEnumerator);\r\n    };\r\n    DisposableEnumerable.prototype = new Enumerable();\r\n\r\n    // optimize array or arraylike object\r\n\r\n    var ArrayEnumerable = function (source) {\r\n        this.getSource = function () { return source; };\r\n    };\r\n    ArrayEnumerable.prototype = new Enumerable();\r\n\r\n    ArrayEnumerable.prototype.any = function (predicate) {\r\n        return (predicate == null)\r\n            ? (this.getSource().length > 0)\r\n            : Enumerable.prototype.any.apply(this, arguments);\r\n    };\r\n\r\n    ArrayEnumerable.prototype.count = function (predicate) {\r\n        return (predicate == null)\r\n            ? this.getSource().length\r\n            : Enumerable.prototype.count.apply(this, arguments);\r\n    };\r\n\r\n    ArrayEnumerable.prototype.elementAt = function (index) {\r\n        var source = this.getSource();\r\n        return (0 <= index && index < source.length)\r\n            ? source[index]\r\n            : Enumerable.prototype.elementAt.apply(this, arguments);\r\n    };\r\n\r\n    ArrayEnumerable.prototype.elementAtOrDefault = function (index, defaultValue) {\r\n        if (defaultValue === undefined) defaultValue = null;\r\n        var source = this.getSource();\r\n        return (0 <= index && index < source.length)\r\n            ? source[index]\r\n            : defaultValue;\r\n    };\r\n\r\n    ArrayEnumerable.prototype.first = function (predicate) {\r\n        var source = this.getSource();\r\n        return (predicate == null && source.length > 0)\r\n            ? source[0]\r\n            : Enumerable.prototype.first.apply(this, arguments);\r\n    };\r\n\r\n    ArrayEnumerable.prototype.firstOrDefault = function (predicate, defaultValue) {\r\n        if (predicate !== undefined) {\r\n            return Enumerable.prototype.firstOrDefault.apply(this, arguments);\r\n        }\r\n        defaultValue = predicate;\r\n\r\n        var source = this.getSource();\r\n        return source.length > 0 ? source[0] : defaultValue;\r\n    };\r\n\r\n    ArrayEnumerable.prototype.last = function (predicate) {\r\n        var source = this.getSource();\r\n        return (predicate == null && source.length > 0)\r\n            ? source[source.length - 1]\r\n            : Enumerable.prototype.last.apply(this, arguments);\r\n    };\r\n\r\n    ArrayEnumerable.prototype.lastOrDefault = function (predicate, defaultValue) {\r\n        if (predicate !== undefined) {\r\n            return Enumerable.prototype.lastOrDefault.apply(this, arguments);\r\n        }\r\n        defaultValue = predicate;\r\n\r\n        var source = this.getSource();\r\n        return source.length > 0 ? source[source.length - 1] : defaultValue;\r\n    };\r\n\r\n    ArrayEnumerable.prototype.skip = function (count) {\r\n        var source = this.getSource();\r\n\r\n        return new Enumerable(function () {\r\n            var index;\r\n\r\n            return new IEnumerator(\r\n                function () { index = (count < 0) ? 0 : count; },\r\n                function () {\r\n                    return (index < source.length)\r\n                        ? this.yieldReturn(source[index++])\r\n                        : false;\r\n                },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    ArrayEnumerable.prototype.takeExceptLast = function (count) {\r\n        if (count == null) count = 1;\r\n        return this.take(this.getSource().length - count);\r\n    };\r\n\r\n    ArrayEnumerable.prototype.takeFromLast = function (count) {\r\n        return this.skip(this.getSource().length - count);\r\n    };\r\n\r\n    ArrayEnumerable.prototype.reverse = function () {\r\n        var source = this.getSource();\r\n\r\n        return new Enumerable(function () {\r\n            var index;\r\n\r\n            return new IEnumerator(\r\n                function () {\r\n                    index = source.length;\r\n                },\r\n                function () {\r\n                    return (index > 0)\r\n                        ? this.yieldReturn(source[--index])\r\n                        : false;\r\n                },\r\n                Functions.Blank);\r\n        });\r\n    };\r\n\r\n    ArrayEnumerable.prototype.sequenceEqual = function (second, compareSelector) {\r\n        if ((second instanceof ArrayEnumerable || second instanceof Array)\r\n            && compareSelector == null\r\n            && Enumerable.from(second).count() != this.count()) {\r\n            return false;\r\n        }\r\n\r\n        return Enumerable.prototype.sequenceEqual.apply(this, arguments);\r\n    };\r\n\r\n    ArrayEnumerable.prototype.toJoinedString = function (separator, selector) {\r\n        var source = this.getSource();\r\n        if (selector != null || !(source instanceof Array)) {\r\n            return Enumerable.prototype.toJoinedString.apply(this, arguments);\r\n        }\r\n\r\n        if (separator == null) separator = \"\";\r\n        return source.join(separator);\r\n    };\r\n\r\n    ArrayEnumerable.prototype.getEnumerator = function () {\r\n        var source = this.getSource();\r\n        var index = -1;\r\n\r\n        // fast and simple enumerator\r\n        return {\r\n            current: function () { return source[index]; },\r\n            moveNext: function () {\r\n                return ++index < source.length;\r\n            },\r\n            dispose: Functions.Blank\r\n        };\r\n    };\r\n\r\n    // optimization for multiple where and multiple select and whereselect\r\n\r\n    var WhereEnumerable = function (source, predicate) {\r\n        this.prevSource = source;\r\n        this.prevPredicate = predicate; // predicate.length always <= 1\r\n    };\r\n    WhereEnumerable.prototype = new Enumerable();\r\n\r\n    WhereEnumerable.prototype.where = function (predicate) {\r\n        predicate = Utils.createLambda(predicate);\r\n\r\n        if (predicate.length <= 1) {\r\n            var prevPredicate = this.prevPredicate;\r\n            var composedPredicate = function (x) { return prevPredicate(x) && predicate(x); };\r\n            return new WhereEnumerable(this.prevSource, composedPredicate);\r\n        }\r\n        else {\r\n            // if predicate use index, can't compose\r\n            return Enumerable.prototype.where.call(this, predicate);\r\n        }\r\n    };\r\n\r\n    WhereEnumerable.prototype.select = function (selector) {\r\n        selector = Utils.createLambda(selector);\r\n\r\n        return (selector.length <= 1)\r\n            ? new WhereSelectEnumerable(this.prevSource, this.prevPredicate, selector)\r\n            : Enumerable.prototype.select.call(this, selector);\r\n    };\r\n\r\n    WhereEnumerable.prototype.getEnumerator = function () {\r\n        var predicate = this.prevPredicate;\r\n        var source = this.prevSource;\r\n        var enumerator;\r\n\r\n        return new IEnumerator(\r\n            function () { enumerator = source.getEnumerator(); },\r\n            function () {\r\n                while (enumerator.moveNext()) {\r\n                    if (predicate(enumerator.current())) {\r\n                        return this.yieldReturn(enumerator.current());\r\n                    }\r\n                }\r\n                return false;\r\n            },\r\n            function () { Utils.dispose(enumerator); });\r\n    };\r\n\r\n    var WhereSelectEnumerable = function (source, predicate, selector) {\r\n        this.prevSource = source;\r\n        this.prevPredicate = predicate; // predicate.length always <= 1 or null\r\n        this.prevSelector = selector; // selector.length always <= 1\r\n    };\r\n    WhereSelectEnumerable.prototype = new Enumerable();\r\n\r\n    WhereSelectEnumerable.prototype.where = function (predicate) {\r\n        predicate = Utils.createLambda(predicate);\r\n\r\n        return (predicate.length <= 1)\r\n            ? new WhereEnumerable(this, predicate)\r\n            : Enumerable.prototype.where.call(this, predicate);\r\n    };\r\n\r\n    WhereSelectEnumerable.prototype.select = function (selector) {\r\n        selector = Utils.createLambda(selector);\r\n\r\n        if (selector.length <= 1) {\r\n            var prevSelector = this.prevSelector;\r\n            var composedSelector = function (x) { return selector(prevSelector(x)); };\r\n            return new WhereSelectEnumerable(this.prevSource, this.prevPredicate, composedSelector);\r\n        }\r\n        else {\r\n            // if selector use index, can't compose\r\n            return Enumerable.prototype.select.call(this, selector);\r\n        }\r\n    };\r\n\r\n    WhereSelectEnumerable.prototype.getEnumerator = function () {\r\n        var predicate = this.prevPredicate;\r\n        var selector = this.prevSelector;\r\n        var source = this.prevSource;\r\n        var enumerator;\r\n\r\n        return new IEnumerator(\r\n            function () { enumerator = source.getEnumerator(); },\r\n            function () {\r\n                while (enumerator.moveNext()) {\r\n                    if (predicate == null || predicate(enumerator.current())) {\r\n                        return this.yieldReturn(selector(enumerator.current()));\r\n                    }\r\n                }\r\n                return false;\r\n            },\r\n            function () { Utils.dispose(enumerator); });\r\n    };\r\n\r\n    // Collections\r\n\r\n    var Dictionary = (function () {\r\n        // static utility methods\r\n        var callHasOwnProperty = function (target, key) {\r\n            return Object.prototype.hasOwnProperty.call(target, key);\r\n        };\r\n\r\n        var computeHashCode = function (obj) {\r\n            if (obj === null) return \"null\";\r\n            if (obj === undefined) return \"undefined\";\r\n\r\n            return (typeof obj.toString === Types.Function)\r\n                ? obj.toString()\r\n                : Object.prototype.toString.call(obj);\r\n        };\r\n\r\n        // LinkedList for Dictionary\r\n        var HashEntry = function (key, value) {\r\n            this.key = key;\r\n            this.value = value;\r\n            this.prev = null;\r\n            this.next = null;\r\n        };\r\n\r\n        var EntryList = function () {\r\n            this.first = null;\r\n            this.last = null;\r\n        };\r\n        EntryList.prototype =\r\n        {\r\n            addLast: function (entry) {\r\n                if (this.last != null) {\r\n                    this.last.next = entry;\r\n                    entry.prev = this.last;\r\n                    this.last = entry;\r\n                } else this.first = this.last = entry;\r\n            },\r\n\r\n            replace: function (entry, newEntry) {\r\n                if (entry.prev != null) {\r\n                    entry.prev.next = newEntry;\r\n                    newEntry.prev = entry.prev;\r\n                } else this.first = newEntry;\r\n\r\n                if (entry.next != null) {\r\n                    entry.next.prev = newEntry;\r\n                    newEntry.next = entry.next;\r\n                } else this.last = newEntry;\r\n\r\n            },\r\n\r\n            remove: function (entry) {\r\n                if (entry.prev != null) entry.prev.next = entry.next;\r\n                else this.first = entry.next;\r\n\r\n                if (entry.next != null) entry.next.prev = entry.prev;\r\n                else this.last = entry.prev;\r\n            }\r\n        };\r\n\r\n        // Overload:function()\r\n        // Overload:function(compareSelector)\r\n        var Dictionary = function (compareSelector) {\r\n            this.countField = 0;\r\n            this.entryList = new EntryList();\r\n            this.buckets = {}; // as Dictionary<string,List<object>>\r\n            this.compareSelector = (compareSelector == null) ? Functions.Identity : compareSelector;\r\n        };\r\n        Dictionary.prototype =\r\n        {\r\n            add: function (key, value) {\r\n                var compareKey = this.compareSelector(key);\r\n                var hash = computeHashCode(compareKey);\r\n                var entry = new HashEntry(key, value);\r\n                if (callHasOwnProperty(this.buckets, hash)) {\r\n                    var array = this.buckets[hash];\r\n                    for (var i = 0; i < array.length; i++) {\r\n                        if (this.compareSelector(array[i].key) === compareKey) {\r\n                            this.entryList.replace(array[i], entry);\r\n                            array[i] = entry;\r\n                            return;\r\n                        }\r\n                    }\r\n                    array.push(entry);\r\n                } else {\r\n                    this.buckets[hash] = [entry];\r\n                }\r\n                this.countField++;\r\n                this.entryList.addLast(entry);\r\n            },\r\n\r\n            get: function (key) {\r\n                var compareKey = this.compareSelector(key);\r\n                var hash = computeHashCode(compareKey);\r\n                if (!callHasOwnProperty(this.buckets, hash)) return undefined;\r\n\r\n                var array = this.buckets[hash];\r\n                for (var i = 0; i < array.length; i++) {\r\n                    var entry = array[i];\r\n                    if (this.compareSelector(entry.key) === compareKey) return entry.value;\r\n                }\r\n                return undefined;\r\n            },\r\n\r\n            set: function (key, value) {\r\n                var compareKey = this.compareSelector(key);\r\n                var hash = computeHashCode(compareKey);\r\n                if (callHasOwnProperty(this.buckets, hash)) {\r\n                    var array = this.buckets[hash];\r\n                    for (var i = 0; i < array.length; i++) {\r\n                        if (this.compareSelector(array[i].key) === compareKey) {\r\n                            var newEntry = new HashEntry(key, value);\r\n                            this.entryList.replace(array[i], newEntry);\r\n                            array[i] = newEntry;\r\n                            return true;\r\n                        }\r\n                    }\r\n                }\r\n                return false;\r\n            },\r\n\r\n            contains: function (key) {\r\n                var compareKey = this.compareSelector(key);\r\n                var hash = computeHashCode(compareKey);\r\n                if (!callHasOwnProperty(this.buckets, hash)) return false;\r\n\r\n                var array = this.buckets[hash];\r\n                for (var i = 0; i < array.length; i++) {\r\n                    if (this.compareSelector(array[i].key) === compareKey) return true;\r\n                }\r\n                return false;\r\n            },\r\n\r\n            clear: function () {\r\n                this.countField = 0;\r\n                this.buckets = {};\r\n                this.entryList = new EntryList();\r\n            },\r\n\r\n            remove: function (key) {\r\n                var compareKey = this.compareSelector(key);\r\n                var hash = computeHashCode(compareKey);\r\n                if (!callHasOwnProperty(this.buckets, hash)) return;\r\n\r\n                var array = this.buckets[hash];\r\n                for (var i = 0; i < array.length; i++) {\r\n                    if (this.compareSelector(array[i].key) === compareKey) {\r\n                        this.entryList.remove(array[i]);\r\n                        array.splice(i, 1);\r\n                        if (array.length == 0) delete this.buckets[hash];\r\n                        this.countField--;\r\n                        return;\r\n                    }\r\n                }\r\n            },\r\n\r\n            count: function () {\r\n                return this.countField;\r\n            },\r\n\r\n            toEnumerable: function () {\r\n                var self = this;\r\n                return new Enumerable(function () {\r\n                    var currentEntry;\r\n\r\n                    return new IEnumerator(\r\n                        function () { currentEntry = self.entryList.first; },\r\n                        function () {\r\n                            if (currentEntry != null) {\r\n                                var result = { key: currentEntry.key, value: currentEntry.value };\r\n                                currentEntry = currentEntry.next;\r\n                                return this.yieldReturn(result);\r\n                            }\r\n                            return false;\r\n                        },\r\n                        Functions.Blank);\r\n                });\r\n            }\r\n        };\r\n\r\n        return Dictionary;\r\n    })();\r\n\r\n    // dictionary = Dictionary<TKey, TValue[]>\r\n    var Lookup = function (dictionary) {\r\n        this.count = function () {\r\n            return dictionary.count();\r\n        };\r\n        this.get = function (key) {\r\n            return Enumerable.from(dictionary.get(key));\r\n        };\r\n        this.contains = function (key) {\r\n            return dictionary.contains(key);\r\n        };\r\n        this.toEnumerable = function () {\r\n            return dictionary.toEnumerable().select(function (kvp) {\r\n                return new Grouping(kvp.key, kvp.value);\r\n            });\r\n        };\r\n    };\r\n\r\n    var Grouping = function (groupKey, elements) {\r\n        this.key = function () {\r\n            return groupKey;\r\n        };\r\n        ArrayEnumerable.call(this, elements);\r\n    };\r\n    Grouping.prototype = new ArrayEnumerable();\r\n\r\n    // module export\r\n    if (typeof define === Types.Function && define.amd) { // AMD\r\n        define(\"linqjs\", [], function () { return Enumerable; });\r\n    }\r\n    else if (typeof module !== Types.Undefined && module.exports) { // Node\r\n        module.exports = Enumerable;\r\n    }\r\n    else {\r\n        root.Enumerable = Enumerable;\r\n    }\r\n})(this);\r\n","/* globals __webpack_amd_options__ */\nmodule.exports = __webpack_amd_options__;\n"],"sourceRoot":""}