This repository has been archived by the owner on Dec 25, 2018. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 36
/
Linq.js.map
1 lines (1 loc) · 228 KB
/
Linq.js.map
1
{"version":3,"sources":["System.Linq/Linq.js","System.Linq/Linq.ts"],"names":["__extends","this","d","b","__","constructor","p","hasOwnProperty","prototype","Object","create","define","require","exports","Values","Arrays","ArrayUtility","Enumerator_1","Types_1","Integer_1","Functions_1","ArrayEnumerator_1","EnumeratorBase_1","Dictionary_1","Queue_1","Utility_1","DisposableBase_1","Exception_1","ObjectDisposedException_1","KeySortedContext_1","createSortContext","orderedEnumerable","currentContext","throwIfDisposed","disposed","className","VOID0","LinqFunctions","_super","LinqFunctions.constructor","LinqFunctions.Greater","LinqFunctions.Lesser","Functions","freeze","UnsupportedEnumerableException","UnsupportedEnumerableException.constructor","Enumerable","Enumerable.constructor","Enumerable.fromArray","Enumerable.from","Enumerable.toArray","Enumerable.getEnumerator","Enumerable._onDispose","Enumerable.choice","Enumerable.cycle","Enumerable.empty","Enumerable.repeat","Enumerable.repeatWithFinalize","Enumerable.make","Enumerable.range","Enumerable.rangeDown","Enumerable.toInfinity","Enumerable.toNegativeInfinity","Enumerable.rangeTo","Enumerable.matches","Enumerable.generate","Enumerable.unfold","Enumerable.defer","Enumerable.forEach","Enumerable.map","Enumerable.max","Enumerable.min","Enumerable.asEnumerable","Enumerable.toLookup","Enumerable.toMap","Enumerable.toDictionary","Enumerable.toJoinedString","Enumerable.doAction","Enumerable.force","Enumerable.skip","Enumerable.skipWhile","Enumerable.take","Enumerable.takeWhile","Enumerable.takeUntil","Enumerable.takeExceptLast","Enumerable.takeFromLast","Enumerable.traverseBreadthFirst","Enumerable.traverseDepthFirst","Enumerable.flatten","Enumerable.pairwise","Enumerable.scan","Enumerable.select","Enumerable.selectMany","Enumerable.choose","Enumerable.where","Enumerable.ofType","Enumerable.except","Enumerable.distinct","Enumerable.distinctUntilChanged","Enumerable.reverse","Enumerable.shuffle","Enumerable.count","Enumerable.all","Enumerable.every","Enumerable.any","Enumerable.some","Enumerable.isEmpty","Enumerable.contains","Enumerable.indexOf","Enumerable.lastIndexOf","Enumerable.defaultIfEmpty","Enumerable.zip","Enumerable.zipMultiple","Enumerable.join","Enumerable.groupJoin","Enumerable.concatWith","Enumerable.merge","Enumerable.concat","Enumerable.insertAt","Enumerable.alternateMultiple","Enumerable.alternateSingle","Enumerable.alternate","Enumerable.intersect","Enumerable.sequenceEqual","Enumerable.union","Enumerable.orderBy","Enumerable.orderUsing","Enumerable.orderUsingReversed","Enumerable.orderByDescending","Enumerable.groupBy","Enumerable.partitionBy","Enumerable.buffer","Enumerable.aggregate","Enumerable.average","value","selector","x","isNaN","sum","NaN","isFinite","sumInfinite","count","Enumerable.maxBy","Enumerable.minBy","Enumerable.sum","Enumerable.product","Enumerable.elementAt","Enumerable.elementAtOrDefault","Enumerable.first","Enumerable.firstOrDefault","Enumerable.last","Enumerable.lastOrDefault","Enumerable.single","Enumerable.singleOrDefault","Enumerable.share","Enumerable.memoize","Enumerable.catchError","Enumerable.finallyAction","ArrayEnumerable","ArrayEnumerable.constructor","ArrayEnumerable._onDispose","get","ArrayEnumerable.source","enumerable","configurable","ArrayEnumerable.toArray","ArrayEnumerable.asEnumerable","ArrayEnumerable.forEach","ArrayEnumerable.any","ArrayEnumerable.count","ArrayEnumerable.elementAt","ArrayEnumerable.elementAtOrDefault","ArrayEnumerable.first","ArrayEnumerable.firstOrDefault","ArrayEnumerable.last","ArrayEnumerable.lastOrDefault","ArrayEnumerable.skip","ArrayEnumerable.takeExceptLast","ArrayEnumerable.takeFromLast","ArrayEnumerable.reverse","ArrayEnumerable.memoize","ArrayEnumerable.sequenceEqual","ArrayEnumerable.toJoinedString","Grouping","Grouping.constructor","Grouping.key","Lookup","Lookup.constructor","Lookup.count","Lookup.get","Lookup.contains","Lookup.getEnumerator","WhereEnumerable","WhereEnumerable.constructor","WhereEnumerable.where","WhereEnumerable.select","WhereEnumerable.getEnumerator","WhereEnumerable._onDispose","WhereSelectEnumerable","WhereSelectEnumerable.constructor","WhereSelectEnumerable.where","WhereSelectEnumerable.select","WhereSelectEnumerable.getEnumerator","WhereSelectEnumerable._onDispose","OrderedEnumerable","OrderedEnumerable.constructor","OrderedEnumerable.createOrderedEnumerable","OrderedEnumerable.thenBy","OrderedEnumerable.thenUsing","OrderedEnumerable.thenByDescending","OrderedEnumerable.thenUsingReversed","OrderedEnumerable.getEnumerator","OrderedEnumerable._onDispose","defineProperty"],"mappings":"AAAA,GAAIA,WAAaC,MAAQA,KAAKD,WAAc,SAAUE,EAAGC,GAErD,QAASC,KAAOH,KAAKI,YAAcH,EADnC,IAAK,GAAII,KAAKH,GAAOA,EAAEI,eAAeD,KAAIJ,EAAEI,GAAKH,EAAEG,GAEnDJ,GAAEM,UAAkB,OAANL,EAAaM,OAAOC,OAAOP,IAAMC,EAAGI,UAAYL,EAAEK,UAAW,GAAIJ,IAEnFO,SAAQ,UAAW,UAAW,oBAAqB,sCAAuC,sCAAuC,+CAAgD,kBAAmB,oBAAqB,sBAAuB,oDAAqD,mDAAoD,gDAAiD,8BAA+B,+BAAgC,sCAAuC,sBAAuB,+CAAgD,kDAAmD,SAAUC,EAASC,EAASC,EAAQC,EAAQC,EAAcC,EAAcC,EAASC,EAAWC,EAAaC,EAAmBC,EAAkBC,EAAcC,EAASC,EAAWC,EAAkBC,EAAaC,EAA2BC,GCQp1B,YAgpHA,SAAAC,GACCC,EACAC,GAAAF,SAAAA,IAAAA,EAAAA,KAGAA,IAAIA,GAAUA,GAAIA,GAAAA,WACjBA,EACAA,EAAkBA,YAClBA,EAAkBA,MAClBA,EAAkBA,SAEnBA,OAAGA,GAAkBA,OACbA,EAAkBA,EAAkBA,OAAQA,GAE7CA,EAMR,QAAAG,GAAyBC,EAAkBC,GAE1CF,GAF0CA,SAAAA,IAAAA,EAAAA,cAEvCA,EAAUA,KAAMA,IAAIA,GAAAA,WAAwBA,GA/oHhD,GAAMG,GAAY,OAGlBC,EAAA,SAAAC,GAAAD,QAAAA,KAA4BE,EAAAA,MAAAA,KAAAA,WAW5BF,MAX4BA,WAAAA,EAAAA,GAE3BA,EAAAA,UAAAA,QAAAA,SAAWA,EAAKA,GAEfG,MAAOA,GAAEA,EAAIA,EAAIA,GAGlBH,EAAAA,UAAAA,OAAAA,SAAUA,EAAKA,GAEdI,MAASA,GAAFA,EAAMA,EAAIA,GAEnBJ,GAX4BjB,EAAAA,YAaxBsB,EAAY,GAAIL,EACpB5B,QAAOkC,OAAOD,EAId,IAAAE,GAAA,SAAAN,GAECM,QAAAA,KAECC,EAAAA,KAAAA,KAAMA,2BAERD,MAN6CA,WAAAA,EAAAA,GAM7CA,GAN6CjB,EAAAA,YAyB7CmB,EAAA,SAAAR,GAICQ,QAAAA,GACWA,EACVA,GAEAC,EAAAA,KAAAA,KAAMA,GAHIA,KAAAA,mBAAAA,EAsgGZD,MA1gGQA,WAAAA,EAAAA,GAaAA,EAAAA,UAAPA,SAAoBA,GAEnBE,MAAOA,IAAIA,GAAmBA,IAQxBF,EAAAA,KAAPA,SAAeA,GAEdG,GAAGA,EAAAA,WAAKA,SAASA,GACjBA,CACCA,GAAGA,YAAkBA,GACpBA,MAAOA,EAERA,IAAGA,MAAMA,QAAQA,GAChBA,MAAOA,IAAIA,GAAmBA,EAE/BA,IAAGA,EAAAA,aAAgBA,GAClBA,MAAOA,IAAIA,GAAWA,WAAIA,MAAAA,GAAOA,iBAElCA,IAAGA,EAAAA,WAAKA,YAAeA,GACtBA,MAAOA,IAAIA,GAAmBA,GAGhCA,KAAMA,IAAIA,IAGJH,EAAAA,QAAPA,SAAkBA,GAEjBI,GAAGA,EAAAA,WAAKA,SAASA,GACjBA,CACCA,GAAGA,MAAMA,QAAQA,GAChBA,MAAOA,GAAOA,OAKfA,IAHGA,EAAAA,WAAKA,YAAeA,KACtBA,EAASA,GAAIA,GAA8BA,IAEzCA,YAAmBA,GACrBA,MAAOA,GAAOA,SAEfA,IAAGA,EAAAA,aAAgBA,GACnBA,CACCA,GAAIA,KAOJA,OANAA,GAAAA,QACCA,EAAOA,gBAAiBA,SAACA,EAAGA,GAE3BA,EAAOA,GAAKA,IAGPA,GAITA,KAAMA,IAAIA,IAKXJ,EAAAA,UAAAA,cAAAA,WAKCK,MAFAA,MAAKA,kBAEEA,KAAKA,sBAMHL,EAAAA,UAAAA,WAAVA,WAECM,EAAAA,UAAMA,WAAUA,KAAAA,MAChBA,KAAKA,mBAAqBA,MAOpBN,EAAAA,OAAPA,SAAiBA,GAEhBO,MAAOA,IAAIA,GACVA,WAAMA,MAAAA,IAAIA,GAAAA,WACTA,KACAA,SAACA,GDvGW,MCwGXA,GAAQA,YAAYA,EAAOA,EAAAA,WAAQA,OAAOA,EAAOA,eAK9CP,EAAAA,MAAPA,SAAgBA,GAEfQ,MAAOA,IAAIA,GACVA,WAECA,GAAIA,GAAeA,CACnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAQA,GAETA,SAACA,GAGAA,MADGA,IAAOA,EAAOA,SAAQA,EAAQA,GAC1BA,EAAQA,YAAYA,EAAOA,WAOhCR,EAAAA,MAAPA,WAECS,MAAOA,IAAIA,GACVA,WAAMA,MAAAA,IAAIA,GAAAA,WACTA,KACAA,EAAUA,UAKNT,EAAAA,OAAPA,SAAiBA,EAAWA,GAE3BU,MAF2BA,UAAAA,IAAAA,EAAAA,EAAAA,GAExBA,MAAMA,IAAiBA,GAAPA,EACXA,EAAWA,QAGhBA,GAAIA,GADAA,SAASA,IAAUA,EAAAA,WAAQA,OAAOA,EAAOA,SAE/CA,WAECA,GAAIA,GAAWA,EACXA,EAAeA,CAEnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAQA,GAGTA,SAACA,GAAWA,MAACA,KAAQA,GAAMA,EAAQA,YAAYA,MAKjDA,WDpIiB,MCqIhBA,IAAIA,GAAAA,WACHA,KACAA,SAACA,GAAWA,MAAAA,GAAQA,YAAYA,QAM7BV,EAAAA,mBAAPA,SACCA,EACAA,GAGAW,MAAOA,IAAIA,GACVA,WAECA,GAAIA,EACJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAUA,KAGXA,SAACA,GAAWA,MAAAA,GAAQA,YAAYA,IAEhCA,WAECA,EAAUA,QAORX,EAAAA,KAAPA,SAAeA,GAEdY,MAAOA,GAAWA,OAAUA,EAASA,IAI/BZ,EAAAA,MAAPA,SACCA,EACAA,EACAA,GAGAa,GALAA,SAAAA,IAAAA,EAAAA,GACAA,SAAAA,IAAAA,EAAAA,EAAAA,GACAA,SAAAA,IAAAA,EAAAA,IAGIA,SAASA,GACZA,KAAMA,IAAIA,OAAMA,mCAEjBA,IAAGA,MAAMA,IAAiBA,GAAPA,EAClBA,MAAOA,GAAWA,OAEnBA,KAAIA,SAASA,GACZA,KAAMA,IAAIA,OAAMA,kCAEjBA,OACGA,IAAIA,GADAA,SAASA,IAAUA,EAAAA,WAAQA,OAAOA,EAAOA,SAE/CA,WAECA,GAAIA,GACAA,EAAWA,EACXA,EAAeA,CAEnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAQA,EACRA,EAAQA,GAGTA,SAACA,GAEAA,GAAIA,GACCA,IAAQA,GACLA,EAAQA,YAAYA,EAK5BA,OAHGA,IAAgBA,EAANA,IACZA,GAASA,GAEHA,KAMVA,WAECA,GAAIA,EAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAQA,GAGTA,SAACA,GAEAA,GAAIA,GAAiBA,CAErBA,OADAA,IAASA,EACFA,EAAQA,YAAYA,QAOzBb,EAAAA,UAAPA,SACCA,EACAA,EACAA,GAIAc,MANAA,UAAAA,IAAAA,EAAAA,GACAA,SAAAA,IAAAA,EAAAA,EAAAA,GACAA,SAAAA,IAAAA,EAAAA,GAEAA,EAAuBA,GAAhBA,KAAKA,IAAIA,GAETA,EAAWA,MAAMA,EAAOA,EAAOA,IAIhCd,EAAAA,WAAPA,SACCA,EACAA,GAEAe,MAHAA,UAAAA,IAAAA,EAAAA,GACAA,SAAAA,IAAAA,EAAAA,GAEOA,EAAWA,MAAMA,EAAOA,EAAAA,EAAUA,IAGnCf,EAAAA,mBAAPA,SACCA,EACAA,GAEAgB,MAHAA,UAAAA,IAAAA,EAAAA,GACAA,SAAAA,IAAAA,EAAAA,GAEOA,EAAWA,UAAUA,EAAOA,EAAAA,EAAUA,IAGvChB,EAAAA,QAAPA,SACCA,EACAA,EACAA,GAEAiB,GAJAA,SAAAA,IAAAA,EAAAA,GACAA,SAAAA,IAAAA,EAAAA,EAAAA,GACAA,SAAAA,IAAAA,EAAAA,IAEIA,SAASA,GACZA,KAAMA,IAAIA,OAAMA,mCAEjBA,IAAGA,MAAMA,GACRA,KAAMA,IAAIA,OAAMA,gCAEjBA,KAAIA,SAASA,GACZA,KAAMA,IAAIA,OAAMA,kCAMjBA,OAHAA,GAAOA,KAAKA,IAAIA,GAGZA,SAASA,GAGNA,GAAIA,GACVA,WAECA,GAAIA,EAEJA,OAAaA,GAANA,EAEJA,GAAIA,GAAAA,WACNA,WAECA,EAAQA,GAGTA,SAACA,GAEAA,GAAIA,GAAwBA,GAAPA,GAAaA,EAAQA,YAAYA,EAKtDA,OAHGA,KACFA,GAASA,GAEHA,IAGNA,GAAIA,GAAAA,WACNA,WAECA,EAAQA,GAGTA,SAACA,GAEAA,GAAIA,GAAiBA,GAAOA,GAAMA,EAAQA,YAAYA,EAKtDA,OAHGA,KACFA,GAASA,GAEHA,MAtCHA,EAAWA,MAAMA,EAAOA,EAAAA,EAAiBA,EAANA,GAAcA,GAAUA,IA6C7DjB,EAAAA,QAAPA,SAAeA,EAAcA,EAAaA,GAAAkB,SAAAA,IAAAA,EAAAA,GAGzCA,IAAIA,SAAcA,EAClBA,IAAGA,GAAMA,EAAAA,WAAKA,OACbA,KAAMA,IAAIA,OAAMA,uCAAyCA,EAAOA,KAWjEA,OATGA,aAAoBA,UAEtBA,GAAUA,EAAkBA,WAAIA,IAAMA,GACtCA,GAAUA,EAAiBA,UAAIA,IAAMA,GACrCA,EAAUA,EAAQA,QAGMA,KAAtBA,EAAMA,QAAQA,OAAYA,GAASA,KAE/BA,GAAIA,GACVA,WAECA,GAAIA,EACJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAQA,GAAIA,QAAOA,EAASA,IAG7BA,SAACA,GAGAA,GAAIA,GAAQA,EAAMA,KAAKA,EACvBA,OAAgBA,QAARA,EAAgBA,EAAQA,YAAYA,IAASA,OAOnDlB,EAAAA,SAAPA,SAAmBA,EAA8BA,GAGhDmB,MAHgDA,UAAAA,IAAAA,EAAAA,EAAAA,GAG7CA,MAAMA,IAAiBA,GAAPA,EACXA,EAAWA,QAIhBA,GAAIA,GAFAA,SAASA,IAAUA,EAAAA,WAAQA,OAAOA,EAAOA,SAG/CA,WAECA,GAAIA,GAAWA,EACXA,EAAeA,CAEnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAQA,GAGTA,SAACA,GAEAA,GAAIA,GAAiBA,GACrBA,OAAeA,GAARA,GAAaA,EAAQA,YAAYA,EAAQA,OAMnDA,WAECA,GAAIA,GAAeA,CACnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAQA,GAGTA,SAACA,GAAWA,MAAAA,GAAQA,YAAYA,EAAQA,WAKrCnB,EAAAA,OAAPA,SAAiBA,EAAQA,EAA6BA,GAErDoB,MAFqDA,UAAAA,IAAAA,GAAAA,GAE9CA,GAAIA,GACVA,WAECA,GACIA,GACAA,EAFAA,EAAeA,CAGnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAQA,EACRA,EAAQA,EACRA,GAAWA,GAGZA,SAACA,GAEAA,GAAIA,GAAIA,GAKRA,OAJGA,GACFA,GAAUA,EAEVA,EAAQA,EAAaA,EAAOA,GACtBA,EAAQA,YAAYA,QAOzBpB,EAAAA,MAAPA,SAAgBA,GAGfqB,MAAOA,IAAIA,GACVA,WAECA,GAAIA,EAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,IAAoBA,iBAGlCA,SAACA,GAAWA,MAAAA,GAAWA,YAAcA,EAAQA,YAAYA,EAAWA,UACpEA,WAECA,EAAAA,QAAQA,QAONrB,EAAAA,QAAPA,SACCA,EACAA,GAEGsB,GAEFA,EAAAA,MAAMA,EAAAA,KAAeA,GAAaA,SAAAA,GAEjCA,EAAAA,QAAkBA,EAAGA,MAKjBtB,EAAAA,IAAPA,SACCA,EACAA,GAGAuB,MAAOA,IAAcA,EAAAA,MAAMA,EAAAA,KAAeA,GAAaA,SAAAA,GAErDA,GAAIA,KAKJA,OAJAA,GAAAA,QAAkBA,EAAGA,SAACA,EAAGA,GAExBA,EAAOA,GAAKA,EAASA,KAEfA,KAMHvB,EAAAA,IAAPA,SAAWA,GAEVwB,MAAOA,GACLA,UAAUA,SAAAA,GAAIA,MAAAA,MAAKA,EAAAA,KAAUA,GAC7BA,UAAUA,EAAUA,UAGhBxB,EAAAA,IAAPA,SAAWA,GAEVyB,MAAOA,GACLA,UAAUA,SAAAA,GAAIA,MAAAA,MAAKA,EAAAA,KAAUA,GAC7BA,UAAUA,EAAUA,SAQvBzB,EAAAA,UAAAA,QAAAA,SAAQA,GAGPsB,GAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAAeA,CAEnBA,GAAAA,MACCA,EAAEA,gBAAiBA,SAAAA,GAGlBA,KAAMA,EAAEA,mBAAqBA,EAAEA,YAEtBA,EAAOA,EAAEA,QAASA,QAAWA,QAQzCtB,EAAAA,UAAAA,QAAAA,SAAQA,GAEPI,GAAIA,KAEJA,OAAGA,GAAkBA,KAAKA,MAAMA,GAAWA,WAE3CA,KAAKA,QAAQA,SAACA,EAAGA,GAEhBA,EAAOA,GAAKA,IAGNA,IAIRJ,EAAAA,UAAAA,aAAAA,WAEC0B,GAAIA,GAAIA,IACRA,OAAOA,IAAIA,GAAcA,WAAMA,MAAAA,GAAEA,mBAIlC1B,EAAAA,UAAAA,SAAAA,SACCA,EACAA,EACAA,GADA2B,SAAAA,IAAAA,EAAsCA,EAAUA,UAChDA,SAAAA,IAAAA,EAA2CA,EAAUA,SAErDA,IAAIA,GAAkCA,GAAIA,GAAAA,WAA2BA,EAYrEA,OAXAA,MAAKA,QACJA,SAAAA,GAECA,GAAIA,GAAMA,EAAYA,GAClBA,EAAUA,EAAgBA,GAE1BA,EAAQA,EAAKA,SAASA,EACvBA,KAAQA,EAAOA,EAAMA,KAAKA,GACxBA,EAAKA,cAAcA,GAAMA,MAGzBA,GAAIA,GAAqBA,IAGjC3B,EAAAA,UAAAA,MAAAA,SACCA,EACAA,GAEA4B,GAAIA,KAKJA,OAJAA,MAAKA,QAAQA,SAAAA,GAEZA,EAAIA,EAAYA,IAAMA,EAAgBA,KAEhCA,GAGR5B,EAAAA,UAAAA,aAAAA,SACCA,EACAA,EACAA,GAAA6B,SAAAA,IAAAA,EAA2CA,EAAUA,SAErDA,IAAIA,GAAgCA,GAAIA,GAAAA,WAAyBA,EAEjEA,OADAA,MAAKA,QAAQA,SAAAA,GAAIA,MAAAA,GAAKA,cAAcA,EAAYA,GAAIA,EAAgBA,MAC7DA,GAGR7B,EAAAA,UAAAA,eAAAA,SAAeA,EAAuBA,GAErC8B,MAFcA,UAAAA,IAAAA,EAAAA,IAAuBA,SAAAA,IAAAA,EAA+BA,EAAUA,UAEvEA,KAAKA,OAAOA,GAAUA,UAAUA,KAAKA,IAY7C9B,EAAAA,UAAAA,SAAAA,SACCA,GAGA+B,GAAIA,GAAIA,KAAMA,GAAYA,EAAEA,iBAE5BA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,EAAeA,CAEnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAgBA,GAEhBA,EAAQA,EACRA,EAAaA,EAAEA,iBAGhBA,SAACA,GAIAA,IAFAA,EAAgBA,GAEVA,EAAWA,YACjBA,CACCA,GAAIA,GAAoBA,EAAOA,EAAWA,QAASA,IAEnDA,IAAGA,KAAeA,GAAwBA,IAAfA,EAC1BA,MAAOA,GAAQA,YAEhBA,IAAkBA,IAAfA,EACFA,MAAOA,GAAQA,YAAYA,EAAWA,SAIxCA,OAAOA,GAGRA,WAECA,EAAAA,QAAQA,MAOXA,WAECA,GAAWA,KAKd/B,EAAAA,UAAAA,MAAAA,SAAMA,GAAAgC,SAAAA,IAAAA,EAAAA,GAGLA,KAAKA,kBAELA,KAAKA,SAASA,SAAAA,GAAWA,MAAAA,MAI1BhC,EAAAA,UAAAA,KAAAA,SAAKA,GAEJiC,GAAIA,GAAIA,IAIRA,IAFAA,EAAEA,mBAEEA,GAASA,MAAMA,IAAgBA,EAANA,EAC5BA,MAAOA,EAERA,KAAIA,SAASA,GACZA,MAAOA,GAAWA,OAEnBA,GAAAA,WAAQA,OAAOA,EAAOA,QAEtBA,IAAIA,GAAWA,CAEfA,OAAOA,MAAKA,SACXA,SAACA,EAAWA,GDxYC,MCyYNA,GAANA,EACGA,EACAA,KAINjC,EAAAA,UAAAA,UAAAA,SAAUA,GAGTkC,KAAKA,iBAELA,IAAIA,IAAmBA,CAEvBA,OAAOA,MAAKA,SACXA,SAACA,EAAWA,GAKXA,MAHGA,KACFA,EAAWA,EAAUA,EAASA,IAExBA,EACJA,EACAA,KAKNlC,EAAAA,UAAAA,KAAAA,SAAKA,GAEJmC,IAAIA,GAASA,MAAMA,IAAgBA,EAANA,EAC5BA,MAAOA,GAAWA,OAEnBA,IAAIA,GAAIA,IAGRA,IAFAA,EAAEA,mBAEEA,SAASA,GACZA,MAAOA,EAERA,GAAAA,WAAQA,OAAOA,EAAOA,QACtBA,IAAIA,GAAIA,CAGRA,OAAOA,GAAEA,SAASA,SAACA,EAAWA,GAAkBA,MAAMA,GAANA,KAGjDnC,EAAAA,UAAAA,UAAAA,SAAUA,GAKToC,MAFAA,MAAKA,kBAEEA,KAAKA,SACXA,SAACA,EAAWA,GD7ZC,MC8ZZA,GAAUA,EAASA,GAChBA,EACAA,KAKNpC,EAAAA,UAAAA,UAAAA,SAAUA,EAAwBA,GAKjCqC,GAFAA,KAAKA,mBAEDA,EACHA,MAAOA,MAAKA,SACXA,SAACA,EAAWA,GDnaI,MCoafA,GAAUA,EAASA,GAChBA,EACAA,GAGNA,IAAIA,IAAgBA,CACpBA,OAAOA,MAAKA,SACXA,SAACA,EAAWA,GAEXA,MAAGA,GACKA,GAERA,EAAQA,EAAUA,EAASA,GAEpBA,MAKVrC,EAAAA,UAAAA,eAAAA,SAAeA,GAAAsC,SAAAA,IAAAA,EAAAA,EAEdA,IAAIA,GAAIA,IAERA,KAAIA,GAASA,MAAMA,IAAiBA,GAAPA,EAC5BA,MAAOA,EAERA,KAAIA,SAASA,GACZA,MAAOA,GAAWA,OAEnBA,GAAAA,WAAQA,OAAOA,EAAOA,QACtBA,IAAIA,GAAIA,CAERA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,CAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,EAAEA,gBACfA,EAAIA,GAAIA,GAAAA,YAGTA,SAACA,GAEAA,KAAMA,EAAWA,YAMhBA,GAHAA,EAAEA,QAAQA,EAAWA,SAGlBA,EAAEA,MAAMA,EAEVA,MAAOA,GAAQA,YAAYA,EAAEA,UAE/BA,QAAOA,GAGRA,WAECA,EAAAA,QAAQA,EAAYA,QAOzBtC,EAAAA,UAAAA,aAAAA,SAAaA,GAEZuC,IAAIA,GAASA,MAAMA,IAAiBA,GAAPA,EAC5BA,MAAOA,GAAWA,OAEnBA,IAAIA,GAAIA,IAERA,OAAIA,UAASA,IAGbA,EAAAA,WAAQA,OAAOA,EAAOA,SAEfA,EAAEA,UAAUA,KAAKA,IAJhBA,EAAEA,WAWXvC,EAAAA,UAAAA,qBAAAA,SACCA,EACAA,GAEAwC,GAAIA,GAAIA,IAERA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GAEAA,EAAcA,EADdA,EAAmBA,CAGvBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAYA,EACZA,KACAA,EAAMA,EACNA,EAAaA,EAAEA,iBAGhBA,SAACA,GAEAA,OACAA,CACCA,GAAGA,EAAWA,WAGbA,MADAA,GAAOA,KAASA,EAAWA,QACpBA,EAAQA,YAAYA,EAAeA,EAAWA,QAASA,GAG/DA,KAAIA,EACHA,MAAOA,GAAQA,YAEhBA,IAAIA,GAAOA,EACTA,UAAaA,GACbA,WAAWA,EAEbA,KAAIA,EAAKA,MAERA,MAAOA,GAAQA,YAIfA,KACAA,KACAA,EAAMA,EACNA,EAAWA,UACXA,EAAaA,EAAKA,kBAKrBA,WAECA,EAAAA,QAAQA,GACRA,EAAOA,OAASA,OAQrBxC,EAAAA,UAAAA,mBAAAA,SACCA,EACAA,GAEAyC,GAAIA,GAAIA,IAERA,OAAOA,IAAIA,GACVA,WAGCA,GACIA,GACAA,EAFAA,IAIJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,EAAEA,gBACfA,EAAMA,GAGPA,SAACA,GAEAA,OACAA,CACCA,GAAGA,EAAWA,WACdA,CACCA,GAAIA,GAAQA,EAAeA,EAAWA,QAASA,EAG/CA,OAFAA,GAAgBA,KAASA,EACzBA,EAAaA,EAAKA,EAAWA,SAASA,gBAC/BA,EAAQA,YAAYA,GAG5BA,GAAQA,GAALA,EAAQA,OAAOA,CAElBA,GAAWA,UACXA,EAAaA,IAAkBA,GAC/BA,EAAgBA,OAASA,IAI3BA,WAECA,IAECA,EAAAA,QAAQA,GDxfK,QC4fbA,EAAAA,aAAaA,SASnBzC,EAAAA,UAAAA,QAAAA,WAEC0C,GAAIA,GAAIA,IAERA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,EAAoCA,IAExCA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,EAAEA,iBAGhBA,SAACA,GAEAA,OACAA,CACCA,GAAqBA,MAAlBA,EACHA,CACCA,GAAGA,EAAiBA,WAEnBA,MAAOA,GAAQA,YAAYA,EAAiBA,QAI5CA,GAAmBA,KAIrBA,GAAGA,EAAWA,WACdA,CACCA,GAAIA,GAAIA,EAAWA,OACnBA,IAAGA,MAAMA,QAAQA,GACjBA,CACCA,EAAiBA,UACjBA,EAAmBA,EAAWA,UAAeA,GAC3CA,WAAWA,EAAUA,UACrBA,UACAA,eACFA,UAIAA,MAAOA,GAAQA,YAAYA,EAAWA,SAIxCA,OAAOA,IAITA,WAECA,EAAAA,QAAQA,EAAYA,QAQzB1C,EAAAA,UAAAA,SAAAA,SAAkBA,GAEjB2C,GAAIA,GAAIA,IAERA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,EAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,EAAEA,gBACfA,EAAWA,YAGZA,SAACA,GAEAA,GAAIA,GAAOA,EAAWA,OACtBA,OAAOA,GAAWA,YACdA,EAAQA,YAAYA,EAASA,EAAMA,EAAWA,WAGnDA,WAECA,EAAAA,QAAQA,QAOb3C,EAAAA,UAAAA,KAAAA,SAAKA,EAAsBA,GAG1B4C,GAAIA,GAAYA,IAAOA,EACnBA,EAAIA,IAERA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,EACAA,CAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,EAAEA,gBACfA,GAAUA,GAGXA,SAACA,GAEAA,MAAGA,IAEFA,GAAUA,EAEHA,EACJA,EAAQA,YAAYA,EAAQA,GAC5BA,EAAWA,YAAcA,EAAQA,YAAYA,EAC7CA,EAAWA,UAGPA,EAAWA,WAChBA,EAAQA,YAAYA,EAAQA,EAAKA,EAAOA,EAAWA,WACnDA,GAGJA,WAECA,EAAAA,QAAQA,QAUb5C,EAAAA,UAAAA,OAAAA,SAAgBA,GAGf6C,GAAIA,GAAIA,KAAMA,GAAYA,EAAEA,iBAE5BA,OAAGA,GAASA,OAAOA,EACXA,GAAIA,GAAsBA,EAAGA,KAAMA,GAEpCA,GAAIA,GACVA,WAECA,GAAIA,GACAA,EAAeA,CAEnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAgBA,GAEhBA,EAAQA,EACRA,EAAaA,EAAEA,iBAGhBA,SAACA,GAIAA,MAFAA,GAAgBA,GAETA,EAAWA,WACfA,EAAQA,YAAYA,EAASA,EAAWA,QAASA,OACjDA,GAGJA,WAECA,EAAAA,QAAQA,MAKXA,WAECA,GAAWA,KAYd7C,EAAAA,UAAAA,WAAAA,SACCA,EACAA,GAEA8C,GAAIA,GAAIA,IAIRA,OAHIA,KACHA,EAAiBA,SAACA,EAAGA,GAAMA,MAAAA,KAErBA,GAAIA,GACVA,WAECA,GAAIA,GACAA,EACAA,EAAeA,CAEnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,EAAEA,gBACfA,EAAmBA,OACnBA,EAAQA,GAGTA,SAACA,GAIAA,GAAGA,IAAmBA,IAAUA,EAAWA,WAC1CA,OAAOA,CAGRA,GACAA,CAGCA,IAAIA,EACJA,CACCA,GAAIA,GAAYA,EAAmBA,EAAWA,QAASA,IAGvDA,KAAIA,EACHA,QAEDA,GAAmBA,EAAAA,KAAeA,GAGnCA,GAAGA,EAAiBA,WACnBA,MAAOA,GAAQA,YACdA,EACCA,EAAWA,QAASA,EAAiBA,SAMxCA,GAAiBA,UACjBA,EAAmBA,WAGdA,EAAWA,WAEjBA,QAAOA,GAGRA,WAECA,EAAAA,QAAQA,EAAYA,GACpBA,EAAaA,KACbA,EAAmBA,UAOxB9C,EAAAA,UAAAA,OAAAA,SAAgBA,GAGf+C,GAAIA,GAAIA,KAAMA,GAAYA,EAAEA,iBAE5BA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,EAAeA,CAEnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAgBA,GAEhBA,EAAQA,EACRA,EAAaA,EAAEA,iBAGhBA,SAACA,GAIAA,IAFAA,EAAgBA,GAEVA,EAAWA,YACjBA,CACCA,GAAIA,GAASA,EAASA,EAAWA,QAASA,IAC1CA,IAAYA,OAATA,GAAiBA,IAASA,EAC5BA,MAAOA,GAAQA,YAAYA,GAG7BA,OAAOA,GAGRA,WAECA,EAAAA,QAAQA,MAKXA,WAECA,GAAWA,KAKd/C,EAAAA,UAAAA,MAAAA,SAAMA,GAGLgD,GAAIA,GAAIA,KAAMA,GAAYA,EAAEA,iBAE5BA,OAAGA,GAAUA,OAAOA,EACZA,GAAIA,GAAgBA,EAAGA,GAExBA,GAAIA,GACVA,WAECA,GAAIA,GACAA,EAAeA,CAEnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAgBA,GAEhBA,EAAQA,EACRA,EAAaA,EAAEA,iBAGhBA,SAACA,GAIAA,IAFAA,EAAgBA,GAEVA,EAAWA,YAEhBA,GAAGA,EAAUA,EAAWA,QAASA,KAChCA,MAAOA,GAAQA,YAAYA,EAAWA,QAExCA,QAAOA,GAGRA,WAECA,EAAAA,QAAQA,MAKXA,WAECA,GAAWA,KAOdhD,EAAAA,UAAAA,OAAAA,SAAcA,GAEbiD,GAAIA,EACJA,QAAYA,GAEXA,IAAKA,QACJA,EAAWA,EAAAA,WAAKA,MAChBA,MACDA,KAAKA,QACJA,EAAWA,EAAAA,WAAKA,MAChBA,MACDA,KAAKA,SACJA,EAAWA,EAAAA,WAAKA,OAChBA,MACDA,KAAKA,UACJA,EAAWA,EAAAA,WAAKA,QAChBA,MACDA,SACCA,MAAwBA,MACtBA,MAAMA,SAAAA,GAAGA,MAAAA,aAAcA,KAE3BA,MAAwBA,MACtBA,MAAMA,SAAAA,GAAGA,aAAOA,KAAIA,KAGvBjD,EAAAA,UAAAA,OAAAA,SACCA,EACAA,GAEAkD,GAAIA,GAAIA,KAAMA,GAAYA,EAAEA,iBAE5BA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,CAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAgBA,GAChBA,EAAaA,EAAEA,gBACfA,EAAOA,GAAIA,GAAAA,WAAuBA,GAC/BA,GACFA,EAAWA,QAAQA,EAAQA,SAAAA,GAAOA,MAAAA,GAAKA,cAAcA,GAAKA,MAG5DA,SAACA,GAGAA,IADAA,EAAgBA,GACVA,EAAWA,YACjBA,CACCA,GAAIA,GAAUA,EAAWA,OACzBA,KAAIA,EAAKA,YAAYA,GAGpBA,MADAA,GAAKA,cAAcA,GAASA,GACrBA,EAAQA,YAAYA,GAG7BA,OAAOA,GAGRA,WAECA,EAAAA,QAAQA,GACRA,EAAKA,WAKRA,WAECA,GAAWA,KAKdlD,EAAAA,UAAAA,SAAAA,SAASA,GAERmD,MAAOA,MAAKA,OAAOA,KAAMA,IAI1BnD,EAAAA,UAAAA,qBAAAA,SAA+BA,GAG9BoD,GAAIA,GAAIA,KAAMA,GAAYA,EAAEA,iBAE5BA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,EACAA,GAAkBA,CAEtBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAgBA,GAChBA,EAAaA,EAAEA,iBAGhBA,SAACA,GAGAA,IADAA,EAAgBA,GACVA,EAAWA,YACjBA,CACCA,GAAIA,GAAMA,EAAgBA,EAAWA,QAErCA,IAAGA,EAEFA,GAAUA,MAENA,IAAGA,IAAaA,EAEpBA,QAIDA,OADAA,GAAaA,EACNA,EAAQA,YAAYA,EAAWA,SAEvCA,OAAOA,GAGRA,WAECA,EAAAA,QAAQA,MAKXA,WAECA,GAAWA,KAKdpD,EAAAA,UAAAA,QAAAA,WAECqD,GAAIA,GAAIA,KAAMA,GAAYA,EAAEA,iBAE5BA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,EAAeA,CAEnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAgBA,GAChBA,EAASA,EAAEA,UACXA,EAAQA,EAAOA,QAGhBA,SAACA,GDtvBc,MCuvBfA,GAAMA,GACHA,EAAQA,YAAYA,IAASA,KAEhCA,WAECA,EAAOA,OAASA,KAKnBA,WAECA,GAAWA,KAKdrD,EAAAA,UAAAA,QAAAA,WAECsD,GAAIA,GAAIA,KAAMA,GAAYA,EAAEA,iBAE5BA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,EACAA,CAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAgBA,GAChBA,EAASA,EAAEA,UACXA,EAAWA,EAAMA,EAAOA,QAGzBA,SAACA,GAGAA,IAAIA,EACHA,MAAOA,GAAQA,YAEhBA,IAAIA,GAAgBA,EAAAA,WAAQA,OAAOA,GAC/BA,EAAgBA,EAAOA,EAQ3BA,OANAA,GAAOA,GAAiBA,IAASA,GACjCA,EAAOA,GAAOA,KAEXA,EAAIA,IAAIA,IACVA,EAAOA,OAASA,GAEVA,EAAQA,YAAYA,IAG5BA,WAECA,EAAOA,OAASA,KAKnBA,WAECA,GAAWA,KAKdtD,EAAAA,UAAAA,MAAAA,SAAMA,GAGLuD,GAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAAeA,CAgBnBA,OAfGA,GAEFA,EAAEA,QAAQA,SAACA,EAAGA,GAEVA,EAAUA,EAAGA,MAAKA,IAKtBA,EAAEA,QAAQA,aAEPA,IAIGA,GAIRvD,EAAAA,UAAAA,IAAAA,SAAIA,GAEHwD,GAAIA,IAASA,CASbA,OARAA,MAAKA,QAAQA,SAAAA,GAEZA,MAAIA,GAAUA,GAAdA,QAECA,GAASA,GACFA,KAGFA,GAIRxD,EAAAA,UAAAA,MAAAA,SAAMA,GAELyD,MAAOA,MAAKA,IAAIA,IAIjBzD,EAAAA,UAAAA,IAAAA,SAAIA,GAEH0D,GAAIA,IAASA,CAoBbA,OAhBGA,GAEFA,KAAKA,QAAQA,SAAAA,GAGZA,MADAA,GAASA,EAAUA,IACXA,IAKTA,KAAKA,QAAQA,WAGZA,MADAA,IAASA,GACFA,IAGFA,GAKR1D,EAAAA,UAAAA,KAAAA,SAAKA,GAEJ2D,MAAOA,MAAKA,IAAIA,IAGjB3D,EAAAA,UAAAA,QAAAA,WAEC4D,OAAQA,KAAKA,OAGd5D,EAAAA,UAAAA,SAAAA,SAAmBA,EAASA,GAE3B6D,MAAOA,GACJA,KAAKA,IAAIA,SAAAA,GAAIA,MAAAA,GAAgBA,KAAKA,EAAgBA,KAClDA,KAAKA,IAAIA,SAAAA,GAAIA,MAAAA,KAAIA,KAMrB7D,EAAAA,UAAAA,QAAAA,SAAkBA,EAASA,GAE1B8D,GAAIA,GAAeA,EAsBnBA,OApBGA,GACFA,KAAKA,QAAQA,SAACA,EAAWA,GAExBA,MAAGA,GAAOA,SAASA,EAAgBA,GAAUA,EAAgBA,IAAQA,IAEpEA,EAAQA,GACDA,GAHRA,SAODA,KAAKA,QAAQA,SAACA,EAAWA,GAGxBA,MAAGA,GAAOA,SAASA,EAASA,GAAOA,IAElCA,EAAQA,GACDA,GAHRA,SAOKA,GAGR9D,EAAAA,UAAAA,YAAAA,SAAsBA,EAASA,GAE9B+D,GAAIA,GAAgBA,EAcpBA,OAZGA,GACFA,KAAKA,QAAQA,SAACA,EAAWA,GAErBA,EAAOA,SAASA,EAAgBA,GAAUA,EAAgBA,IAAQA,KAAOA,EACzEA,KAGJA,KAAKA,QAAQA,SAACA,EAAWA,GAErBA,EAAOA,SAASA,EAASA,GAAOA,KAAOA,EAASA,KAG9CA,GAGR/D,EAAAA,UAAAA,eAAAA,SAAeA,GAAAgE,SAAAA,IAAAA,EAAAA,KAEdA,IAAIA,GAAIA,KAAMA,GAAoBA,EAAEA,iBAEpCA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,CAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,GAAUA,EACVA,EAAgBA,GAChBA,EAAaA,EAAEA,iBAGhBA,SAACA,GAIAA,MAFAA,GAAgBA,GAEbA,EAAWA,YAEbA,GAAUA,EACHA,EAAQA,YAAYA,EAAWA,UAE/BA,GAEPA,GAAUA,EACHA,EAAQA,YAAYA,KAErBA,GAGRA,WAECA,EAAAA,QAAQA,QAObhE,EAAAA,UAAAA,IAAAA,SACCA,EACAA,GAEAiE,GAAIA,GAAIA,IAERA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,EACAA,EAAeA,CAEnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAQA,EACRA,EAAkBA,EAAEA,gBACpBA,EAAmBA,EAAAA,KAAwBA,IAG5CA,SAACA,GDr2Bc,MCs2BfA,GAAgBA,YAAcA,EAAiBA,YAC5CA,EAAQA,YAAYA,EAAeA,EAAgBA,QAASA,EAAiBA,QAASA,OACzFA,WAECA,EAAAA,QAAQA,EAAiBA,QAO9BjE,EAAAA,UAAAA,YAAAA,SACCA,EACAA,GAEAkE,GAAIA,GAAIA,IAERA,OAAIA,GAAOA,OAGJA,GAAIA,GACVA,WAECA,GAAIA,GACAA,EACAA,EACAA,EAAeA,CAEnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,GAAIA,GAAAA,WAAWA,GAC5BA,EAAQA,EACRA,EAAkBA,EAAEA,gBACpBA,EAAmBA,MAGpBA,SAACA,GAEAA,GAAGA,EAAgBA,WAElBA,OACAA,CACCA,MAAOA,GACPA,CACCA,IAAGA,EAAWA,MAObA,MAAOA,GAAQA,YALfA,IAAIA,GAAOA,EAAWA,SACnBA,KACFA,EAAmBA,EAAAA,KAAwBA,IAM9CA,GAAGA,EAAiBA,WACnBA,MAAOA,GAAQA,YACdA,EAAeA,EAAgBA,QAASA,EAAiBA,QAASA,KAGpEA,GAAiBA,UACjBA,EAAmBA,KAIrBA,MAAOA,GAAQA,cAGhBA,WAECA,EAAAA,QAAQA,EAAiBA,OApDrBA,EAAWA,SA6DpBlE,EAAAA,UAAAA,KAAAA,SACCA,EACAA,EACAA,EACAA,EACAA,GAAAmE,SAAAA,IAAAA,EAA2CA,EAAUA,SAGrDA,IAAIA,GAAIA,IACRA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,EACAA,EAAyBA,KACzBA,EAAoBA,CAExBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAkBA,EAAEA,gBACpBA,EAASA,EAAWA,KAAaA,GAC/BA,SAASA,EAAkBA,EAAUA,SAAUA,IAGlDA,SAACA,GAEAA,OACAA,CACCA,GAAkBA,MAAfA,EACHA,CACCA,GAAIA,GAAeA,EAAcA,IACjCA,IAAGA,IAAeA,EACjBA,MAAOA,GAAQA,YAAYA,EAAeA,EAAgBA,QAASA,GAEpEA,GAAeA,KACfA,EAAaA,EAGdA,IAAGA,EAAgBA,WAOlBA,MAAOA,GAAQA,YALfA,IAAIA,GAAMA,EAAiBA,EAAgBA,QAC3CA,GAAgBA,EAAOA,IAAIA,KAS9BA,WAECA,EAAAA,QAAQA,QAObnE,EAAAA,UAAAA,UAAAA,SACCA,EACAA,EACAA,EACAA,EACAA,GAAAoE,SAAAA,IAAAA,EAA2CA,EAAUA,SAErDA,IAAIA,GAAIA,IAERA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,EAA+BA,IAEnCA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,EAAEA,gBACfA,EAASA,EAAWA,KAAaA,GAC/BA,SAASA,EAAkBA,EAAUA,SAAUA,IAGlDA,SAACA,GD96Bc,MC+6BfA,GAAWA,YACRA,EAAQA,YACVA,EACCA,EAAWA,QACXA,EAAOA,IAAIA,EAAiBA,EAAWA,aAIzCA,WAECA,EAAAA,QAAQA,QAObpE,EAAAA,UAAAA,WAAAA,SAAWA,GAEVqE,GAAIA,GAAIA,IAERA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,CAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAkBA,EAAEA,iBAGrBA,SAACA,GAEAA,GAAoBA,MAAjBA,EACHA,CACCA,GAAGA,EAAgBA,WAAYA,MAAOA,GAAQA,YAAYA,EAAgBA,QAC1EA,GAAmBA,EAAAA,KAAkBA,GACrCA,EAAgBA,UAChBA,EAAkBA,KAEnBA,MAAGA,GAAiBA,WAAmBA,EAAQA,YAAYA,EAAiBA,UACrEA,GAGRA,WAECA,EAAAA,QAAQA,EAAiBA,QAO9BrE,EAAAA,UAAAA,MAAAA,SAAMA,GAELsE,GAAIA,GAAIA,IAERA,OAAIA,GAAYA,OAGOA,GAApBA,EAAYA,OACPA,EAAEA,WAAWA,EAAYA,IAE1BA,GAAIA,GACVA,WAECA,GAAIA,GACAA,CAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAGCA,EAAaA,EAAEA,gBACfA,EAAQA,GAAIA,GAAAA,WAAkCA,IAG/CA,SAACA,GAEAA,OACAA,CAECA,MAAOA,GAAcA,EAAMA,OAE1BA,EAAaA,EAAAA,KAAkBA,EAAMA,UAGtCA,IAAGA,GAAcA,EAAWA,WAC3BA,MAAOA,GAAQA,YAAYA,EAAWA,QAEvCA,EAAAA,IAAGA,EAOHA,MAAOA,GAAQA,YALdA,GAAWA,UACXA,EAAaA,QAQhBA,WAECA,EAAAA,QAAQA,EAAYA,OA7ChBA,GAoDTtE,EAAAA,UAAAA,OAAAA,WDh+BW,ICg+BJuE,GAAAA,MAAAA,EAAAA,EAAAA,EAAAA,UAAAA,OAAAA,IAAAA,EAAAA,EAAAA,GAAAA,UAAAA,EAENA,IAAIA,GAAIA,IACRA,OAAuBA,IAApBA,EAAYA,OACPA,EAEeA,GAApBA,EAAYA,OACPA,EAAEA,WAAWA,EAAYA,IAE1BA,EAAEA,MAAMA,IAIhBvE,EAAAA,UAAAA,SAAAA,SAASA,EAAcA,GAEtBwE,GAAGA,MAAMA,IAAgBA,EAANA,IAAYA,SAASA,GACvCA,KAAMA,IAAIA,OAAMA,uCAEjBA,GAAAA,WAAQA,OAAOA,EAAOA,QACtBA,IAAIA,GAAWA,EAEXA,EAAIA,IAGRA,OAFAA,GAAEA,kBAEKA,GAAIA,GACVA,WAGCA,GAAIA,GACAA,EAEAA,EAAeA,EACfA,GAAuBA,CAE3BA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAQA,EACRA,EAAkBA,EAAEA,gBACpBA,EAAmBA,EAAAA,KAAkBA,GACrCA,GAAeA,GAGhBA,SAACA,GAEAA,MAAGA,IAAOA,IAETA,GAAeA,EACZA,EAAiBA,YACZA,EAAQA,YAAYA,EAAiBA,SAG3CA,EAAgBA,YAElBA,IACOA,EAAQA,YAAYA,EAAgBA,WAGpCA,GACJA,EAAiBA,YACjBA,EAAQA,YAAYA,EAAiBA,UAG1CA,WAECA,EAAAA,QAAQA,EAAiBA,QAQ9BxE,EAAAA,UAAAA,kBAAAA,SAAkBA,GAEjByE,GAAIA,GAAIA,IAERA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,EACAA,EACAA,CAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAGCA,EAAsBA,GAAIA,GAAAA,WACzBA,EAAWA,QAAWA,IAGvBA,EAAaA,EAAEA,eAEfA,IAAIA,GAAgBA,EAAWA,UAC/BA,GAAOA,EACJA,EACAA,EAEAA,IACFA,EAASA,EAAWA,UAGtBA,SAACA,GAEAA,OAAOA,GAENA,IAAKA,GACJA,MAAOA,GAAQA,YAEhBA,KAAKA,GACJA,GAAGA,EAAoBA,WACtBA,MAAOA,GAAQA,YAAYA,EAAoBA,QAChDA,GAAoBA,QACpBA,EAAOA,EAITA,GAAIA,GAASA,EAKTA,EAAUA,EAAWA,UAQzBA,OAPAA,GAAOA,EACJA,EACAA,EAEAA,IACFA,EAASA,EAAWA,SAEdA,EAAQA,YAAYA,IAI5BA,WAECA,EAAAA,QAAQA,EAAYA,QAOzBzE,EAAAA,UAAAA,gBAAAA,SAAgBA,GAEf0E,MAAOA,MAAKA,kBAAkBA,EAAWA,KAAKA,KAG/C1E,EAAAA,UAAAA,UAAAA,WD/hCW,IC+hCD2E,GAAAA,MAAAA,EAAAA,EAAAA,EAAAA,UAAAA,OAAAA,IAAAA,EAAAA,EAAAA,GAAAA,UAAAA,EAETA,OAAOA,MAAKA,kBAAkBA,IAI/B3E,EAAAA,UAAAA,UAAAA,SACCA,EACAA,GAEA4E,GAAIA,GAAIA,IAERA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,EACAA,CAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,EAAEA,gBAEfA,EAAOA,GAAIA,GAAAA,WAAuBA,GAClCA,EAAOA,GAAIA,GAAAA,WAAuBA,GAElCA,EAAWA,KAAQA,GACjBA,QAAQA,SAAAA,GAERA,EAAKA,cAAcA,GAAKA,MAI3BA,SAACA,GAEAA,KAAMA,EAAWA,YACjBA,CACCA,GAAIA,GAAUA,EAAWA,OACzBA,KAAIA,EAAKA,YAAYA,IAAYA,EAAKA,YAAYA,GAGjDA,MADAA,GAAKA,cAAcA,GAASA,GACrBA,EAAQA,YAAYA,GAG7BA,MAAOA,GAAQA,cAGhBA,WAECA,EAAAA,QAAQA,QAOb5E,EAAAA,UAAAA,cAAAA,SACCA,EACAA,GAEA6E,MAFAA,UAAAA,IAAAA,EAAyCA,EAAOA,UAEzCA,EAAAA,MACNA,KAAKA,gBACLA,SAAAA,GAAKA,MAAAA,GAAAA,MACJA,EAAWA,KAAQA,GAAQA,gBAC3BA,SAAAA,GAECA,KAAMA,EAAGA,YAERA,IAAIA,EAAGA,aAAeA,EAAiBA,EAAGA,QAASA,EAAGA,SACrDA,OAAOA,CAGTA,QAAQA,EAAGA,gBAcf7E,EAAAA,UAAAA,MAAAA,SACCA,EACAA,GAAA8E,SAAAA,IAAAA,EAAwCA,EAAUA,SAElDA,IAAIA,GAAIA,IACRA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,GACAA,EACAA,CAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAkBA,EAAEA,gBACpBA,EAAOA,GAAIA,GAAAA,WAAmBA,IAG/BA,SAACA,GAEAA,GAAIA,EACJA,IAAGA,IAAmBA,EACtBA,CACCA,KAAMA,EAAgBA,YAGrBA,GADAA,EAAUA,EAAgBA,SACtBA,EAAKA,YAAYA,GAGpBA,MADAA,GAAKA,cAAcA,EAASA,MACrBA,EAAQA,YAAYA,EAG7BA,GAAmBA,EAAWA,KAAQA,GAAQA,gBAE/CA,KAAMA,EAAiBA,YAGtBA,GADAA,EAAUA,EAAiBA,SACvBA,EAAKA,YAAYA,GAGpBA,MADAA,GAAKA,cAAcA,EAASA,MACrBA,EAAQA,YAAYA,EAG7BA,QAAOA,GAGRA,WAECA,EAAAA,QAAQA,EAAiBA,QAW9B9E,EAAAA,UAAAA,QAAAA,SAAiCA,GAEhC+E,MAFgCA,UAAAA,IAAAA,EAAgCA,EAAUA,UAEnEA,GAAIA,GAA0BA,KAAMA,EAAaA,IAGzD/E,EAAAA,UAAAA,WAAAA,SAAWA,GAEVgF,MAAOA,IAAIA,GAAyBA,KAAMA,KAAMA,EAAiBA,KAAMA,IAGxEhF,EAAAA,UAAAA,mBAAAA,SAAmBA,GAElBiF,MAAOA,IAAIA,GAAyBA,KAAMA,KAAMA,GAAkBA,KAAMA,IAGzEjF,EAAAA,UAAAA,kBAAAA,SAA2CA,GAE1CkF,MAF0CA,UAAAA,IAAAA,EAAgCA,EAAUA,UAE7EA,GAAIA,GAA0BA,KAAMA,EAAaA,KA6DzDlF,EAAAA,UAAAA,QAAAA,SACCA,EACAA,EACAA,GAEAmF,GAAIA,GAAIA,IAERA,OADIA,KAAiBA,EAAkBA,EAAUA,UAC1CA,GAAIA,GACVA,WAAMA,MAAAA,GAAEA,SAASA,EAAaA,EAAiBA,GAC7CA,mBAUJnF,EAAAA,UAAAA,YAAAA,SACCA,EACAA,EACAA,EAEAA,GAFAoF,SAAAA,IAAAA,EACGA,SAACA,EAAUA,GAAwBA,MAAAA,IAAIA,GAAyBA,EAAKA,KACxEA,SAAAA,IAAAA,EACGA,EAAUA,SAGbA,IAAIA,GAAIA,IAERA,OADIA,KAAiBA,EAAkBA,EAAUA,UAC1CA,GAAIA,GACVA,WAECA,GAAIA,GACAA,EACAA,EACAA,EACAA,CAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,EAAEA,gBACZA,EAAWA,YAEbA,EAAMA,EAAYA,EAAWA,SAC7BA,EAAaA,EAAgBA,GAC7BA,GAASA,EAAgBA,EAAWA,UACpCA,EAAMA,GAGNA,EAAQA,MAGVA,SAACA,GAEAA,IAAIA,EACHA,MAAOA,GAAQA,YAGhBA,KADAA,GAAIA,GAAiBA,GACdA,EAAUA,EAAWA,cAE3BA,EAAIA,EAAWA,QACZA,IAAaA,EAAgBA,EAAYA,MAC3CA,EAAMA,KAASA,EAAgBA,EAKjCA,IAAIA,GACGA,EAAeA,EAAKA,EAe3BA,OAbGA,IAEFA,EAAIA,EAAWA,QACfA,EAAMA,EAAYA,GAClBA,EAAaA,EAAgBA,GAC7BA,GAASA,EAAgBA,IACzBA,EAAMA,GAINA,EAAQA,KAGFA,EAAQA,YAAYA,IAG5BA,WAECA,EAAAA,QAAQA,GACRA,EAAQA,UASbpF,EAAAA,UAAAA,OAAAA,SAAOA,GAENqF,GAAQA,EAALA,IAAWA,SAASA,GACtBA,KAAMA,IAAIA,OAAMA,uBAEjBA,GAAAA,WAAQA,OAAOA,EAAMA,OAErBA,IAAcA,GAAVA,EAAIA,IAERA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,EACJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,EAAEA,iBAGhBA,SAACA,GAEAA,GAAIA,GAAYA,EAAaA,WAAcA,EAE3CA,KADAA,EAAMA,EACIA,EAAJA,GAAYA,EAAWA,UAE5BA,EAAMA,KAASA,EAAWA,OAI3BA,OADAA,GAAMA,OAASA,EACRA,GAAOA,EAAQA,YAAYA,IAGnCA,WAECA,EAAAA,QAAQA,QASbrF,EAAAA,UAAAA,UAAAA,SACCA,EACAA,GAEAsF,MAAOA,MAAKA,KAAKA,EAAMA,GAAMA,iBAG9BtF,EAAAA,UAAAA,QAAAA,SAAQA,GAAAuF,SAAAA,IAAAA,EAA+BA,EAAAA,WAAKA,YAE3CA,IAAIA,GAAMA,EAENA,EAAcA,EAEdA,EAAQA,CAmBZA,OAjBAA,MAAKA,QACJA,SAASA,GAER,GAAIC,GAAQC,EAASC,EACrB,OAAGC,OAAMH,IAERI,EAAMC,KACC,IAELC,SAASN,GACXI,GAAOJ,EAEPO,GAAeP,EAAM,EAAI,EAAO,SAC/BQ,KAIDT,EACKA,GAAYA,EAAAA,GAEZA,MAAMA,KAASA,EACpBA,IACCA,EAAIA,GAITvF,EAAAA,UAAAA,IAAAA,WAECwB,MAAOA,MAAKA,UAAUA,EAAUA,UAGjCxB,EAAAA,UAAAA,IAAAA,WAECyB,MAAOA,MAAKA,UAAUA,EAAUA,SAGjCzB,EAAAA,UAAAA,MAAAA,SAAgBA,GAEfiG,MAFeA,UAAAA,IAAAA,EAAoCA,EAAUA,UAEtDA,KAAKA,UAAUA,SAACA,EAAKA,GAAQA,MAACA,GAAYA,GAAGA,EAAYA,GAAMA,EAAIA,KAG3EjG,EAAAA,UAAAA,MAAAA,SAAgBA,GAEfkG,MAFeA,UAAAA,IAAAA,EAAoCA,EAAUA,UAEtDA,KAAKA,UAAUA,SAACA,EAAKA,GAAQA,MAACA,GAAYA,GAAGA,EAAYA,GAAMA,EAAIA,KAI3ElG,EAAAA,UAAAA,IAAAA,SAAIA,GAAAmG,SAAAA,IAAAA,EAA+BA,EAAAA,WAAKA,YAEvCA,IAAIA,GAAMA,EAGNA,EAAcA,CAkBlBA,OAhBAA,MAAKA,QACJA,SAAAA,GAECA,GAAIA,GAAQA,EAASA,EACrBA,OAAGA,OAAMA,IAERA,EAAMA,KACCA,QAELA,SAASA,GACXA,GAAOA,EAEPA,GAAeA,EAAMA,EAAIA,EAAOA,MAI5BA,MAAMA,GAAOA,IAAOA,EAAeA,GAAYA,EAAAA,GAAYA,GAInEnG,EAAAA,UAAAA,QAAAA,SAAQA,GAAAoG,SAAAA,IAAAA,EAA+BA,EAAAA,WAAKA,YAE3CA,IAAIA,GAASA,EAAGA,GAAiBA,CAyBjCA,OAvBAA,MAAKA,QACJA,SAAAA,GAECA,GAASA,CACTA,IAAIA,GAAQA,EAASA,EACrBA,OAAGA,OAAMA,IAERA,EAASA,KACFA,GAGEA,GAAPA,GAEFA,EAASA,GACFA,QAKRA,GAAUA,KAIJA,GAAUA,MAAMA,GAAWA,IAAMA,GAO1CpG,EAAAA,UAAAA,UAAAA,SAAUA,GAETqG,GAAGA,MAAMA,IAAgBA,EAANA,IAAYA,SAASA,GACvCA,KAAMA,IAAIA,OAAMA,uCAEjBA,GAAAA,WAAQA,OAAOA,EAAOA,QACtBA,IAAIA,GAAWA,EAEXA,EAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAAUA,OACVA,GAAQA,CAaZA,IAZAA,EAAEA,QACDA,SAACA,EAAKA,GAELA,MAAGA,IAAGA,GAELA,EAAQA,EACRA,GAAQA,GACDA,GAJRA,UASEA,EAAOA,KAAMA,IAAIA,OAAMA,qFAC3BA,OAAOA,IAGRrG,EAAAA,UAAAA,mBAAAA,SAAmBA,EAAcA,GAGhCsG,GAHgCA,SAAAA,IAAAA,EAAAA,MAG7BA,MAAMA,IAAgBA,EAANA,IAAYA,SAASA,GACvCA,KAAMA,IAAIA,OAAMA,uCAEjBA,GAAAA,WAAQA,OAAOA,EAAOA,QACtBA,IAAIA,GAAWA,EAEXA,EAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAAUA,OACVA,GAAQA,CAaZA,OAZAA,GAAEA,QACDA,SAACA,EAAKA,GAELA,MAAGA,IAAGA,GAELA,EAAQA,EACRA,GAAQA,GACDA,GAJRA,SASOA,EAAwBA,EAAfA,GAYnBtG,EAAAA,UAAAA,MAAAA,WAECuG,GAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAAUA,OACVA,GAAgBA,CAUpBA,IATAA,EAAEA,QACDA,SAAAA,GAICA,MAFAA,GAAQA,EACRA,GAAQA,GACDA,KAILA,EAAOA,KAAMA,IAAIA,OAAMA,4CAC3BA,OAAOA,IAGRvG,EAAAA,UAAAA,eAAAA,SAAeA,GAAAwG,SAAAA,IAAAA,EAAAA,KAEdA,IAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAAUA,OACVA,GAAQA,CASZA,OARAA,GAAEA,QACDA,SAAAA,GAICA,MAFAA,GAAQA,EACRA,GAAQA,GACDA,IAGAA,EAAwBA,EAAfA,GAGnBxG,EAAAA,UAAAA,KAAAA,WAECyG,GAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAAUA,OACVA,GAAgBA,CASpBA,IARAA,EAAEA,QACDA,SAAAA,GAECA,GAAQA,EACRA,EAAQA,KAINA,EAAOA,KAAMA,IAAIA,OAAMA,2CAC3BA,OAAOA,IAGRzG,EAAAA,UAAAA,cAAAA,SAAcA,GAAA0G,SAAAA,IAAAA,EAAAA,KAEbA,IAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAAUA,OACVA,GAAgBA,CAQpBA,OAPAA,GAAEA,QACDA,SAAAA,GAECA,GAAQA,EACRA,EAAQA,IAGDA,EAAwBA,EAAfA,GAGnB1G,EAAAA,UAAAA,OAAAA,WAEC2G,GAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAAUA,OACVA,GAAgBA,CAapBA,IAZAA,EAAEA,QACDA,SAAAA,GAECA,GAAIA,EAKCA,KAAMA,IAAIA,OAAMA,kDAHpBA,IAAQA,EACRA,EAAQA,KAMPA,EAAOA,KAAMA,IAAIA,OAAMA,6CAC3BA,OAAOA,IAGR3G,EAAAA,UAAAA,gBAAAA,SAAgBA,GAAA4G,SAAAA,IAAAA,EAAAA,KAGfA,IAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAAUA,OACVA,GAAgBA,CAapBA,OAZAA,GAAEA,QACDA,SAAAA,GAECA,GAAIA,EAKCA,KAAMA,IAAIA,OAAMA,kDAHpBA,IAAQA,EACRA,EAAQA,IAMFA,EAAwBA,EAAfA,GAKnB5G,EAAAA,UAAAA,MAAAA,WAEC6G,GAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,EACJA,OAAOA,IAAIA,GACVA,WAECA,MAAOA,IAAIA,GAAAA,WACVA,WAIKA,IACHA,EAAmBA,EAAEA,kBAGvBA,SAACA,GD71Cc,MC81CfA,GAAiBA,YACdA,EAAQA,YAAYA,EAAiBA,YAI1CA,WAECA,EAAAA,QAAQA,MAMX7G,EAAAA,UAAAA,QAAAA,WAEC8G,GAEIA,GACAA,EAHAA,EAAIA,KAAMA,GAAoBA,EAAEA,iBAKpCA,OAAOA,IAAIA,GACVA,WAGCA,GAAIA,GAAeA,CAEnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAgBA,GACZA,IACHA,EAAaA,EAAEA,iBACZA,IACHA,MACDA,EAAQA,GAGTA,SAACA,GAEAA,EAAgBA,EAEhBA,IAAIA,GAAIA,GAERA,OAAGA,IAAGA,EAAMA,OAEHA,EAAWA,WAChBA,EAAQA,YAAYA,EAAMA,GAAKA,EAAWA,UAC1CA,EAGGA,EAAQA,YAAYA,EAAMA,OAKpCA,WAECA,GAAWA,EACRA,IACFA,EAAMA,OAASA,GAChBA,EAAQA,KAERA,EAAAA,QAAQA,GACRA,EAAaA,QAMhB9G,EAAAA,UAAAA,WAAAA,SAAWA,GAEV+G,GAAIA,GAAIA,KAAMA,GAAYA,EAAEA,iBAC5BA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,EAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,IAECA,EAAgBA,GAChBA,EAAaA,EAAEA,gBAEhBA,MAAMA,MAMPA,SAACA,GAEAA,IAGCA,GADAA,EAAgBA,GACbA,EAAWA,WACbA,MAAOA,GAAQA,YAAYA,EAAWA,SAExCA,MAAMA,GAELA,EAAQA,GAETA,OAAOA,GAGRA,WAECA,EAAAA,QAAQA,QAOb/G,EAAAA,UAAAA,cAAAA,SAAcA,GAEbgH,GAAIA,GAAIA,KAAMA,GAAYA,EAAEA,iBAE5BA,OAAOA,IAAIA,GACVA,WAECA,GAAIA,EAEJA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAgBA,GAChBA,EAAaA,EAAEA,iBAGhBA,SAACA,GAGAA,MADAA,GAAgBA,GACRA,EAAWA,WAChBA,EAAQA,YAAYA,EAAWA,UAC/BA,GAGJA,WAECA,IAECA,EAAAA,QAAQA,GD55CK,QCg6CbA,UAQPhH,GA1gGQpB,EAAAA,WADKb,GAAAiC,WAAUA,CA8gGvB,IAAAiH,GAAA,SAAAzH,GAKCyH,QAAAA,GAAYA,GAEXC,EAAAA,KAAAA,KAAMA,WAGLA,MADAA,GAAEA,kBACKA,GAAIA,GAAAA,WAAmBA,WAI7BA,MAFAA,GAAEA,gBAAgBA,+CAAgDA,mBAE3DA,EAAEA,WAIXA,IAAIA,GAAIA,IACRA,GAAEA,sBAAwBA,kBAC1BA,EAAEA,QAAUA,EAuNdD,MA1OQA,WAAAA,EAAAA,GAuBGA,EAAAA,UAAAA,WAAVA,WAECE,EAAAA,UAAMA,WAAUA,KAAAA,MAChBA,KAAKA,QAAeA,MAGrBF,OAAAA,eAAIA,EAAAA,UAAAA,UD76COG,IC66CXH,WAECI,MAAOA,MAAKA,SD56CFC,YAAY,EACZC,cAAc,IC86CzBN,EAAAA,UAAAA,QAAAA,WAECO,GAAIA,GAAIA,KAAKA,MACbA,KAAIA,EACHA,QAEDA,IAAGA,MAAMA,QAAQA,GAChBA,MAAaA,GAAGA,OAGjBA,KAAIA,GADAA,GAAMA,EAAEA,OAAQA,EAAaA,EAAaA,WAAcA,GACpDA,EAAIA,EAAKA,EAAFA,IAASA,EAEvBA,EAAOA,GAAKA,EAAEA,EAGfA,OAAOA,IAGRP,EAAAA,UAAAA,aAAAA,WAECQ,MAAOA,IAAIA,GAAmBA,KAAKA,UAIpCR,EAAAA,UAAAA,QAAAA,SAAQA,GAEPS,GAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAASA,EAAEA,OACfA,IAAGA,EAIFA,IAAIA,GAAIA,GAAIA,EAAGA,EAAEA,EAAOA,QAGfA,EAAOA,EAAOA,GAAIA,MAAKA,IAHEA,KAWpCT,EAAAA,UAAAA,IAAAA,SAAIA,GAEHU,GAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAASA,EAAEA,QAASA,EAAMA,EAASA,EAAOA,OAASA,CACvDA,OAAOA,MAASA,GAAaA,EAAAA,UAAMA,IAAGA,KAAAA,KAACA,KAGxCV,EAAAA,UAAAA,MAAAA,SAAMA,GAELW,GAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAASA,EAAEA,QAASA,EAAMA,EAASA,EAAOA,OAASA,CACvDA,OAAOA,KAAQA,EAAYA,EAAAA,UAAMA,MAAKA,KAAAA,KAACA,GAAaA,IAGrDX,EAAAA,UAAAA,UAAAA,SAAUA,GAETY,GAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAASA,EAAEA,OACfA,OAAQA,GAAMA,EAAOA,QAAUA,GAAOA,EACnCA,EAAOA,GACPA,EAAAA,UAAMA,UAASA,KAAAA,KAACA,IAGpBZ,EAAAA,UAAAA,mBAAAA,SAAmBA,EAAcA,GAAAa,SAAAA,IAAAA,EAAAA,KAEhCA,IAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAASA,EAAEA,OACfA,OAAQA,GAAMA,EAAOA,QAAUA,GAAOA,EACnCA,EAAOA,GACPA,GAGJb,EAAAA,UAAAA,MAAAA,WAECc,GAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAASA,EAAEA,OACfA,OAAQA,IAAUA,EAAOA,OACtBA,EAAOA,GACPA,EAAAA,UAAMA,MAAKA,KAAAA,OAGfd,EAAAA,UAAAA,eAAAA,SAAeA,GAAAe,SAAAA,IAAAA,EAAAA,KAEdA,IAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAASA,EAAEA,OACfA,OAAQA,IAAUA,EAAOA,OACtBA,EAAOA,GACPA,GAGJf,EAAAA,UAAAA,KAAAA,WAECgB,GAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAASA,EAAEA,QAASA,EAAMA,EAAOA,MACrCA,OAAOA,GACJA,EAAOA,EAAMA,GACbA,EAAAA,UAAMA,KAAIA,KAAAA,OAGdhB,EAAAA,UAAAA,cAAAA,SAAcA,GAAAiB,SAAAA,IAAAA,EAAAA,KAEbA,IAAIA,GAAIA,IACRA,GAAEA,iBAEFA,IAAIA,GAASA,EAAEA,QAASA,EAAMA,EAAOA,MACrCA,OAAOA,GACJA,EAAOA,EAAMA,GACbA,GAGJjB,EAAAA,UAAAA,KAAAA,SAAKA,GAGJkB,GAAIA,GAAIA,IAERA,QAAIA,GAAeA,EAANA,EACLA,EAAEA,eAEHA,GAAIA,GACVA,WAAMA,MAAAA,IAAIA,GAAAA,WAAmBA,WAAMA,MAAAA,GAAEA,SAASA,MAIhDlB,EAAAA,UAAAA,eAAAA,SAAeA,GAAAmB,SAAAA,IAAAA,EAAAA,EAEdA,IAAIA,GAAIA,KAAMA,EAAMA,EAAEA,QAAUA,EAAEA,QAAQA,OAASA,CACnDA,OAAOA,GAAEA,KAAKA,EAAMA,IAGrBnB,EAAAA,UAAAA,aAAAA,SAAaA,GAEZoB,IAAIA,GAAeA,EAANA,EAASA,MAAOA,GAAWA,OAExCA,IAAIA,GAAMA,KACNA,EAAMA,EAAEA,QACLA,EAAEA,QAAQA,OACVA,CAEPA,OAAOA,GAAEA,KAAKA,EAAMA,IAGrBpB,EAAAA,UAAAA,QAAAA,WAECqB,GAAIA,GAAIA,IAERA,OAAOA,IAAIA,GACVA,WAAMA,MAAAA,IAAIA,GAAAA,WACTA,WAAMA,MAAAA,GAAEA,SAASA,EAAEA,QACfA,EAAEA,QAAQA,OAASA,EACpBA,EAAGA,OAKTrB,EAAAA,UAAAA,QAAAA,WAECsB,MAAOA,IAAIA,GAAmBA,KAAKA,UAGpCtB,EAAAA,UAAAA,cAAAA,SACCA,EACAA,GAEAuB,MAFAA,UAAAA,IAAAA,EAAyCA,EAAOA,UAE7CA,MAAMA,QAAQA,GACTA,EAAOA,SAASA,KAAKA,OAAmBA,GAAQA,EAAMA,GAE3DA,YAAmBA,GACOA,EAAQA,cAAcA,KAAKA,OAAQA,GAEzDA,EAAAA,UAAMA,cAAaA,KAAAA,KAACA,EAAQA,IAIpCvB,EAAAA,UAAAA,eAAAA,SAAeA,EAAuBA,GAAvBwB,SAAAA,IAAAA,EAAAA,IAAuBA,SAAAA,IAAAA,EAA+BA,EAAUA,SAE9EA,IAAIA,GAAIA,KAAKA,OACbA,QAAQA,GAAYA,MAAMA,QAAQA,GACpBA,EAAGA,KAAKA,GACnBA,EAAAA,UAAMA,eAAcA,KAAAA,KAACA,EAAWA,IAGrCxB,GA1OQjH,GAmPR0I,EAAA,SAAAlJ,GAICkJ,QAAAA,GAAoBA,EAAgBA,GAEnCC,EAAAA,KAAAA,KAAMA,GAFaA,KAAAA,UAAAA,EASrBD,MAZQA,WAAAA,EAAAA,GAQPA,OAAAA,eAAIA,EAAAA,UAAAA,ODx/COtB,ICw/CXsB,WAECE,MAAOA,MAAKA,WDv/CFtB,YAAY,EACZC,cAAc,ICw/C1BmB,GAZQzB,GAuBR4B,EAAA,WAICA,QAAAA,GAAoBA,GAAAC,KAAAA,YAAAA,EA+CrBD,MA3CCA,QAAAA,eAAIA,EAAAA,UAAAA,SDlgDOzB,ICkgDXyB,WAECE,MAAOA,MAAKA,YAAYA,ODjgDdzB,YAAY,EACZC,cAAc,ICmgDzBsB,EAAAA,UAAAA,IAAAA,SAAIA,GAEHG,MAAOA,MAAKA,YAAYA,SAASA,IAGlCH,EAAAA,UAAAA,SAAAA,SAASA,GAERI,MAAOA,MAAKA,YAAYA,YAAYA,IAGrCJ,EAAAA,UAAAA,cAAAA,WAGCK,GACIA,GADAA,EAAIA,IAGRA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,EAAEA,YAAYA,iBAE5BA,SAACA,GAGAA,IAAIA,EAAWA,WACdA,OAAOA,CAERA,IAAIA,GAAUA,EAAWA,OAEzBA,OAAOA,GAAQA,YAAYA,GAAIA,GAAyBA,EAAQA,IAAKA,EAAQA,SAE9EA,WAECA,EAAAA,QAAQA,MAKZL,KAGAM,EAAA,SAAA3J,GAGC2J,QAAAA,GACSA,EACAA,GAGRC,EAAAA,KAAAA,KAAMA,MAJEA,KAAAA,WAAAA,EACAA,KAAAA,cAAAA,EAkEVD,MAtEQA,WAAAA,EAAAA,GAUPA,EAAAA,UAAAA,MAAAA,SAAMA,GAGLE,GAAGA,EAAUA,OAAOA,EACnBA,MAAOA,GAAAA,UAAMA,MAAKA,KAAAA,KAACA,EAEpBA,IAAIA,GAAgBA,KAAKA,cACrBA,EAAoBA,SAACA,GAAQA,MAAAA,GAAcA,IAAMA,EAAUA,GAC/DA,OAAOA,IAAIA,GAAmBA,KAAKA,WAAYA,IAGhDF,EAAAA,UAAAA,OAAAA,SAAgBA,GAGfG,MAAGA,GAASA,OAAOA,EACXA,EAAAA,UAAMA,OAAMA,KAAAA,KAACA,GAEdA,GAAIA,GACVA,KAAKA,WACLA,KAAKA,cACLA,IAIFH,EAAAA,UAAAA,cAAAA,WAECI,GAEIA,GAFAA,EAAYA,KAAKA,cACjBA,EAASA,KAAKA,UAGlBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,EAAOA,iBAGrBA,SAACA,GAEAA,KAAMA,EAAWA,YAEhBA,GAAGA,EAAUA,EAAWA,SACvBA,MAAOA,GAAQA,YAAYA,EAAWA,QAGxCA,QAAOA,GAGRA,WAECA,EAAAA,QAAQA,MAKDJ,EAAAA,UAAAA,WAAVA,WAECK,EAAAA,UAAMA,WAAUA,KAAAA,MAChBA,KAAKA,cAAgBA,KACrBA,KAAKA,WAAaA,MAEpBL,GAtEQnJ,GAwERyJ,EAAA,SAAAjK,GAGCiK,QAAAA,GACSA,EACAA,EACAA,GAGRC,EAAAA,KAAAA,KAAMA,MALEA,KAAAA,WAAAA,EACAA,KAAAA,cAAAA,EACAA,KAAAA,aAAAA,EAqEVD,MA1EQA,WAAAA,EAAAA,GAWPA,EAAAA,UAAAA,MAAAA,SAAMA,GAELE,MAAGA,GAAUA,OAAOA,EACZA,EAAAA,UAAMA,MAAKA,KAAAA,KAACA,GAEbA,GAAIA,GAAmBA,KAAMA,IAGrCF,EAAAA,UAAAA,OAAAA,SAAgBA,GAGfG,GAAGA,EAASA,OAAOA,EAElBA,MAAOA,GAAAA,UAAMA,OAAMA,KAAAA,KAACA,EAErBA,IAAIA,GAAIA,KACJA,EAAeA,EAAEA,aACjBA,EAAmBA,SAACA,GAAcA,MAAAA,GAASA,EAAaA,IAC5DA,OAAOA,IAAIA,GAAsBA,EAAEA,WAAYA,EAAEA,cAAeA,IAGjEH,EAAAA,UAAAA,cAAAA,WAECI,GAIIA,GAJAA,EAAgCA,KAChCA,EAAgCA,EAAEA,cAClCA,EAAgCA,EAAEA,WAClCA,EAAgCA,EAAEA,YAGtCA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAaA,EAAOA,iBAGrBA,SAACA,GAEAA,KAAMA,EAAWA,YACjBA,CACCA,GAAIA,GAAIA,EAAWA,OACnBA,IAAcA,MAAXA,GAAmBA,EAAUA,GAE/BA,MAAOA,GAAQA,YAAYA,EAASA,IAGtCA,OAAOA,GAGRA,WAECA,EAAAA,QAAQA,MAKDJ,EAAAA,UAAAA,WAAVA,WAECK,GAAIA,GAAIA,IACRA,GAAAA,UAAMA,WAAUA,KAAAA,MAChBA,EAAEA,cAAgBA,KAClBA,EAAEA,WAAaA,KACfA,EAAEA,aAAeA,MAEnBL,GA1EQzJ,GAqFR+J,EAAA,SAAAvK,GAICuK,QAAAA,GACSA,EACDA,EACAA,EACAA,EACAA,GAAPC,SAAAA,IAAAA,EAAgCA,EAAOA,SAEvCA,EAAAA,KAAAA,KAAMA,MANEA,KAAAA,OAAAA,EACDA,KAAAA,YAAAA,EACAA,KAAAA,MAAAA,EACAA,KAAAA,OAAAA,EACAA,KAAAA,SAAAA,EA2ETD,MAnFQA,WAAAA,EAAAA,GAaCA,EAAAA,UAAAA,wBAARA,SACCA,EACAA,GAEAE,MAAOA,IAAIA,GAA8BA,KAAKA,OAAQA,EAAaA,EAAOA,OAG3EF,EAAAA,UAAAA,OAAAA,SAAOA,GAENG,MAAOA,MAAKA,wBAAwBA,EAAaA,IAGlDH,EAAAA,UAAAA,UAAAA,SAAUA,GAETI,MAAOA,IAAIA,GAAyBA,KAAKA,OAAQA,KAAMA,EAAiBA,KAAMA,IAG/EJ,EAAAA,UAAAA,iBAAAA,SAAiBA,GAEhBK,MAAOA,MAAKA,wBAAwBA,EAAaA,KAGlDL,EAAAA,UAAAA,kBAAAA,SAAkBA,GAEjBM,MAAOA,IAAIA,GAAyBA,KAAKA,OAAQA,KAAMA,GAAkBA,KAAMA,IAGhFN,EAAAA,UAAAA,cAAAA,WAECO,GACIA,GACAA,EAFAA,EAAIA,KAGJA,EAAeA,CAEnBA,OAAOA,IAAIA,GAAAA,WACVA,WAECA,EAAQA,EACRA,EAASA,EAAWA,QAAQA,EAAEA,QAC9BA,EAAUA,EAAkBA,GAAGA,sBAAsBA,IAGtDA,SAACA,GAEAA,MAAQA,GAAMA,EAAQA,OACnBA,EAAQA,YAAYA,EAAOA,EAAQA,QACnCA,GAGJA,WAEIA,IACFA,EAAOA,OAASA,GACjBA,EAASA,KACNA,IACFA,EAAQA,OAASA,GAClBA,EAAUA,QAKHP,EAAAA,UAAAA,WAAVA,WAECQ,EAAAA,UAAMA,WAAUA,KAAAA,MAChBA,KAAKA,OAASA,KACdA,KAAKA,YAAcA,KACnBA,KAAKA,MAAQA,KACbA,KAAKA,OAASA,MAGhBR,GAnFQ/J,EAqHRrC,QAAA6M,eAAAzM,EAAA,cAAAyH,OAAA,ID3oDIzH,EAAAA,WC2oDWiC","file":"System.Linq/Linq.js","sourcesContent":["var __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\ndefine([\"require\", \"exports\", '../System/Compare', '../System/Collections/Array/Compare', '../System/Collections/Array/Utility', '../System/Collections/Enumeration/Enumerator', '../System/Types', '../System/Integer', '../System/Functions', '../System/Collections/Enumeration/ArrayEnumerator', '../System/Collections/Enumeration/EnumeratorBase', '../System/Collections/Dictionaries/Dictionary', '../System/Collections/Queue', '../System/Disposable/Utility', '../System/Disposable/DisposableBase', \"../System/Exception\", '../System/Disposable/ObjectDisposedException', \"../System/Collections/Sorting/KeySortedContext\"], function (require, exports, Values, Arrays, ArrayUtility, Enumerator_1, Types_1, Integer_1, Functions_1, ArrayEnumerator_1, EnumeratorBase_1, Dictionary_1, Queue_1, Utility_1, DisposableBase_1, Exception_1, ObjectDisposedException_1, KeySortedContext_1) {\n 'use strict';\n var VOID0 = void 0;\n var LinqFunctions = (function (_super) {\n __extends(LinqFunctions, _super);\n function LinqFunctions() {\n _super.apply(this, arguments);\n }\n LinqFunctions.prototype.Greater = function (a, b) {\n return a > b ? a : b;\n };\n LinqFunctions.prototype.Lesser = function (a, b) {\n return a < b ? a : b;\n };\n return LinqFunctions;\n })(Functions_1.default);\n var Functions = new LinqFunctions();\n Object.freeze(Functions);\n var UnsupportedEnumerableException = (function (_super) {\n __extends(UnsupportedEnumerableException, _super);\n function UnsupportedEnumerableException() {\n _super.call(this, \"Unsupported enumerable.\");\n }\n return UnsupportedEnumerableException;\n })(Exception_1.default);\n var Enumerable = (function (_super) {\n __extends(Enumerable, _super);\n function Enumerable(_enumeratorFactory, finalizer) {\n _super.call(this, finalizer);\n this._enumeratorFactory = _enumeratorFactory;\n }\n Enumerable.fromArray = function (array) {\n return new ArrayEnumerable(array);\n };\n Enumerable.from = function (source) {\n if (Types_1.default.isObject(source)) {\n if (source instanceof Enumerable)\n return source;\n if (Array.isArray(source))\n return new ArrayEnumerable(source);\n if (Enumerator_1.isEnumerable(source))\n return new Enumerable(function () { return source.getEnumerator(); });\n if (Types_1.default.isArrayLike(source))\n return new ArrayEnumerable(source);\n }\n throw new UnsupportedEnumerableException();\n };\n Enumerable.toArray = function (source) {\n if (Types_1.default.isObject(source)) {\n if (Array.isArray(source))\n return source.slice();\n if (Types_1.default.isArrayLike(source))\n source = new ArrayEnumerable(source);\n if (source instanceof Enumerable)\n return source.toArray();\n if (Enumerator_1.isEnumerable(source)) {\n var result = [];\n Enumerator_1.forEach(source.getEnumerator(), function (e, i) {\n result[i] = e;\n });\n return result;\n }\n }\n throw new UnsupportedEnumerableException();\n };\n Enumerable.prototype.getEnumerator = function () {\n this.throwIfDisposed();\n return this._enumeratorFactory();\n };\n Enumerable.prototype._onDispose = function () {\n _super.prototype._onDispose.call(this);\n this._enumeratorFactory = null;\n };\n Enumerable.choice = function (values) {\n return new Enumerable(function () { return new EnumeratorBase_1.default(null, function (yielder) {\n return yielder.yieldReturn(values[Integer_1.default.random(values.length)]);\n }); });\n };\n Enumerable.cycle = function (values) {\n return new Enumerable(function () {\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n index = 0;\n }, function (yielder) {\n if (index >= values.length)\n index = 0;\n return yielder.yieldReturn(values[index++]);\n });\n });\n };\n Enumerable.empty = function () {\n return new Enumerable(function () { return new EnumeratorBase_1.default(null, Functions.False); });\n };\n Enumerable.repeat = function (element, count) {\n if (count === void 0) { count = Infinity; }\n if (isNaN(count) || count <= 0)\n return Enumerable.empty();\n return isFinite(count) && Integer_1.default.assert(count, \"count\")\n ? new Enumerable(function () {\n var c = count;\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n index = 0;\n }, function (yielder) { return (index++ < c) && yielder.yieldReturn(element); });\n })\n : new Enumerable(function () {\n return new EnumeratorBase_1.default(null, function (yielder) { return yielder.yieldReturn(element); });\n });\n };\n Enumerable.repeatWithFinalize = function (initializer, finalizer) {\n return new Enumerable(function () {\n var element;\n return new EnumeratorBase_1.default(function () {\n element = initializer();\n }, function (yielder) { return yielder.yieldReturn(element); }, function () {\n finalizer(element);\n });\n });\n };\n Enumerable.make = function (element) {\n return Enumerable.repeat(element, 1);\n };\n Enumerable.range = function (start, count, step) {\n if (start === void 0) { start = 0; }\n if (count === void 0) { count = Infinity; }\n if (step === void 0) { step = 1; }\n if (!isFinite(start))\n throw new Error(\"Must have a valid 'start' value.\");\n if (isNaN(count) || count <= 0)\n return Enumerable.empty();\n if (!isFinite(step))\n throw new Error(\"Must have a valid 'step' value.\");\n return isFinite(count) && Integer_1.default.assert(count, \"count\")\n ? new Enumerable(function () {\n var value;\n var c = count;\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n index = 0;\n value = start;\n }, function (yielder) {\n var result = index++ < c\n && yielder.yieldReturn(value);\n if (result && index < count)\n value += step;\n return result;\n });\n })\n : new Enumerable(function () {\n var value;\n return new EnumeratorBase_1.default(function () {\n value = start;\n }, function (yielder) {\n var current = value;\n value += step;\n return yielder.yieldReturn(current);\n });\n });\n };\n Enumerable.rangeDown = function (start, count, step) {\n if (start === void 0) { start = 0; }\n if (count === void 0) { count = Infinity; }\n if (step === void 0) { step = 1; }\n step = Math.abs(step) * -1;\n return Enumerable.range(start, count, step);\n };\n Enumerable.toInfinity = function (start, step) {\n if (start === void 0) { start = 0; }\n if (step === void 0) { step = 1; }\n return Enumerable.range(start, Infinity, step);\n };\n Enumerable.toNegativeInfinity = function (start, step) {\n if (start === void 0) { start = 0; }\n if (step === void 0) { step = 1; }\n return Enumerable.rangeDown(start, Infinity, step);\n };\n Enumerable.rangeTo = function (start, to, step) {\n if (start === void 0) { start = 0; }\n if (to === void 0) { to = Infinity; }\n if (step === void 0) { step = 1; }\n if (!isFinite(start))\n throw new Error(\"Must have a valid 'start' value.\");\n if (isNaN(to))\n throw new Error(\"Must have a valid 'to' value.\");\n if (!isFinite(step))\n throw new Error(\"Must have a valid 'step' value.\");\n step = Math.abs(step);\n if (!isFinite(to))\n return Enumerable.range(start, Infinity, (start < to) ? (+step) : (-step));\n return new Enumerable(function () {\n var value;\n return start < to\n ? new EnumeratorBase_1.default(function () {\n value = start;\n }, function (yielder) {\n var result = value <= to && yielder.yieldReturn(value);\n if (result)\n value += step;\n return result;\n })\n : new EnumeratorBase_1.default(function () {\n value = start;\n }, function (yielder) {\n var result = value >= to && yielder.yieldReturn(value);\n if (result)\n value -= step;\n return result;\n });\n });\n };\n Enumerable.matches = function (input, pattern, flags) {\n if (flags === void 0) { flags = \"\"; }\n var type = typeof input;\n if (type != Types_1.default.STRING)\n throw new Error(\"Cannot exec RegExp matches of type '\" + type + \"'.\");\n if (pattern instanceof RegExp) {\n flags += (pattern.ignoreCase) ? \"i\" : \"\";\n flags += (pattern.multiline) ? \"m\" : \"\";\n pattern = pattern.source;\n }\n if (flags.indexOf(\"g\") === -1)\n flags += \"g\";\n return new Enumerable(function () {\n var regex;\n return new EnumeratorBase_1.default(function () {\n regex = new RegExp(pattern, flags);\n }, function (yielder) {\n var match = regex.exec(input);\n return (match !== null) ? yielder.yieldReturn(match) : false;\n });\n });\n };\n Enumerable.generate = function (factory, count) {\n if (count === void 0) { count = Infinity; }\n if (isNaN(count) || count <= 0)\n return Enumerable.empty();\n return isFinite(count) && Integer_1.default.assert(count, \"count\")\n ? new Enumerable(function () {\n var c = count;\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n index = 0;\n }, function (yielder) {\n var current = index++;\n return current < c && yielder.yieldReturn(factory(current));\n });\n })\n : new Enumerable(function () {\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n index = 0;\n }, function (yielder) { return yielder.yieldReturn(factory(index++)); });\n });\n };\n Enumerable.unfold = function (seed, valueFactory, skipSeed) {\n if (skipSeed === void 0) { skipSeed = false; }\n return new Enumerable(function () {\n var index = 0;\n var value;\n var isFirst;\n return new EnumeratorBase_1.default(function () {\n index = 0;\n value = seed;\n isFirst = !skipSeed;\n }, function (yielder) {\n var i = index++;\n if (isFirst)\n isFirst = false;\n else\n value = valueFactory(value, i);\n return yielder.yieldReturn(value);\n });\n });\n };\n Enumerable.defer = function (enumerableFactory) {\n return new Enumerable(function () {\n var enumerator;\n return new EnumeratorBase_1.default(function () {\n enumerator = enumerableFactory().getEnumerator();\n }, function (yielder) { return enumerator.moveNext() && yielder.yieldReturn(enumerator.current); }, function () {\n Utility_1.dispose(enumerator);\n });\n });\n };\n Enumerable.forEach = function (enumerable, action) {\n if (enumerable) {\n Utility_1.using(Enumerator_1.from(enumerable), function (e) {\n Enumerator_1.forEach(e, action);\n });\n }\n };\n Enumerable.map = function (enumerable, selector) {\n return enumerable && Utility_1.using(Enumerator_1.from(enumerable), function (e) {\n var result = [];\n Enumerator_1.forEach(e, function (e, i) {\n result[i] = selector(e);\n });\n return result;\n });\n };\n Enumerable.max = function (values) {\n return values\n .takeUntil(function (v) { return v == +Infinity; }, true)\n .aggregate(Functions.Greater);\n };\n Enumerable.min = function (values) {\n return values\n .takeUntil(function (v) { return v == -Infinity; }, true)\n .aggregate(Functions.Lesser);\n };\n Enumerable.prototype.forEach = function (action) {\n var _ = this;\n _.throwIfDisposed();\n var index = 0;\n Utility_1.using(_.getEnumerator(), function (e) {\n while (_.throwIfDisposed() && e.moveNext()) {\n if (action(e.current, index++) === false)\n break;\n }\n });\n };\n Enumerable.prototype.toArray = function (predicate) {\n var result = [];\n if (predicate)\n return this.where(predicate).toArray();\n this.forEach(function (x, i) {\n result[i] = x;\n });\n return result;\n };\n Enumerable.prototype.asEnumerable = function () {\n var _ = this;\n return new Enumerable(function () { return _.getEnumerator(); });\n };\n Enumerable.prototype.toLookup = function (keySelector, elementSelector, compareSelector) {\n if (elementSelector === void 0) { elementSelector = Functions.Identity; }\n if (compareSelector === void 0) { compareSelector = Functions.Identity; }\n var dict = new Dictionary_1.default(compareSelector);\n this.forEach(function (x) {\n var key = keySelector(x);\n var element = elementSelector(x);\n var array = dict.getValue(key);\n if (array !== VOID0)\n array.push(element);\n else\n dict.addByKeyValue(key, [element]);\n });\n return new Lookup(dict);\n };\n Enumerable.prototype.toMap = function (keySelector, elementSelector) {\n var obj = {};\n this.forEach(function (x) {\n obj[keySelector(x)] = elementSelector(x);\n });\n return obj;\n };\n Enumerable.prototype.toDictionary = function (keySelector, elementSelector, compareSelector) {\n if (compareSelector === void 0) { compareSelector = Functions.Identity; }\n var dict = new Dictionary_1.default(compareSelector);\n this.forEach(function (x) { return dict.addByKeyValue(keySelector(x), elementSelector(x)); });\n return dict;\n };\n Enumerable.prototype.toJoinedString = function (separator, selector) {\n if (separator === void 0) { separator = \"\"; }\n if (selector === void 0) { selector = Functions.Identity; }\n return this.select(selector).toArray().join(separator);\n };\n Enumerable.prototype.doAction = function (action) {\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n throwIfDisposed(disposed);\n index = 0;\n enumerator = _.getEnumerator();\n }, function (yielder) {\n throwIfDisposed(disposed);\n while (enumerator.moveNext()) {\n var actionResult = action(enumerator.current, index++);\n if (actionResult === false || actionResult === 0)\n return yielder.yieldBreak();\n if (actionResult !== 2)\n return yielder.yieldReturn(enumerator.current);\n }\n return false;\n }, function () {\n Utility_1.dispose(enumerator);\n });\n }, function () {\n disposed = true;\n });\n };\n Enumerable.prototype.force = function (defaultAction) {\n if (defaultAction === void 0) { defaultAction = 0; }\n this.throwIfDisposed();\n this.doAction(function (element) { return defaultAction; });\n };\n Enumerable.prototype.skip = function (count) {\n var _ = this;\n _.throwIfDisposed();\n if (!count || isNaN(count) || count < 0)\n return _;\n if (!isFinite(count))\n return Enumerable.empty();\n Integer_1.default.assert(count, \"count\");\n var c = count;\n return this.doAction(function (element, index) {\n return index < c\n ? 2\n : 1;\n });\n };\n Enumerable.prototype.skipWhile = function (predicate) {\n this.throwIfDisposed();\n var skipping = true;\n return this.doAction(function (element, index) {\n if (skipping)\n skipping = predicate(element, index);\n return skipping\n ? 2\n : 1;\n });\n };\n Enumerable.prototype.take = function (count) {\n if (!count || isNaN(count) || count < 0)\n return Enumerable.empty();\n var _ = this;\n _.throwIfDisposed();\n if (!isFinite(count))\n return _;\n Integer_1.default.assert(count, \"count\");\n var c = count;\n return _.doAction(function (element, index) { return index < c; });\n };\n Enumerable.prototype.takeWhile = function (predicate) {\n this.throwIfDisposed();\n return this.doAction(function (element, index) {\n return predicate(element, index)\n ? 1\n : 0;\n });\n };\n Enumerable.prototype.takeUntil = function (predicate, includeUntilValue) {\n this.throwIfDisposed();\n if (!includeUntilValue)\n return this.doAction(function (element, index) {\n return predicate(element, index)\n ? 0\n : 1;\n });\n var found = false;\n return this.doAction(function (element, index) {\n if (found)\n return 0;\n found = predicate(element, index);\n return 1;\n });\n };\n Enumerable.prototype.takeExceptLast = function (count) {\n if (count === void 0) { count = 1; }\n var _ = this;\n if (!count || isNaN(count) || count <= 0)\n return _;\n if (!isFinite(count))\n return Enumerable.empty();\n Integer_1.default.assert(count, \"count\");\n var c = count;\n return new Enumerable(function () {\n var enumerator;\n var q;\n return new EnumeratorBase_1.default(function () {\n enumerator = _.getEnumerator();\n q = new Queue_1.default();\n }, function (yielder) {\n while (enumerator.moveNext()) {\n q.enqueue(enumerator.current);\n if (q.count > c)\n return yielder.yieldReturn(q.dequeue());\n }\n return false;\n }, function () {\n Utility_1.dispose(enumerator, q);\n });\n });\n };\n Enumerable.prototype.takeFromLast = function (count) {\n if (!count || isNaN(count) || count <= 0)\n return Enumerable.empty();\n var _ = this;\n if (!isFinite(count))\n return _.reverse();\n Integer_1.default.assert(count, \"count\");\n return _.reverse().take(count);\n };\n Enumerable.prototype.traverseBreadthFirst = function (func, resultSelector) {\n var _ = this;\n return new Enumerable(function () {\n var enumerator;\n var nestLevel = 0;\n var buffer, len;\n return new EnumeratorBase_1.default(function () {\n nestLevel = 0;\n buffer = [];\n len = 0;\n enumerator = _.getEnumerator();\n }, function (yielder) {\n while (true) {\n if (enumerator.moveNext()) {\n buffer[len++] = enumerator.current;\n return yielder.yieldReturn(resultSelector(enumerator.current, nestLevel));\n }\n if (!len)\n return yielder.yieldBreak();\n var next = Enumerable\n .fromArray(buffer)\n .selectMany(func);\n if (!next.any()) {\n return yielder.yieldBreak();\n }\n else {\n nestLevel++;\n buffer = [];\n len = 0;\n enumerator.dispose();\n enumerator = next.getEnumerator();\n }\n }\n }, function () {\n Utility_1.dispose(enumerator);\n buffer.length = 0;\n });\n });\n };\n Enumerable.prototype.traverseDepthFirst = function (func, resultSelector) {\n var _ = this;\n return new Enumerable(function () {\n var enumeratorStack = [];\n var enumerator;\n var len;\n return new EnumeratorBase_1.default(function () {\n enumerator = _.getEnumerator();\n len = 0;\n }, function (yielder) {\n while (true) {\n if (enumerator.moveNext()) {\n var value = resultSelector(enumerator.current, len);\n enumeratorStack[len++] = enumerator;\n enumerator = func(enumerator.current).getEnumerator();\n return yielder.yieldReturn(value);\n }\n if (len == 0)\n return false;\n enumerator.dispose();\n enumerator = enumeratorStack[--len];\n enumeratorStack.length = len;\n }\n }, function () {\n try {\n Utility_1.dispose(enumerator);\n }\n finally {\n Utility_1.disposeThese(enumeratorStack);\n }\n });\n });\n };\n Enumerable.prototype.flatten = function () {\n var _ = this;\n return new Enumerable(function () {\n var enumerator;\n var middleEnumerator = null;\n return new EnumeratorBase_1.default(function () {\n enumerator = _.getEnumerator();\n }, function (yielder) {\n while (true) {\n if (middleEnumerator != null) {\n if (middleEnumerator.moveNext()) {\n return yielder.yieldReturn(middleEnumerator.current);\n }\n else {\n middleEnumerator = null;\n }\n }\n if (enumerator.moveNext()) {\n var c = enumerator.current;\n if (Array.isArray(c)) {\n middleEnumerator.dispose();\n middleEnumerator = Enumerable.fromArray(c)\n .selectMany(Functions.Identity)\n .flatten()\n .getEnumerator();\n continue;\n }\n else {\n return yielder.yieldReturn(enumerator.current);\n }\n }\n return false;\n }\n }, function () {\n Utility_1.dispose(enumerator, middleEnumerator);\n });\n });\n };\n Enumerable.prototype.pairwise = function (selector) {\n var _ = this;\n return new Enumerable(function () {\n var enumerator;\n return new EnumeratorBase_1.default(function () {\n enumerator = _.getEnumerator();\n enumerator.moveNext();\n }, function (yielder) {\n var prev = enumerator.current;\n return enumerator.moveNext()\n && yielder.yieldReturn(selector(prev, enumerator.current));\n }, function () {\n Utility_1.dispose(enumerator);\n });\n });\n };\n Enumerable.prototype.scan = function (func, seed) {\n var isUseSeed = seed !== VOID0;\n var _ = this;\n return new Enumerable(function () {\n var enumerator;\n var value;\n var isFirst;\n return new EnumeratorBase_1.default(function () {\n enumerator = _.getEnumerator();\n isFirst = true;\n }, function (yielder) {\n if (isFirst) {\n isFirst = false;\n return isUseSeed\n ? yielder.yieldReturn(value = seed)\n : enumerator.moveNext() && yielder.yieldReturn(value\n = enumerator.current);\n }\n return (enumerator.moveNext())\n ? yielder.yieldReturn(value = func(value, enumerator.current))\n : false;\n }, function () {\n Utility_1.dispose(enumerator);\n });\n });\n };\n Enumerable.prototype.select = function (selector) {\n var _ = this, disposed = !_.throwIfDisposed();\n if (selector.length < 2)\n return new WhereSelectEnumerable(_, null, selector);\n return new Enumerable(function () {\n var enumerator;\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n throwIfDisposed(disposed);\n index = 0;\n enumerator = _.getEnumerator();\n }, function (yielder) {\n throwIfDisposed(disposed);\n return enumerator.moveNext()\n ? yielder.yieldReturn(selector(enumerator.current, index++))\n : false;\n }, function () {\n Utility_1.dispose(enumerator);\n });\n }, function () {\n disposed = true;\n });\n };\n Enumerable.prototype.selectMany = function (collectionSelector, resultSelector) {\n var _ = this;\n if (!resultSelector)\n resultSelector = function (a, b) { return b; };\n return new Enumerable(function () {\n var enumerator;\n var middleEnumerator;\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n enumerator = _.getEnumerator();\n middleEnumerator = undefined;\n index = 0;\n }, function (yielder) {\n if (middleEnumerator === VOID0 && !enumerator.moveNext())\n return false;\n do {\n if (!middleEnumerator) {\n var middleSeq = collectionSelector(enumerator.current, index++);\n if (!middleSeq)\n continue;\n middleEnumerator = Enumerator_1.from(middleSeq);\n }\n if (middleEnumerator.moveNext())\n return yielder.yieldReturn(resultSelector(enumerator.current, middleEnumerator.current));\n middleEnumerator.dispose();\n middleEnumerator = null;\n } while (enumerator.moveNext());\n return false;\n }, function () {\n Utility_1.dispose(enumerator, middleEnumerator);\n enumerator = null;\n middleEnumerator = null;\n });\n });\n };\n Enumerable.prototype.choose = function (selector) {\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n throwIfDisposed(disposed);\n index = 0;\n enumerator = _.getEnumerator();\n }, function (yielder) {\n throwIfDisposed(disposed);\n while (enumerator.moveNext()) {\n var result = selector(enumerator.current, index++);\n if (result !== null && result !== VOID0)\n return yielder.yieldReturn(result);\n }\n return false;\n }, function () {\n Utility_1.dispose(enumerator);\n });\n }, function () {\n disposed = true;\n });\n };\n Enumerable.prototype.where = function (predicate) {\n var _ = this, disposed = !_.throwIfDisposed();\n if (predicate.length < 2)\n return new WhereEnumerable(_, predicate);\n return new Enumerable(function () {\n var enumerator;\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n throwIfDisposed(disposed);\n index = 0;\n enumerator = _.getEnumerator();\n }, function (yielder) {\n throwIfDisposed(disposed);\n while (enumerator.moveNext()) {\n if (predicate(enumerator.current, index++))\n return yielder.yieldReturn(enumerator.current);\n }\n return false;\n }, function () {\n Utility_1.dispose(enumerator);\n });\n }, function () {\n disposed = true;\n });\n };\n Enumerable.prototype.ofType = function (type) {\n var typeName;\n switch (type) {\n case Number:\n typeName = Types_1.default.NUMBER;\n break;\n case String:\n typeName = Types_1.default.STRING;\n break;\n case Boolean:\n typeName = Types_1.default.BOOLEAN;\n break;\n case Function:\n typeName = Types_1.default.FUNCTION;\n break;\n default:\n return this\n .where(function (x) { return x instanceof type; });\n }\n return this\n .where(function (x) { return typeof x === typeName; });\n };\n Enumerable.prototype.except = function (second, compareSelector) {\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n var keys;\n return new EnumeratorBase_1.default(function () {\n throwIfDisposed(disposed);\n enumerator = _.getEnumerator();\n keys = new Dictionary_1.default(compareSelector);\n if (second)\n Enumerable.forEach(second, function (key) { return keys.addByKeyValue(key, true); });\n }, function (yielder) {\n throwIfDisposed(disposed);\n while (enumerator.moveNext()) {\n var current = enumerator.current;\n if (!keys.containsKey(current)) {\n keys.addByKeyValue(current, true);\n return yielder.yieldReturn(current);\n }\n }\n return false;\n }, function () {\n Utility_1.dispose(enumerator);\n keys.clear();\n });\n }, function () {\n disposed = true;\n });\n };\n Enumerable.prototype.distinct = function (compareSelector) {\n return this.except(null, compareSelector);\n };\n Enumerable.prototype.distinctUntilChanged = function (compareSelector) {\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n var compareKey;\n var initial = true;\n return new EnumeratorBase_1.default(function () {\n throwIfDisposed(disposed);\n enumerator = _.getEnumerator();\n }, function (yielder) {\n throwIfDisposed(disposed);\n while (enumerator.moveNext()) {\n var key = compareSelector(enumerator.current);\n if (initial) {\n initial = false;\n }\n else if (compareKey === key) {\n continue;\n }\n compareKey = key;\n return yielder.yieldReturn(enumerator.current);\n }\n return false;\n }, function () {\n Utility_1.dispose(enumerator);\n });\n }, function () {\n disposed = true;\n });\n };\n Enumerable.prototype.reverse = function () {\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var buffer;\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n throwIfDisposed(disposed);\n buffer = _.toArray();\n index = buffer.length;\n }, function (yielder) {\n return index > 0\n && yielder.yieldReturn(buffer[--index]);\n }, function () {\n buffer.length = 0;\n });\n }, function () {\n disposed = true;\n });\n };\n Enumerable.prototype.shuffle = function () {\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var buffer;\n var capacity;\n var len;\n return new EnumeratorBase_1.default(function () {\n throwIfDisposed(disposed);\n buffer = _.toArray();\n capacity = len = buffer.length;\n }, function (yielder) {\n if (!len)\n return yielder.yieldBreak();\n var selectedIndex = Integer_1.default.random(len);\n var selectedValue = buffer[selectedIndex];\n buffer[selectedIndex] = buffer[--len];\n buffer[len] = null;\n if (len % 32 == 0)\n buffer.length = len;\n return yielder.yieldReturn(selectedValue);\n }, function () {\n buffer.length = 0;\n });\n }, function () {\n disposed = true;\n });\n };\n Enumerable.prototype.count = function (predicate) {\n var _ = this;\n _.throwIfDisposed();\n var count = 0;\n if (predicate) {\n _.forEach(function (x, i) {\n if (predicate(x, i))\n ++count;\n });\n }\n else {\n _.forEach(function () {\n ++count;\n });\n }\n return count;\n };\n Enumerable.prototype.all = function (predicate) {\n var result = true;\n this.forEach(function (x) {\n if (!predicate(x)) {\n result = false;\n return false;\n }\n });\n return result;\n };\n Enumerable.prototype.every = function (predicate) {\n return this.all(predicate);\n };\n Enumerable.prototype.any = function (predicate) {\n var result = false;\n if (predicate) {\n this.forEach(function (x) {\n result = predicate(x);\n return !result;\n });\n }\n else {\n this.forEach(function () {\n result = true;\n return false;\n });\n }\n return result;\n };\n Enumerable.prototype.some = function (predicate) {\n return this.any(predicate);\n };\n Enumerable.prototype.isEmpty = function () {\n return !this.any();\n };\n Enumerable.prototype.contains = function (value, compareSelector) {\n return compareSelector\n ? this.any(function (v) { return compareSelector(v) === compareSelector(value); })\n : this.any(function (v) { return v === value; });\n };\n Enumerable.prototype.indexOf = function (value, compareSelector) {\n var found = -1;\n if (compareSelector)\n this.forEach(function (element, i) {\n if (Values.areEqual(compareSelector(element), compareSelector(value), true)) {\n found = i;\n return false;\n }\n });\n else\n this.forEach(function (element, i) {\n if (Values.areEqual(element, value, true)) {\n found = i;\n return false;\n }\n });\n return found;\n };\n Enumerable.prototype.lastIndexOf = function (value, compareSelector) {\n var result = -1;\n if (compareSelector)\n this.forEach(function (element, i) {\n if (Values.areEqual(compareSelector(element), compareSelector(value), true))\n result\n = i;\n });\n else\n this.forEach(function (element, i) {\n if (Values.areEqual(element, value, true))\n result = i;\n });\n return result;\n };\n Enumerable.prototype.defaultIfEmpty = function (defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n var isFirst;\n return new EnumeratorBase_1.default(function () {\n isFirst = true;\n throwIfDisposed(disposed);\n enumerator = _.getEnumerator();\n }, function (yielder) {\n throwIfDisposed(disposed);\n if (enumerator.moveNext()) {\n isFirst = false;\n return yielder.yieldReturn(enumerator.current);\n }\n else if (isFirst) {\n isFirst = false;\n return yielder.yieldReturn(defaultValue);\n }\n return false;\n }, function () {\n Utility_1.dispose(enumerator);\n });\n });\n };\n Enumerable.prototype.zip = function (second, resultSelector) {\n var _ = this;\n return new Enumerable(function () {\n var firstEnumerator;\n var secondEnumerator;\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n index = 0;\n firstEnumerator = _.getEnumerator();\n secondEnumerator = Enumerator_1.from(second);\n }, function (yielder) {\n return firstEnumerator.moveNext() && secondEnumerator.moveNext()\n && yielder.yieldReturn(resultSelector(firstEnumerator.current, secondEnumerator.current, index++));\n }, function () {\n Utility_1.dispose(firstEnumerator, secondEnumerator);\n });\n });\n };\n Enumerable.prototype.zipMultiple = function (second, resultSelector) {\n var _ = this;\n if (!second.length)\n return Enumerable.empty();\n return new Enumerable(function () {\n var secondTemp;\n var firstEnumerator;\n var secondEnumerator;\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n secondTemp = new Queue_1.default(second);\n index = 0;\n firstEnumerator = _.getEnumerator();\n secondEnumerator = null;\n }, function (yielder) {\n if (firstEnumerator.moveNext()) {\n while (true) {\n while (!secondEnumerator) {\n if (secondTemp.count) {\n var next = secondTemp.dequeue();\n if (next)\n secondEnumerator = Enumerator_1.from(next);\n }\n else\n return yielder.yieldBreak();\n }\n if (secondEnumerator.moveNext())\n return yielder.yieldReturn(resultSelector(firstEnumerator.current, secondEnumerator.current, index++));\n secondEnumerator.dispose();\n secondEnumerator = null;\n }\n }\n return yielder.yieldBreak();\n }, function () {\n Utility_1.dispose(firstEnumerator, secondTemp);\n });\n });\n };\n Enumerable.prototype.join = function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector) {\n if (compareSelector === void 0) { compareSelector = Functions.Identity; }\n var _ = this;\n return new Enumerable(function () {\n var outerEnumerator;\n var lookup;\n var innerElements = null;\n var innerCount = 0;\n return new EnumeratorBase_1.default(function () {\n outerEnumerator = _.getEnumerator();\n lookup = Enumerable.from(inner)\n .toLookup(innerKeySelector, Functions.Identity, compareSelector);\n }, function (yielder) {\n while (true) {\n if (innerElements != null) {\n var innerElement = innerElements[innerCount++];\n if (innerElement !== VOID0)\n return yielder.yieldReturn(resultSelector(outerEnumerator.current, innerElement));\n innerElement = null;\n innerCount = 0;\n }\n if (outerEnumerator.moveNext()) {\n var key = outerKeySelector(outerEnumerator.current);\n innerElements = lookup.get(key);\n }\n else {\n return yielder.yieldBreak();\n }\n }\n }, function () {\n Utility_1.dispose(outerEnumerator);\n });\n });\n };\n Enumerable.prototype.groupJoin = function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector) {\n if (compareSelector === void 0) { compareSelector = Functions.Identity; }\n var _ = this;\n return new Enumerable(function () {\n var enumerator;\n var lookup = null;\n return new EnumeratorBase_1.default(function () {\n enumerator = _.getEnumerator();\n lookup = Enumerable.from(inner)\n .toLookup(innerKeySelector, Functions.Identity, compareSelector);\n }, function (yielder) {\n return enumerator.moveNext()\n && yielder.yieldReturn(resultSelector(enumerator.current, lookup.get(outerKeySelector(enumerator.current))));\n }, function () {\n Utility_1.dispose(enumerator);\n });\n });\n };\n Enumerable.prototype.concatWith = function (other) {\n var _ = this;\n return new Enumerable(function () {\n var firstEnumerator;\n var secondEnumerator;\n return new EnumeratorBase_1.default(function () {\n firstEnumerator = _.getEnumerator();\n }, function (yielder) {\n if (firstEnumerator != null) {\n if (firstEnumerator.moveNext())\n return yielder.yieldReturn(firstEnumerator.current);\n secondEnumerator = Enumerator_1.from(other);\n firstEnumerator.dispose();\n firstEnumerator = null;\n }\n if (secondEnumerator.moveNext())\n return yielder.yieldReturn(secondEnumerator.current);\n return false;\n }, function () {\n Utility_1.dispose(firstEnumerator, secondEnumerator);\n });\n });\n };\n Enumerable.prototype.merge = function (enumerables) {\n var _ = this;\n if (!enumerables.length)\n return _;\n if (enumerables.length == 1)\n return _.concatWith(enumerables[0]);\n return new Enumerable(function () {\n var enumerator;\n var queue;\n return new EnumeratorBase_1.default(function () {\n enumerator = _.getEnumerator();\n queue = new Queue_1.default(enumerables);\n }, function (yielder) {\n while (true) {\n while (!enumerator && queue.count) {\n enumerator = Enumerator_1.from(queue.dequeue());\n }\n if (enumerator && enumerator.moveNext())\n return yielder.yieldReturn(enumerator.current);\n if (enumerator) {\n enumerator.dispose();\n enumerator = null;\n continue;\n }\n return yielder.yieldBreak();\n }\n }, function () {\n Utility_1.dispose(enumerator, queue);\n });\n });\n };\n Enumerable.prototype.concat = function () {\n var enumerables = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n enumerables[_i - 0] = arguments[_i];\n }\n var _ = this;\n if (enumerables.length == 0)\n return _;\n if (enumerables.length == 1)\n return _.concatWith(enumerables[0]);\n return _.merge(enumerables);\n };\n Enumerable.prototype.insertAt = function (index, other) {\n if (isNaN(index) || index < 0 || !isFinite(index))\n throw new Error(\"'index' is invalid or out of bounds.\");\n Integer_1.default.assert(index, \"index\");\n var n = index;\n var _ = this;\n _.throwIfDisposed();\n return new Enumerable(function () {\n var firstEnumerator;\n var secondEnumerator;\n var count = 0;\n var isEnumerated = false;\n return new EnumeratorBase_1.default(function () {\n count = 0;\n firstEnumerator = _.getEnumerator();\n secondEnumerator = Enumerator_1.from(other);\n isEnumerated = false;\n }, function (yielder) {\n if (count == n) {\n isEnumerated = true;\n if (secondEnumerator.moveNext())\n return yielder.yieldReturn(secondEnumerator.current);\n }\n if (firstEnumerator.moveNext()) {\n count++;\n return yielder.yieldReturn(firstEnumerator.current);\n }\n return !isEnumerated\n && secondEnumerator.moveNext()\n && yielder.yieldReturn(secondEnumerator.current);\n }, function () {\n Utility_1.dispose(firstEnumerator, secondEnumerator);\n });\n });\n };\n Enumerable.prototype.alternateMultiple = function (sequence) {\n var _ = this;\n return new Enumerable(function () {\n var buffer, mode, enumerator, alternateEnumerator;\n return new EnumeratorBase_1.default(function () {\n alternateEnumerator = new ArrayEnumerator_1.default(Enumerable.toArray(sequence));\n enumerator = _.getEnumerator();\n var hasAtLeastOne = enumerator.moveNext();\n mode = hasAtLeastOne\n ? 1\n : 0;\n if (hasAtLeastOne)\n buffer = enumerator.current;\n }, function (yielder) {\n switch (mode) {\n case 0:\n return yielder.yieldBreak();\n case 2:\n if (alternateEnumerator.moveNext())\n return yielder.yieldReturn(alternateEnumerator.current);\n alternateEnumerator.reset();\n mode = 1;\n break;\n }\n var latest = buffer;\n var another = enumerator.moveNext();\n mode = another\n ? 2\n : 0;\n if (another)\n buffer = enumerator.current;\n return yielder.yieldReturn(latest);\n }, function () {\n Utility_1.dispose(enumerator, alternateEnumerator);\n });\n });\n };\n Enumerable.prototype.alternateSingle = function (value) {\n return this.alternateMultiple(Enumerable.make(value));\n };\n Enumerable.prototype.alternate = function () {\n var sequence = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n sequence[_i - 0] = arguments[_i];\n }\n return this.alternateMultiple(sequence);\n };\n Enumerable.prototype.intersect = function (second, compareSelector) {\n var _ = this;\n return new Enumerable(function () {\n var enumerator;\n var keys;\n var outs;\n return new EnumeratorBase_1.default(function () {\n enumerator = _.getEnumerator();\n keys = new Dictionary_1.default(compareSelector);\n outs = new Dictionary_1.default(compareSelector);\n Enumerable.from(second)\n .forEach(function (key) {\n keys.addByKeyValue(key, true);\n });\n }, function (yielder) {\n while (enumerator.moveNext()) {\n var current = enumerator.current;\n if (!outs.containsKey(current) && keys.containsKey(current)) {\n outs.addByKeyValue(current, true);\n return yielder.yieldReturn(current);\n }\n }\n return yielder.yieldBreak();\n }, function () {\n Utility_1.dispose(enumerator);\n });\n });\n };\n Enumerable.prototype.sequenceEqual = function (second, equalityComparer) {\n if (equalityComparer === void 0) { equalityComparer = Values.areEqual; }\n return Utility_1.using(this.getEnumerator(), function (e1) { return Utility_1.using(Enumerable.from(second).getEnumerator(), function (e2) {\n while (e1.moveNext()) {\n if (!e2.moveNext() || !equalityComparer(e1.current, e2.current))\n return false;\n }\n return !e2.moveNext();\n }); });\n };\n Enumerable.prototype.union = function (second, compareSelector) {\n if (compareSelector === void 0) { compareSelector = Functions.Identity; }\n var _ = this;\n return new Enumerable(function () {\n var firstEnumerator;\n var secondEnumerator;\n var keys;\n return new EnumeratorBase_1.default(function () {\n firstEnumerator = _.getEnumerator();\n keys = new Dictionary_1.default(compareSelector);\n }, function (yielder) {\n var current;\n if (secondEnumerator === VOID0) {\n while (firstEnumerator.moveNext()) {\n current = firstEnumerator.current;\n if (!keys.containsKey(current)) {\n keys.addByKeyValue(current, null);\n return yielder.yieldReturn(current);\n }\n }\n secondEnumerator = Enumerable.from(second).getEnumerator();\n }\n while (secondEnumerator.moveNext()) {\n current = secondEnumerator.current;\n if (!keys.containsKey(current)) {\n keys.addByKeyValue(current, null);\n return yielder.yieldReturn(current);\n }\n }\n return false;\n }, function () {\n Utility_1.dispose(firstEnumerator, secondEnumerator);\n });\n });\n };\n Enumerable.prototype.orderBy = function (keySelector) {\n if (keySelector === void 0) { keySelector = Functions.Identity; }\n return new OrderedEnumerable(this, keySelector, 1);\n };\n Enumerable.prototype.orderUsing = function (comparison) {\n return new OrderedEnumerable(this, null, 1, null, comparison);\n };\n Enumerable.prototype.orderUsingReversed = function (comparison) {\n return new OrderedEnumerable(this, null, -1, null, comparison);\n };\n Enumerable.prototype.orderByDescending = function (keySelector) {\n if (keySelector === void 0) { keySelector = Functions.Identity; }\n return new OrderedEnumerable(this, keySelector, -1);\n };\n Enumerable.prototype.groupBy = function (keySelector, elementSelector, compareSelector) {\n var _ = this;\n if (!elementSelector)\n elementSelector = Functions.Identity;\n return new Enumerable(function () { return _.toLookup(keySelector, elementSelector, compareSelector)\n .getEnumerator(); });\n };\n Enumerable.prototype.partitionBy = function (keySelector, elementSelector, resultSelector, compareSelector) {\n if (resultSelector === void 0) { resultSelector = function (key, elements) { return new Grouping(key, elements); }; }\n if (compareSelector === void 0) { compareSelector = Functions.Identity; }\n var _ = this;\n if (!elementSelector)\n elementSelector = Functions.Identity;\n return new Enumerable(function () {\n var enumerator;\n var key;\n var compareKey;\n var group;\n var len;\n return new EnumeratorBase_1.default(function () {\n enumerator = _.getEnumerator();\n if (enumerator.moveNext()) {\n key = keySelector(enumerator.current);\n compareKey = compareSelector(key);\n group = [elementSelector(enumerator.current)];\n len = 1;\n }\n else\n group = null;\n }, function (yielder) {\n if (!group)\n return yielder.yieldBreak();\n var hasNext, c;\n while ((hasNext = enumerator.moveNext())) {\n c = enumerator.current;\n if (compareKey === compareSelector(keySelector(c)))\n group[len++] = elementSelector(c);\n else\n break;\n }\n var result = resultSelector(key, group);\n if (hasNext) {\n c = enumerator.current;\n key = keySelector(c);\n compareKey = compareSelector(key);\n group = [elementSelector(c)];\n len = 1;\n }\n else {\n group = null;\n }\n return yielder.yieldReturn(result);\n }, function () {\n Utility_1.dispose(enumerator);\n group = null;\n });\n });\n };\n Enumerable.prototype.buffer = function (size) {\n if (size < 1 || !isFinite(size))\n throw new Error(\"Invalid buffer size.\");\n Integer_1.default.assert(size, \"size\");\n var _ = this, len;\n return new Enumerable(function () {\n var enumerator;\n return new EnumeratorBase_1.default(function () {\n enumerator = _.getEnumerator();\n }, function (yielder) {\n var array = ArrayUtility.initialize(size);\n len = 0;\n while (len < size && enumerator.moveNext) {\n array[len++] = enumerator.current;\n }\n array.length = len;\n return len && yielder.yieldReturn(array);\n }, function () {\n Utility_1.dispose(enumerator);\n });\n });\n };\n Enumerable.prototype.aggregate = function (func, seed) {\n return this.scan(func, seed).lastOrDefault();\n };\n Enumerable.prototype.average = function (selector) {\n if (selector === void 0) { selector = Types_1.default.numberOrNaN; }\n var sum = 0;\n var sumInfinite = 0;\n var count = 0;\n this.forEach(function (x) {\n var value = selector(x);\n if (isNaN(value)) {\n sum = NaN;\n return false;\n }\n if (isFinite(value))\n sum += value;\n else\n sumInfinite += value > 0 ? (+1) : (-1);\n ++count;\n });\n if (sumInfinite)\n return sumInfinite * Infinity;\n return (isNaN(sum) || !count)\n ? NaN\n : (sum / count);\n };\n Enumerable.prototype.max = function () {\n return this.aggregate(Functions.Greater);\n };\n Enumerable.prototype.min = function () {\n return this.aggregate(Functions.Lesser);\n };\n Enumerable.prototype.maxBy = function (keySelector) {\n if (keySelector === void 0) { keySelector = Functions.Identity; }\n return this.aggregate(function (a, b) { return (keySelector(a) > keySelector(b)) ? a : b; });\n };\n Enumerable.prototype.minBy = function (keySelector) {\n if (keySelector === void 0) { keySelector = Functions.Identity; }\n return this.aggregate(function (a, b) { return (keySelector(a) < keySelector(b)) ? a : b; });\n };\n Enumerable.prototype.sum = function (selector) {\n if (selector === void 0) { selector = Types_1.default.numberOrNaN; }\n var sum = 0;\n var sumInfinite = 0;\n this.forEach(function (x) {\n var value = selector(x);\n if (isNaN(value)) {\n sum = NaN;\n return false;\n }\n if (isFinite(value))\n sum += value;\n else\n sumInfinite += value > 0 ? (+1) : (-1);\n });\n return isNaN(sum) ? NaN : (sumInfinite ? (sumInfinite * Infinity) : sum);\n };\n Enumerable.prototype.product = function (selector) {\n if (selector === void 0) { selector = Types_1.default.numberOrNaN; }\n var result = 1, exists = false;\n this.forEach(function (x) {\n exists = true;\n var value = selector(x);\n if (isNaN(value)) {\n result = NaN;\n return false;\n }\n if (value == 0) {\n result = 0;\n return false;\n }\n result *= value;\n });\n return (exists && isNaN(result)) ? NaN : result;\n };\n Enumerable.prototype.elementAt = function (index) {\n if (isNaN(index) || index < 0 || !isFinite(index))\n throw new Error(\"'index' is invalid or out of bounds.\");\n Integer_1.default.assert(index, \"index\");\n var n = index;\n var _ = this;\n _.throwIfDisposed();\n var value = undefined;\n var found = false;\n _.forEach(function (x, i) {\n if (i == n) {\n value = x;\n found = true;\n return false;\n }\n });\n if (!found)\n throw new Error(\"index is less than 0 or greater than or equal to the number of elements in source.\");\n return value;\n };\n Enumerable.prototype.elementAtOrDefault = function (index, defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n if (isNaN(index) || index < 0 || !isFinite(index))\n throw new Error(\"'index' is invalid or out of bounds.\");\n Integer_1.default.assert(index, \"index\");\n var n = index;\n var _ = this;\n _.throwIfDisposed();\n var value = undefined;\n var found = false;\n _.forEach(function (x, i) {\n if (i == n) {\n value = x;\n found = true;\n return false;\n }\n });\n return (!found) ? defaultValue : value;\n };\n Enumerable.prototype.first = function () {\n var _ = this;\n _.throwIfDisposed();\n var value = undefined;\n var found = false;\n _.forEach(function (x) {\n value = x;\n found = true;\n return false;\n });\n if (!found)\n throw new Error(\"first:No element satisfies the condition.\");\n return value;\n };\n Enumerable.prototype.firstOrDefault = function (defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n var _ = this;\n _.throwIfDisposed();\n var value = undefined;\n var found = false;\n _.forEach(function (x) {\n value = x;\n found = true;\n return false;\n });\n return (!found) ? defaultValue : value;\n };\n Enumerable.prototype.last = function () {\n var _ = this;\n _.throwIfDisposed();\n var value = undefined;\n var found = false;\n _.forEach(function (x) {\n found = true;\n value = x;\n });\n if (!found)\n throw new Error(\"last:No element satisfies the condition.\");\n return value;\n };\n Enumerable.prototype.lastOrDefault = function (defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n var _ = this;\n _.throwIfDisposed();\n var value = undefined;\n var found = false;\n _.forEach(function (x) {\n found = true;\n value = x;\n });\n return (!found) ? defaultValue : value;\n };\n Enumerable.prototype.single = function () {\n var _ = this;\n _.throwIfDisposed();\n var value = undefined;\n var found = false;\n _.forEach(function (x) {\n if (!found) {\n found = true;\n value = x;\n }\n else\n throw new Error(\"single:sequence contains more than one element.\");\n });\n if (!found)\n throw new Error(\"single:No element satisfies the condition.\");\n return value;\n };\n Enumerable.prototype.singleOrDefault = function (defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n var _ = this;\n _.throwIfDisposed();\n var value = undefined;\n var found = false;\n _.forEach(function (x) {\n if (!found) {\n found = true;\n value = x;\n }\n else\n throw new Error(\"single:sequence contains more than one element.\");\n });\n return (!found) ? defaultValue : value;\n };\n Enumerable.prototype.share = function () {\n var _ = this;\n _.throwIfDisposed();\n var sharedEnumerator;\n return new Enumerable(function () {\n return new EnumeratorBase_1.default(function () {\n if (!sharedEnumerator)\n sharedEnumerator = _.getEnumerator();\n }, function (yielder) {\n return sharedEnumerator.moveNext()\n && yielder.yieldReturn(sharedEnumerator.current);\n });\n }, function () {\n Utility_1.dispose(sharedEnumerator);\n });\n };\n Enumerable.prototype.memoize = function () {\n var _ = this, disposed = !_.throwIfDisposed();\n var cache;\n var enumerator;\n return new Enumerable(function () {\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n throwIfDisposed(disposed);\n if (!enumerator)\n enumerator = _.getEnumerator();\n if (!cache)\n cache = [];\n index = 0;\n }, function (yielder) {\n throwIfDisposed(disposed);\n var i = index++;\n if (i >= cache.length) {\n return (enumerator.moveNext())\n ? yielder.yieldReturn(cache[i] = enumerator.current)\n : false;\n }\n return yielder.yieldReturn(cache[i]);\n });\n }, function () {\n disposed = true;\n if (cache)\n cache.length = 0;\n cache = null;\n Utility_1.dispose(enumerator);\n enumerator = null;\n });\n };\n Enumerable.prototype.catchError = function (handler) {\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n return new EnumeratorBase_1.default(function () {\n try {\n throwIfDisposed(disposed);\n enumerator = _.getEnumerator();\n }\n catch (e) {\n }\n }, function (yielder) {\n try {\n throwIfDisposed(disposed);\n if (enumerator.moveNext())\n return yielder.yieldReturn(enumerator.current);\n }\n catch (e) {\n handler(e);\n }\n return false;\n }, function () {\n Utility_1.dispose(enumerator);\n });\n });\n };\n Enumerable.prototype.finallyAction = function (action) {\n var _ = this, disposed = !_.throwIfDisposed();\n return new Enumerable(function () {\n var enumerator;\n return new EnumeratorBase_1.default(function () {\n throwIfDisposed(disposed);\n enumerator = _.getEnumerator();\n }, function (yielder) {\n throwIfDisposed(disposed);\n return (enumerator.moveNext())\n ? yielder.yieldReturn(enumerator.current)\n : false;\n }, function () {\n try {\n Utility_1.dispose(enumerator);\n }\n finally {\n action();\n }\n });\n });\n };\n return Enumerable;\n })(DisposableBase_1.default);\n exports.Enumerable = Enumerable;\n var ArrayEnumerable = (function (_super) {\n __extends(ArrayEnumerable, _super);\n function ArrayEnumerable(source) {\n _super.call(this, function () {\n _.throwIfDisposed();\n return new ArrayEnumerator_1.default(function () {\n _.throwIfDisposed(\"The underlying ArrayEnumerable was disposed.\", \"ArrayEnumerator\");\n return _._source;\n });\n });\n var _ = this;\n _._disposableObjectName = \"ArrayEnumerable\";\n _._source = source;\n }\n ArrayEnumerable.prototype._onDispose = function () {\n _super.prototype._onDispose.call(this);\n this._source = null;\n };\n Object.defineProperty(ArrayEnumerable.prototype, \"source\", {\n get: function () {\n return this._source;\n },\n enumerable: true,\n configurable: true\n });\n ArrayEnumerable.prototype.toArray = function () {\n var s = this.source;\n if (!s)\n return [];\n if (Array.isArray(s))\n return s.slice();\n var len = s.length, result = ArrayUtility.initialize(len);\n for (var i = 0; i < len; ++i) {\n result[i] = s[i];\n }\n return result;\n };\n ArrayEnumerable.prototype.asEnumerable = function () {\n return new ArrayEnumerable(this._source);\n };\n ArrayEnumerable.prototype.forEach = function (action) {\n var _ = this;\n _.throwIfDisposed();\n var source = _._source;\n if (source) {\n for (var i = 0; i < source.length; ++i) {\n if (action(source[i], i) === false)\n break;\n }\n }\n };\n ArrayEnumerable.prototype.any = function (predicate) {\n var _ = this;\n _.throwIfDisposed();\n var source = _._source, len = source ? source.length : 0;\n return len && (!predicate || _super.prototype.any.call(this, predicate));\n };\n ArrayEnumerable.prototype.count = function (predicate) {\n var _ = this;\n _.throwIfDisposed();\n var source = _._source, len = source ? source.length : 0;\n return len && (predicate ? _super.prototype.count.call(this, predicate) : len);\n };\n ArrayEnumerable.prototype.elementAt = function (index) {\n var _ = this;\n _.throwIfDisposed();\n var source = _._source;\n return (index < source.length && index >= 0)\n ? source[index]\n : _super.prototype.elementAt.call(this, index);\n };\n ArrayEnumerable.prototype.elementAtOrDefault = function (index, defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n var _ = this;\n _.throwIfDisposed();\n var source = _._source;\n return (index < source.length && index >= 0)\n ? source[index]\n : defaultValue;\n };\n ArrayEnumerable.prototype.first = function () {\n var _ = this;\n _.throwIfDisposed();\n var source = _._source;\n return (source && source.length)\n ? source[0]\n : _super.prototype.first.call(this);\n };\n ArrayEnumerable.prototype.firstOrDefault = function (defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n var _ = this;\n _.throwIfDisposed();\n var source = _._source;\n return (source && source.length)\n ? source[0]\n : defaultValue;\n };\n ArrayEnumerable.prototype.last = function () {\n var _ = this;\n _.throwIfDisposed();\n var source = _._source, len = source.length;\n return (len)\n ? source[len - 1]\n : _super.prototype.last.call(this);\n };\n ArrayEnumerable.prototype.lastOrDefault = function (defaultValue) {\n if (defaultValue === void 0) { defaultValue = null; }\n var _ = this;\n _.throwIfDisposed();\n var source = _._source, len = source.length;\n return len\n ? source[len - 1]\n : defaultValue;\n };\n ArrayEnumerable.prototype.skip = function (count) {\n var _ = this;\n if (!count || count < 0)\n return _.asEnumerable();\n return new Enumerable(function () { return new ArrayEnumerator_1.default(function () { return _._source; }, count); });\n };\n ArrayEnumerable.prototype.takeExceptLast = function (count) {\n if (count === void 0) { count = 1; }\n var _ = this, len = _._source ? _._source.length : 0;\n return _.take(len - count);\n };\n ArrayEnumerable.prototype.takeFromLast = function (count) {\n if (!count || count < 0)\n return Enumerable.empty();\n var _ = this, len = _._source\n ? _._source.length\n : 0;\n return _.skip(len - count);\n };\n ArrayEnumerable.prototype.reverse = function () {\n var _ = this;\n return new Enumerable(function () { return new ArrayEnumerator_1.default(function () { return _._source; }, _._source\n ? (_._source.length - 1)\n : 0, -1); });\n };\n ArrayEnumerable.prototype.memoize = function () {\n return new ArrayEnumerable(this._source);\n };\n ArrayEnumerable.prototype.sequenceEqual = function (second, equalityComparer) {\n if (equalityComparer === void 0) { equalityComparer = Values.areEqual; }\n if (Array.isArray(second))\n return Arrays.areEqual(this.source, second, true, equalityComparer);\n if (second instanceof ArrayEnumerable)\n return second.sequenceEqual(this.source, equalityComparer);\n return _super.prototype.sequenceEqual.call(this, second, equalityComparer);\n };\n ArrayEnumerable.prototype.toJoinedString = function (separator, selector) {\n if (separator === void 0) { separator = \"\"; }\n if (selector === void 0) { selector = Functions.Identity; }\n var s = this._source;\n return !selector && Array.isArray(s)\n ? s.join(separator)\n : _super.prototype.toJoinedString.call(this, separator, selector);\n };\n return ArrayEnumerable;\n })(Enumerable);\n var Grouping = (function (_super) {\n __extends(Grouping, _super);\n function Grouping(_groupKey, elements) {\n _super.call(this, elements);\n this._groupKey = _groupKey;\n }\n Object.defineProperty(Grouping.prototype, \"key\", {\n get: function () {\n return this._groupKey;\n },\n enumerable: true,\n configurable: true\n });\n return Grouping;\n })(ArrayEnumerable);\n var Lookup = (function () {\n function Lookup(_dictionary) {\n this._dictionary = _dictionary;\n }\n Object.defineProperty(Lookup.prototype, \"count\", {\n get: function () {\n return this._dictionary.count;\n },\n enumerable: true,\n configurable: true\n });\n Lookup.prototype.get = function (key) {\n return this._dictionary.getValue(key);\n };\n Lookup.prototype.contains = function (key) {\n return this._dictionary.containsKey(key);\n };\n Lookup.prototype.getEnumerator = function () {\n var _ = this;\n var enumerator;\n return new EnumeratorBase_1.default(function () {\n enumerator = _._dictionary.getEnumerator();\n }, function (yielder) {\n if (!enumerator.moveNext())\n return false;\n var current = enumerator.current;\n return yielder.yieldReturn(new Grouping(current.key, current.value));\n }, function () {\n Utility_1.dispose(enumerator);\n });\n };\n return Lookup;\n })();\n var WhereEnumerable = (function (_super) {\n __extends(WhereEnumerable, _super);\n function WhereEnumerable(prevSource, prevPredicate) {\n _super.call(this, null);\n this.prevSource = prevSource;\n this.prevPredicate = prevPredicate;\n }\n WhereEnumerable.prototype.where = function (predicate) {\n if (predicate.length > 1)\n return _super.prototype.where.call(this, predicate);\n var prevPredicate = this.prevPredicate;\n var composedPredicate = function (x) { return prevPredicate(x) && predicate(x); };\n return new WhereEnumerable(this.prevSource, composedPredicate);\n };\n WhereEnumerable.prototype.select = function (selector) {\n if (selector.length > 1)\n return _super.prototype.select.call(this, selector);\n return new WhereSelectEnumerable(this.prevSource, this.prevPredicate, selector);\n };\n WhereEnumerable.prototype.getEnumerator = function () {\n var predicate = this.prevPredicate;\n var source = this.prevSource;\n var enumerator;\n return new EnumeratorBase_1.default(function () {\n enumerator = source.getEnumerator();\n }, function (yielder) {\n while (enumerator.moveNext()) {\n if (predicate(enumerator.current))\n return yielder.yieldReturn(enumerator.current);\n }\n return false;\n }, function () {\n Utility_1.dispose(enumerator);\n });\n };\n WhereEnumerable.prototype._onDispose = function () {\n _super.prototype._onDispose.call(this);\n this.prevPredicate = null;\n this.prevSource = null;\n };\n return WhereEnumerable;\n })(Enumerable);\n var WhereSelectEnumerable = (function (_super) {\n __extends(WhereSelectEnumerable, _super);\n function WhereSelectEnumerable(prevSource, prevPredicate, prevSelector) {\n _super.call(this, null);\n this.prevSource = prevSource;\n this.prevPredicate = prevPredicate;\n this.prevSelector = prevSelector;\n }\n WhereSelectEnumerable.prototype.where = function (predicate) {\n if (predicate.length > 1)\n return _super.prototype.where.call(this, predicate);\n return new WhereEnumerable(this, predicate);\n };\n WhereSelectEnumerable.prototype.select = function (selector) {\n if (selector.length > 1)\n return _super.prototype.select.call(this, selector);\n var _ = this;\n var prevSelector = _.prevSelector;\n var composedSelector = function (x) { return selector(prevSelector(x)); };\n return new WhereSelectEnumerable(_.prevSource, _.prevPredicate, composedSelector);\n };\n WhereSelectEnumerable.prototype.getEnumerator = function () {\n var _ = this, predicate = _.prevPredicate, source = _.prevSource, selector = _.prevSelector, enumerator;\n return new EnumeratorBase_1.default(function () {\n enumerator = source.getEnumerator();\n }, function (yielder) {\n while (enumerator.moveNext()) {\n var c = enumerator.current;\n if (predicate == null || predicate(c)) {\n return yielder.yieldReturn(selector(c));\n }\n }\n return false;\n }, function () {\n Utility_1.dispose(enumerator);\n });\n };\n WhereSelectEnumerable.prototype._onDispose = function () {\n var _ = this;\n _super.prototype._onDispose.call(this);\n _.prevPredicate = null;\n _.prevSource = null;\n _.prevSelector = null;\n };\n return WhereSelectEnumerable;\n })(Enumerable);\n var OrderedEnumerable = (function (_super) {\n __extends(OrderedEnumerable, _super);\n function OrderedEnumerable(source, keySelector, order, parent, comparer) {\n if (comparer === void 0) { comparer = Values.compare; }\n _super.call(this, null);\n this.source = source;\n this.keySelector = keySelector;\n this.order = order;\n this.parent = parent;\n this.comparer = comparer;\n }\n OrderedEnumerable.prototype.createOrderedEnumerable = function (keySelector, order) {\n return new OrderedEnumerable(this.source, keySelector, order, this);\n };\n OrderedEnumerable.prototype.thenBy = function (keySelector) {\n return this.createOrderedEnumerable(keySelector, 1);\n };\n OrderedEnumerable.prototype.thenUsing = function (comparison) {\n return new OrderedEnumerable(this.source, null, 1, this, comparison);\n };\n OrderedEnumerable.prototype.thenByDescending = function (keySelector) {\n return this.createOrderedEnumerable(keySelector, -1);\n };\n OrderedEnumerable.prototype.thenUsingReversed = function (comparison) {\n return new OrderedEnumerable(this.source, null, -1, this, comparison);\n };\n OrderedEnumerable.prototype.getEnumerator = function () {\n var _ = this;\n var buffer;\n var indexes;\n var index = 0;\n return new EnumeratorBase_1.default(function () {\n index = 0;\n buffer = Enumerable.toArray(_.source);\n indexes = createSortContext(_).generateSortedIndexes(buffer);\n }, function (yielder) {\n return (index < indexes.length)\n ? yielder.yieldReturn(buffer[indexes[index++]])\n : false;\n }, function () {\n if (buffer)\n buffer.length = 0;\n buffer = null;\n if (indexes)\n indexes.length = 0;\n indexes = null;\n });\n };\n OrderedEnumerable.prototype._onDispose = function () {\n _super.prototype._onDispose.call(this);\n this.source = null;\n this.keySelector = null;\n this.order = null;\n this.parent = null;\n };\n return OrderedEnumerable;\n })(Enumerable);\n function createSortContext(orderedEnumerable, currentContext) {\n if (currentContext === void 0) { currentContext = null; }\n var context = new KeySortedContext_1.default(currentContext, orderedEnumerable.keySelector, orderedEnumerable.order, orderedEnumerable.comparer);\n if (orderedEnumerable.parent)\n return createSortContext(orderedEnumerable.parent, context);\n return context;\n }\n function throwIfDisposed(disposed, className) {\n if (className === void 0) { className = \"Enumerable\"; }\n if (disposed)\n throw new ObjectDisposedException_1.default(className);\n }\n Object.defineProperty(exports, \"__esModule\", { value: true });\n exports.default = Enumerable;\n});\n","/*\r\n * @author electricessence / https://github.com/electricessence/\r\n * Original: http://linqjs.codeplex.com/\r\n * Licensing: MIT https://github.com/electricessence/TypeScript.NET/blob/master/LICENSE.md\r\n */\r\n///<reference path=\"../System/Primitive.d.ts\"/>\r\n///<reference path=\"../System/FunctionTypes.d.ts\"/>\r\n///<reference path=\"../System/Collections/Array/IArray.d.ts\"/>\r\n///<reference path=\"../System/Collections/Enumeration/IEnumerator.d.ts\"/>\r\n///<reference path=\"../System/Collections/Enumeration/IEnumerable.d.ts\"/>\r\n///<reference path=\"../System/Collections/Dictionaries/IDictionary.d.ts\"/>\r\n///<reference path=\"../System/IComparer.d.ts\"/>\r\n///<reference path=\"../System/Collections/Sorting/Order.d.ts\"/>\r\n'use strict'; // For compatibility with (let, const, function, class);\r\n\r\nimport * as Values from '../System/Compare';\r\nimport * as Arrays from '../System/Collections/Array/Compare';\r\nimport * as ArrayUtility from '../System/Collections/Array/Utility';\r\nimport {from as enumeratorFrom, forEach as enumeratorForEach, isEnumerable} from '../System/Collections/Enumeration/Enumerator';\r\nimport Type from '../System/Types';\r\nimport Integer from '../System/Integer';\r\nimport BaseFunctions from '../System/Functions';\r\nimport ArrayEnumerator from '../System/Collections/Enumeration/ArrayEnumerator';\r\nimport EnumeratorBase from '../System/Collections/Enumeration/EnumeratorBase';\r\nimport Dictionary from '../System/Collections/Dictionaries/Dictionary';\r\nimport Queue from '../System/Collections/Queue';\r\nimport {dispose, disposeThese, using} from '../System/Disposable/Utility';\r\nimport DisposableBase from '../System/Disposable/DisposableBase';\r\nimport Exception from \"../System/Exception\";\r\nimport ArgumentException from '../System/Exceptions/ArgumentException';\r\nimport ObjectDisposedException from '../System/Disposable/ObjectDisposedException';\r\nimport KeySortedContext from \"../System/Collections/Sorting/KeySortedContext\";\r\ntype Comparable = Primitive|IComparable<any>;\r\n\r\n// #region Local Constants.\r\n\r\nconst VOID0:any = void 0;\r\n\r\n// Leave internal to avoid accidental overwriting.\r\nclass LinqFunctions extends BaseFunctions\r\n{\r\n\tGreater<T>(a:T, b:T)\r\n\t{\r\n\t\treturn a>b ? a : b;\r\n\t}\r\n\r\n\tLesser<T>(a:T, b:T)\r\n\t{\r\n\t\treturn a<b ? a : b;\r\n\t}\r\n}\r\n\r\nvar Functions = new LinqFunctions();\r\nObject.freeze(Functions);\r\n\r\n// #endregion\r\n\r\nclass UnsupportedEnumerableException extends Exception\r\n{\r\n\tconstructor()\r\n\t{\r\n\t\tsuper(\"Unsupported enumerable.\");\r\n\t}\r\n}\r\n\r\n\r\n/**\r\n * Defined values for doAction.\r\n */\r\nexport const enum EnumerableAction\r\n{\r\n\tBreak = 0,\r\n\tReturn = 1,\r\n\tSkip = 2\r\n}\r\n\r\n/**\r\n * Enumerable<T> is a wrapper class that allows more primitive enumerables to exhibit LINQ behavior.\r\n *\r\n * In C# Enumerable<T> is not an instance but has extensions for IEnumerable<T>.\r\n * In this case, we use Enumerable<T> as the underlying class that is being chained.\r\n */\r\nexport class Enumerable<T>\r\nextends DisposableBase implements IEnumerable<T>\r\n{\r\n\r\n\tconstructor(\r\n\t\tprotected _enumeratorFactory:() => IEnumerator<T>,\r\n\t\tfinalizer?:() => void)\r\n\t{\r\n\t\tsuper(finalizer);\r\n\t}\r\n\r\n\t/**\r\n\t * Static shortcut for creating an ArrayEnumerable.\r\n\t */\r\n\tstatic fromArray<T>(array:IArray<T>):Enumerable<T>\r\n\t{\r\n\t\treturn new ArrayEnumerable<T>(array);\r\n\t}\r\n\r\n\t/**\r\n\t * Universal method for converting a primitive enumerables into a LINQ enabled ones.\r\n\t *\r\n\t * Is not limited to TypeScript usages.\r\n\t */\r\n\tstatic from<T>(source:IEnumerable<T> | IArray<T>):Enumerable<T>\r\n\t{\r\n\t\tif(Type.isObject(source))\r\n\t\t{\r\n\t\t\tif(source instanceof Enumerable)\r\n\t\t\t\treturn source;\r\n\r\n\t\t\tif(Array.isArray(source))\r\n\t\t\t\treturn new ArrayEnumerable<T>(source);\r\n\r\n\t\t\tif(isEnumerable<T>(source))\r\n\t\t\t\treturn new Enumerable(()=>source.getEnumerator());\r\n\r\n\t\t\tif(Type.isArrayLike<T>(source))\r\n\t\t\t\treturn new ArrayEnumerable<T>(source);\r\n\t\t}\r\n\r\n\t\tthrow new UnsupportedEnumerableException();\r\n\t}\r\n\r\n\tstatic toArray<T>(source:IEnumerable<T> | IArray<T>):T[]\r\n\t{\r\n\t\tif(Type.isObject(source))\r\n\t\t{\r\n\t\t\tif(Array.isArray(source))\r\n\t\t\t\treturn source.slice();\r\n\r\n\t\t\tif(Type.isArrayLike<T>(source))\r\n\t\t\t\tsource = new ArrayEnumerable<T>(<IArray<T>>source);\r\n\r\n\t\t\tif(source instanceof Enumerable)\r\n\t\t\t\treturn source.toArray();\r\n\r\n\t\t\tif(isEnumerable<T>(source))\r\n\t\t\t{\r\n\t\t\t\tvar result:T[] = [];\r\n\t\t\t\tenumeratorForEach<T>(\r\n\t\t\t\t\tsource.getEnumerator(), (e, i) =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tresult[i] = e;\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t\treturn result;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tthrow new UnsupportedEnumerableException();\r\n\t}\r\n\r\n\r\n\t// #region IEnumerable<T> Implementation...\r\n\tgetEnumerator():IEnumerator<T>\r\n\t{\r\n\r\n\t\tthis.throwIfDisposed();\r\n\r\n\t\treturn this._enumeratorFactory();\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\t// #region IDisposable override...\r\n\tprotected _onDispose():void\r\n\t{\r\n\t\tsuper._onDispose(); // Just in case.\r\n\t\tthis._enumeratorFactory = null;\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\t//////////////////////////////////////////\r\n\t// #region Static Methods...\r\n\tstatic choice<T>(values:IArray<T>):Enumerable<T>\r\n\t{\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() => new EnumeratorBase<T>(\r\n\t\t\t\tnull,\r\n\t\t\t\t(yielder)=>\r\n\t\t\t\t\tyielder.yieldReturn(values[Integer.random(values.length)])\r\n\t\t\t)\r\n\t\t);\r\n\t}\r\n\r\n\tstatic cycle<T>(values:IArray<T>):Enumerable<T>\r\n\t{\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar index:number = 0; // Let the compiler know this is an int.\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t}, // Reinitialize the value just in case the enumerator is restarted.\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tif(index>=values.length) index = 0;\r\n\t\t\t\t\t\treturn yielder.yieldReturn(values[index++]);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tstatic empty<T>():Enumerable<T>\r\n\t{\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() => new EnumeratorBase<T>(\r\n\t\t\t\tnull,\r\n\t\t\t\tFunctions.False\r\n\t\t\t)\r\n\t\t);\r\n\t}\r\n\r\n\tstatic repeat<T>(element:T, count:number = Infinity):Enumerable<T>\r\n\t{\r\n\t\tif(isNaN(count) || count<=0)\r\n\t\t\treturn Enumerable.empty<T>();\r\n\r\n\t\treturn isFinite(count) && Integer.assert(count, \"count\")\r\n\t\t\t? new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar c:number = count;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=> (index++<c) && yielder.yieldReturn(element)\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t)\r\n\t\t\t: new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t\tnew EnumeratorBase<T>(\r\n\t\t\t\t\tnull,\r\n\t\t\t\t\t(yielder)=> yielder.yieldReturn(element)\r\n\t\t\t\t)\r\n\t\t);\r\n\t}\r\n\r\n\t// Note: this enumeration does not break.\r\n\tstatic repeatWithFinalize<T>(\r\n\t\tinitializer:() => T,\r\n\t\tfinalizer:(element:T) => void):Enumerable<T>\r\n\t{\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar element:T;\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\telement = initializer();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=> yielder.yieldReturn(element),\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tfinalizer(element);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tstatic make<T>(element:T):Enumerable<T>\r\n\t{\r\n\t\treturn Enumerable.repeat<T>(element, 1);\r\n\t}\r\n\r\n\t// start and step can be other than integer.\r\n\tstatic range(\r\n\t\tstart:number = 0,\r\n\t\tcount:number = Infinity,\r\n\t\tstep:number = 1):Enumerable<number>\r\n\t{\r\n\r\n\t\tif(!isFinite(start))\r\n\t\t\tthrow new Error(\"Must have a valid 'start' value.\");\r\n\r\n\t\tif(isNaN(count) || count<=0)\r\n\t\t\treturn Enumerable.empty<number>();\r\n\r\n\t\tif(!isFinite(step))\r\n\t\t\tthrow new Error(\"Must have a valid 'step' value.\");\r\n\r\n\t\treturn isFinite(count) && Integer.assert(count, \"count\")\r\n\t\t\t? new Enumerable<number>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar value:number;\r\n\t\t\t\tvar c:number = count; // Force integer evaluation.\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<number>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tvalue = start;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar result:boolean =\r\n\t\t\t\t\t\t\t index++<c\r\n\t\t\t\t\t\t\t && yielder.yieldReturn(value);\r\n\r\n\t\t\t\t\t\tif(result && index<count)\r\n\t\t\t\t\t\t\tvalue += step;\r\n\r\n\t\t\t\t\t\treturn result;\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t})\r\n\r\n\t\t\t: new Enumerable<number>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar value:number;\r\n\r\n\t\t\t\treturn new EnumeratorBase<number>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvalue = start;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar current:number = value;\r\n\t\t\t\t\t\tvalue += step;\r\n\t\t\t\t\t\treturn yielder.yieldReturn(current);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tstatic rangeDown(\r\n\t\tstart:number = 0,\r\n\t\tcount:number = Infinity,\r\n\t\tstep:number = 1):Enumerable<number>\r\n\t{\r\n\t\tstep = Math.abs(step)* -1;\r\n\r\n\t\treturn Enumerable.range(start, count, step);\r\n\t}\r\n\r\n\t// step = -1 behaves the same as toNegativeInfinity;\r\n\tstatic toInfinity(\r\n\t\tstart:number = 0,\r\n\t\tstep:number = 1):Enumerable<number>\r\n\t{\r\n\t\treturn Enumerable.range(start, Infinity, step);\r\n\t}\r\n\r\n\tstatic toNegativeInfinity(\r\n\t\tstart:number = 0,\r\n\t\tstep:number = 1):Enumerable<number>\r\n\t{\r\n\t\treturn Enumerable.rangeDown(start, Infinity, step);\r\n\t}\r\n\r\n\tstatic rangeTo(\r\n\t\tstart:number = 0,\r\n\t\tto:number = Infinity,\r\n\t\tstep:number = 1):Enumerable<number>\r\n\t{\r\n\t\tif(!isFinite(start))\r\n\t\t\tthrow new Error(\"Must have a valid 'start' value.\");\r\n\r\n\t\tif(isNaN(to))\r\n\t\t\tthrow new Error(\"Must have a valid 'to' value.\");\r\n\r\n\t\tif(!isFinite(step))\r\n\t\t\tthrow new Error(\"Must have a valid 'step' value.\");\r\n\r\n\t\t// This way we adjust for the delta from start and to so the user can say +/- step and it will work as expected.\r\n\t\tstep = Math.abs(step);\r\n\r\n\t\t// Range to infinity has a more efficient mechanism.\r\n\t\tif(!isFinite(to))\r\n\t\t\treturn Enumerable.range(start, Infinity, (start<to) ? (+step) : (-step));\r\n\r\n\t\treturn new Enumerable<number>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar value:number;\r\n\r\n\t\t\t\treturn start<to\r\n\r\n\t\t\t\t\t? new EnumeratorBase<number>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvalue = start;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar result:boolean = value<=to && yielder.yieldReturn(value);\r\n\r\n\t\t\t\t\t\tif(result)\r\n\t\t\t\t\t\t\tvalue += step;\r\n\r\n\t\t\t\t\t\treturn result;\r\n\t\t\t\t\t})\r\n\r\n\t\t\t\t\t: new EnumeratorBase<number>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvalue = start;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar result:boolean = value>=to && yielder.yieldReturn(value);\r\n\r\n\t\t\t\t\t\tif(result)\r\n\t\t\t\t\t\t\tvalue -= step;\r\n\r\n\t\t\t\t\t\treturn result;\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tstatic matches(input:string, pattern:any, flags:string = \"\"):Enumerable<RegExpExecArray>\r\n\t{\r\n\r\n\t\tvar type = typeof input;\r\n\t\tif(type!=Type.STRING)\r\n\t\t\tthrow new Error(\"Cannot exec RegExp matches of type '\" + type + \"'.\");\r\n\r\n\t\tif(pattern instanceof RegExp)\r\n\t\t{\r\n\t\t\tflags += (pattern.ignoreCase) ? \"i\" : \"\";\r\n\t\t\tflags += (pattern.multiline) ? \"m\" : \"\";\r\n\t\t\tpattern = pattern.source;\r\n\t\t}\r\n\r\n\t\tif(flags.indexOf(\"g\")=== -1) flags += \"g\";\r\n\r\n\t\treturn new Enumerable<RegExpExecArray>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar regex:RegExp;\r\n\t\t\t\treturn new EnumeratorBase<RegExpExecArray>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tregex = new RegExp(pattern, flags);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\t// Calling regex.exec consecutively on the same input uses the lastIndex to start the next match.\r\n\t\t\t\t\t\tvar match = regex.exec(input);\r\n\t\t\t\t\t\treturn (match!==null) ? yielder.yieldReturn(match) : false;\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tstatic generate<T>(factory:(index?:number) => T, count:number = Infinity):Enumerable<T>\r\n\t{\r\n\r\n\t\tif(isNaN(count) || count<=0)\r\n\t\t\treturn Enumerable.empty<T>();\r\n\r\n\t\treturn isFinite(count) && Integer.assert(count, \"count\")\r\n\r\n\t\t\t? new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar c:number = count;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar current:number = index++;\r\n\t\t\t\t\t\treturn current<c && yielder.yieldReturn(factory(current));\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t})\r\n\r\n\t\t\t: new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar index:number = 0;\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=> yielder.yieldReturn(factory(index++))\r\n\t\t\t\t);\r\n\t\t\t});\r\n\t}\r\n\r\n\tstatic unfold<T>(seed:T, valueFactory:Selector<T, T>, skipSeed:Boolean = false):Enumerable<T>\r\n\t{\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar index:number = 0;\r\n\t\t\t\tvar value:T;\r\n\t\t\t\tvar isFirst:boolean;\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tvalue = seed;\r\n\t\t\t\t\t\tisFirst = !skipSeed;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar i = index++;\r\n\t\t\t\t\t\tif(isFirst)\r\n\t\t\t\t\t\t\tisFirst = false;\r\n\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\tvalue = valueFactory(value, i);\r\n\t\t\t\t\t\treturn yielder.yieldReturn(value);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tstatic defer<T>(enumerableFactory:() => IEnumerable<T>):Enumerable<T>\r\n\t{\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = enumerableFactory().getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=> enumerator.moveNext() && yielder.yieldReturn(enumerator.current),\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tstatic forEach<T>(\r\n\t\tenumerable:IEnumerable<T> | IArray<T>,\r\n\t\taction:(element:T, index?:number) => any):void\r\n\t{\r\n\t\tif(enumerable)\r\n\t\t{\r\n\t\t\tusing(enumeratorFrom(enumerable), e=>\r\n\t\t\t{\r\n\t\t\t\tenumeratorForEach(e, action);\r\n\t\t\t});\r\n\t\t}\r\n\t}\r\n\r\n\tstatic map<T,TResult>(\r\n\t\tenumerable:IEnumerable<T> | IArray<T>,\r\n\t\tselector:Selector<T,TResult>):TResult[]\r\n\t{\r\n\r\n\t\treturn enumerable && using(enumeratorFrom(enumerable), e=>\r\n\t\t\t{\r\n\t\t\t\tvar result:TResult[] = [];\r\n\t\t\t\tenumeratorForEach(e, (e, i)=>\r\n\t\t\t\t{\r\n\t\t\t\t\tresult[i] = selector(e);\r\n\t\t\t\t});\r\n\t\t\t\treturn result;\r\n\t\t\t});\r\n\r\n\t}\r\n\r\n\t// Slightly optimized versions for numbers.\r\n\tstatic max(values:Enumerable<number>):number\r\n\t{\r\n\t\treturn values\r\n\t\t\t.takeUntil(v=> v== +Infinity, true)\r\n\t\t\t.aggregate(Functions.Greater);\r\n\t}\r\n\r\n\tstatic min(values:Enumerable<number>):number\r\n\t{\r\n\t\treturn values\r\n\t\t\t.takeUntil(v=> v== -Infinity, true)\r\n\t\t\t.aggregate(Functions.Lesser);\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\t//////////////////////////////////////////\r\n\t// #region Instance methods...\r\n\r\n\tforEach(action:Predicate<T> | Action<T>):void\r\n\t{\r\n\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar index:number = 0;\r\n\t\t// Return value of action can be anything, but if it is (===) false then the forEach will discontinue.\r\n\t\tusing(\r\n\t\t\t_.getEnumerator(), e=>\r\n\t\t\t{\r\n\t\t\t\t// It is possible that subsequently 'action' could cause the enumeration to dispose, so we have to check each time.\r\n\t\t\t\twhile(_.throwIfDisposed() && e.moveNext())\r\n\t\t\t\t{\r\n\t\t\t\t\tif(<any>action(e.current, index++)===false)\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t// #region Conversion Methods\r\n\ttoArray(predicate?:Predicate<T>):T[]\r\n\t{\r\n\t\tvar result:T[] = [];\r\n\r\n\t\tif(predicate) return this.where(predicate).toArray();\r\n\r\n\t\tthis.forEach((x, i)=>\r\n\t\t{\r\n\t\t\tresult[i] = x\r\n\t\t});\r\n\r\n\t\treturn result;\r\n\t}\r\n\r\n\t// Return a default (unfiltered) enumerable.\r\n\tasEnumerable():Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\t\treturn new Enumerable<T>(() => _.getEnumerator());\r\n\t}\r\n\r\n\r\n\ttoLookup<TKey, TValue, TCompare>(\r\n\t\tkeySelector:Selector<T, TKey>,\r\n\t\telementSelector:Selector<T, TValue> = Functions.Identity,\r\n\t\tcompareSelector:Selector<TKey, TCompare> = Functions.Identity):ILookup<TKey, TValue>\r\n\t{\r\n\t\tvar dict:Dictionary<TKey, TValue[]> = new Dictionary<TKey, TValue[]>(compareSelector);\r\n\t\tthis.forEach(\r\n\t\t\tx=>\r\n\t\t\t{\r\n\t\t\t\tvar key = keySelector(x);\r\n\t\t\t\tvar element = elementSelector(x);\r\n\r\n\t\t\t\tvar array = dict.getValue(key);\r\n\t\t\t\tif(array!==VOID0) array.push(element);\r\n\t\t\t\telse dict.addByKeyValue(key, [element]);\r\n\t\t\t}\r\n\t\t);\r\n\t\treturn new Lookup<TKey, TValue>(dict);\r\n\t}\r\n\r\n\ttoMap<TResult>(\r\n\t\tkeySelector:Selector<T, string>,\r\n\t\telementSelector:Selector<T, TResult>):IMap<TResult>\r\n\t{\r\n\t\tvar obj:IMap<TResult> = {};\r\n\t\tthis.forEach(x=>\r\n\t\t{\r\n\t\t\tobj[keySelector(x)] = elementSelector(x);\r\n\t\t});\r\n\t\treturn obj;\r\n\t}\r\n\r\n\ttoDictionary<TKey, TValue, TCompare>(\r\n\t\tkeySelector:Selector<T, TKey>,\r\n\t\telementSelector:Selector<T, TValue>,\r\n\t\tcompareSelector:Selector<TKey, TCompare> = Functions.Identity):Dictionary<TKey, TValue>\r\n\t{\r\n\t\tvar dict:Dictionary<TKey, TValue> = new Dictionary<TKey, TValue>(compareSelector);\r\n\t\tthis.forEach(x=> dict.addByKeyValue(keySelector(x), elementSelector(x)));\r\n\t\treturn dict;\r\n\t}\r\n\r\n\ttoJoinedString(separator:string = \"\", selector:Selector<T, string> = Functions.Identity)\r\n\t{\r\n\t\treturn this.select(selector).toArray().join(separator);\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\r\n\t/**\r\n\t * Similar to forEach, but executes an action for each time a value is enumerated.\r\n\t * If the action explicitly returns false or 0 (EnumerationAction.Break), the enumeration will complete.\r\n\t * If it returns a 2 (EnumerationAction.Skip) it will move on to the next item.\r\n\t * This also automatically handles disposing the enumerator.\r\n\t */\r\n\tdoAction(\r\n\t\taction:Action<T> | Predicate<T> | Selector<T, number> | Selector<T, EnumerableAction>):Enumerable<T>\r\n\t{\r\n\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tvar actionResult = <any>action(enumerator.current, index++);\r\n\r\n\t\t\t\t\t\t\tif(actionResult===false || actionResult===EnumerableAction.Break)\r\n\t\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\r\n\t\t\t\t\t\t\tif(actionResult!==EnumerableAction.Skip) // || !== 2\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(enumerator.current);\r\n\r\n\t\t\t\t\t\t\t// If actionResult===2, then a signal for skip is received.\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\r\n\t\t\t},\r\n\t\t\t// Using a finalizer value reduces the chance of a circular reference\r\n\t\t\t// since we could simply reference the enumeration and check e.wasDisposed.\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tforce(defaultAction:EnumerableAction = EnumerableAction.Break):void\r\n\t{\r\n\r\n\t\tthis.throwIfDisposed();\r\n\r\n\t\tthis.doAction(element => defaultAction);\r\n\t}\r\n\r\n\t// #region Indexing/Paging methods.\r\n\tskip(count:number):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tif(!count || isNaN(count) || count<0) // Out of bounds? Simply return this.\r\n\t\t\treturn _;\r\n\r\n\t\tif(!isFinite(count)) // +Infinity equals skip all so return empty.\r\n\t\t\treturn Enumerable.empty<T>();\r\n\r\n\t\tInteger.assert(count, \"count\");\r\n\r\n\t\tvar c:number = count;\r\n\r\n\t\treturn this.doAction(\r\n\t\t\t(element:T, index?:number) =>\r\n\t\t\t\tindex<c\r\n\t\t\t\t\t? EnumerableAction.Skip\r\n\t\t\t\t\t: EnumerableAction.Return\r\n\t\t);\r\n\t}\r\n\r\n\tskipWhile(predicate:Predicate<T>):Enumerable<T>\r\n\t{\r\n\r\n\t\tthis.throwIfDisposed();\r\n\r\n\t\tvar skipping:boolean = true;\r\n\r\n\t\treturn this.doAction(\r\n\t\t\t(element:T, index?:number) =>\r\n\t\t\t{\r\n\t\t\t\tif(skipping)\r\n\t\t\t\t\tskipping = predicate(element, index);\r\n\r\n\t\t\t\treturn skipping\r\n\t\t\t\t\t? EnumerableAction.Skip\r\n\t\t\t\t\t: EnumerableAction.Return;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\ttake(count:number):Enumerable<T>\r\n\t{\r\n\t\tif(!count || isNaN(count) || count<0) // Out of bounds? Empty.\r\n\t\t\treturn Enumerable.empty<T>();\r\n\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tif(!isFinite(count)) // +Infinity equals no limit.\r\n\t\t\treturn _;\r\n\r\n\t\tInteger.assert(count, \"count\");\r\n\t\tvar c = count;\r\n\r\n\t\t// Once action returns false, the enumeration will stop.\r\n\t\treturn _.doAction((element:T, index?:number) => index<c);\r\n\t}\r\n\r\n\ttakeWhile(predicate:Predicate<T>):Enumerable<T>\r\n\t{\r\n\r\n\t\tthis.throwIfDisposed();\r\n\r\n\t\treturn this.doAction(\r\n\t\t\t(element:T, index?:number) =>\r\n\t\t\t\tpredicate(element, index)\r\n\t\t\t\t\t? EnumerableAction.Return\r\n\t\t\t\t\t: EnumerableAction.Break\r\n\t\t);\r\n\t}\r\n\r\n\t// Is like the inverse of take While with the ability to return the value identified by the predicate.\r\n\ttakeUntil(predicate:Predicate<T>, includeUntilValue?:boolean):Enumerable<T>\r\n\t{\r\n\r\n\t\tthis.throwIfDisposed();\r\n\r\n\t\tif(!includeUntilValue)\r\n\t\t\treturn this.doAction(\r\n\t\t\t\t(element:T, index?:number) =>\r\n\t\t\t\t\tpredicate(element, index)\r\n\t\t\t\t\t\t? EnumerableAction.Break\r\n\t\t\t\t\t\t: EnumerableAction.Return\r\n\t\t\t);\r\n\r\n\t\tvar found:boolean = false;\r\n\t\treturn this.doAction(\r\n\t\t\t(element:T, index?:number) =>\r\n\t\t\t{\r\n\t\t\t\tif(found)\r\n\t\t\t\t\treturn EnumerableAction.Break;\r\n\r\n\t\t\t\tfound = predicate(element, index);\r\n\r\n\t\t\t\treturn EnumerableAction.Return;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\ttakeExceptLast(count:number = 1):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\tif(!count || isNaN(count) || count<=0) // Out of bounds? Empty.\r\n\t\t\treturn _;\r\n\r\n\t\tif(!isFinite(count)) // +Infinity equals skip all so return empty.\r\n\t\t\treturn Enumerable.empty<T>();\r\n\r\n\t\tInteger.assert(count, \"count\");\r\n\t\tvar c = count;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar q:Queue<T>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tq = new Queue<T>();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t// Add the next one to the queue.\r\n\t\t\t\t\t\t\tq.enqueue(enumerator.current);\r\n\r\n\t\t\t\t\t\t\t// Did we reach our quota?\r\n\t\t\t\t\t\t\tif(q.count>c)\r\n\t\t\t\t\t\t\t// Okay then, start returning results.\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(q.dequeue());\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator, q);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\ttakeFromLast(count:number):Enumerable<T>\r\n\t{\r\n\t\tif(!count || isNaN(count) || count<=0) // Out of bounds? Empty.\r\n\t\t\treturn Enumerable.empty<T>();\r\n\r\n\t\tvar _ = this;\r\n\r\n\t\tif(!isFinite(count)) // Infinity means return all in reverse.\r\n\t\t\treturn _.reverse();\r\n\r\n\t\tInteger.assert(count, \"count\");\r\n\r\n\t\treturn _.reverse().take(count);\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\t// #region Projection and Filtering Methods\r\n\r\n\ttraverseBreadthFirst(\r\n\t\tfunc:(element:any) => IEnumerable<any>,\r\n\t\tresultSelector?:(element:any, nestLevel?:number) => any):Enumerable<any>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<any>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<any>;\r\n\t\t\t\tvar nestLevel:number = 0;\r\n\t\t\t\tvar buffer:any[], len:number;\r\n\r\n\t\t\t\treturn new EnumeratorBase<any>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tnestLevel = 0;\r\n\t\t\t\t\t\tbuffer = [];\r\n\t\t\t\t\t\tlen = 0;\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\twhile(true)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tif(enumerator.moveNext())\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tbuffer[len++] = enumerator.current;\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(resultSelector(enumerator.current, nestLevel));\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tif(!len)\r\n\t\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\r\n\t\t\t\t\t\t\tvar next = Enumerable\r\n\t\t\t\t\t\t\t\t.fromArray<T>(buffer)\r\n\t\t\t\t\t\t\t\t.selectMany(func);\r\n\r\n\t\t\t\t\t\t\tif(!next.any())\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tnestLevel++;\r\n\t\t\t\t\t\t\t\tbuffer = [];\r\n\t\t\t\t\t\t\t\tlen = 0;\r\n\t\t\t\t\t\t\t\tenumerator.dispose();\r\n\t\t\t\t\t\t\t\tenumerator = next.getEnumerator();\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t\tbuffer.length = 0;\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\r\n\ttraverseDepthFirst(\r\n\t\tfunc:(element:any) => IEnumerable<any>,\r\n\t\tresultSelector?:(element:any, nestLevel?:number) => any):Enumerable<any>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<any>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\t// Dev Note: May want to consider using an actual stack and not an array.\r\n\t\t\t\tvar enumeratorStack:IEnumerator<any>[] = [];\r\n\t\t\t\tvar enumerator:IEnumerator<any>;\r\n\t\t\t\tvar len:number; // Avoid using push/pop since they query .length every time and can be slower.\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tlen = 0;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\twhile(true)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tif(enumerator.moveNext())\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tvar value = resultSelector(enumerator.current, len);\r\n\t\t\t\t\t\t\t\tenumeratorStack[len++] = enumerator;\r\n\t\t\t\t\t\t\t\tenumerator = func(enumerator.current).getEnumerator();\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(value);\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tif(len==0) return false;\r\n\r\n\t\t\t\t\t\t\tenumerator.dispose();\r\n\t\t\t\t\t\t\tenumerator = enumeratorStack[--len];\r\n\t\t\t\t\t\t\tenumeratorStack.length = len;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\ttry\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tfinally\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tdisposeThese(enumeratorStack);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\r\n\tflatten():Enumerable<any>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<any>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<any>;\r\n\t\t\t\tvar middleEnumerator:IEnumerator<any> = null;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\twhile(true)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tif(middleEnumerator!=null)\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tif(middleEnumerator.moveNext())\r\n\t\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\t\treturn yielder.yieldReturn(middleEnumerator.current);\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\t\tmiddleEnumerator = null;\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tif(enumerator.moveNext())\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tvar c = enumerator.current;\r\n\t\t\t\t\t\t\t\tif(Array.isArray(c))\r\n\t\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\t\tmiddleEnumerator.dispose();\r\n\t\t\t\t\t\t\t\t\tmiddleEnumerator = Enumerable.fromArray<any>(c)\r\n\t\t\t\t\t\t\t\t\t\t.selectMany(Functions.Identity)\r\n\t\t\t\t\t\t\t\t\t\t.flatten()\r\n\t\t\t\t\t\t\t\t\t\t.getEnumerator();\r\n\t\t\t\t\t\t\t\t\tcontinue;\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\t\treturn yielder.yieldReturn(enumerator.current);\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator, middleEnumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\r\n\tpairwise<TSelect>(selector:(prev:T, current:T) => TSelect):Enumerable<TSelect>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<TSelect>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TSelect>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tenumerator.moveNext();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar prev = enumerator.current;\r\n\t\t\t\t\t\treturn enumerator.moveNext()\r\n\t\t\t\t\t\t\t&& yielder.yieldReturn(selector(prev, enumerator.current));\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tscan(func:(a:T, b:T) => T, seed?:T):Enumerable<T>\r\n\t{\r\n\r\n\t\tvar isUseSeed = seed!==VOID0; // For now...\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar value:T;\r\n\t\t\t\tvar isFirst:boolean;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tisFirst = true;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tif(isFirst)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tisFirst = false;\r\n\t\t\t\t\t\t\t//noinspection JSUnusedAssignment\r\n\t\t\t\t\t\t\treturn isUseSeed\r\n\t\t\t\t\t\t\t\t? yielder.yieldReturn(value = seed)\r\n\t\t\t\t\t\t\t\t: enumerator.moveNext() && yielder.yieldReturn(value\r\n\t\t\t\t\t\t\t\t= enumerator.current);\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\treturn (enumerator.moveNext())\r\n\t\t\t\t\t\t\t? yielder.yieldReturn(value = func(value, enumerator.current))\r\n\t\t\t\t\t\t\t: false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\r\n\tselect<TResult>(selector:Selector<T, TResult>):Enumerable<TResult>\r\n\t{\r\n\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\tif(selector.length<2)\r\n\t\t\treturn new WhereSelectEnumerable(_, null, selector);\r\n\r\n\t\treturn new Enumerable<TResult>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TResult>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\treturn enumerator.moveNext()\r\n\t\t\t\t\t\t\t? yielder.yieldReturn(selector(enumerator.current, index++))\r\n\t\t\t\t\t\t\t: false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\r\n\tselectMany<TResult>(collectionSelector:Selector<T, IEnumerable<TResult | IArray<TResult>>>):Enumerable<TResult>;\r\n\r\n\tselectMany<TElement, TResult>(\r\n\t\tcollectionSelector:Selector<T, IEnumerable<TElement> | IArray<TResult>> | Selector<T, IArray<TElement>>,\r\n\t\tresultSelector?:(collection:T, element:TElement) => TResult):Enumerable<TResult>;\r\n\r\n\tselectMany<TResult>(\r\n\t\tcollectionSelector:Selector<T, any>,\r\n\t\tresultSelector?:(collection:any, middle:any) => TResult):Enumerable<TResult>\r\n\t{\r\n\t\tvar _ = this;\r\n\t\tif(!resultSelector)\r\n\t\t\tresultSelector = (a, b) => b;\r\n\r\n\t\treturn new Enumerable<TResult>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar middleEnumerator:IEnumerator<any>;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TResult>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tmiddleEnumerator = undefined;\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\r\n\t\t\t\t\t\t// Just started, and nothing to enumerate? End.\r\n\t\t\t\t\t\tif(middleEnumerator===VOID0 && !enumerator.moveNext())\r\n\t\t\t\t\t\t\treturn false;\r\n\r\n\t\t\t\t\t\t// moveNext has been called at least once...\r\n\t\t\t\t\t\tdo\r\n\t\t\t\t\t\t{\r\n\r\n\t\t\t\t\t\t\t// Initialize middle if there isn't one.\r\n\t\t\t\t\t\t\tif(!middleEnumerator)\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tvar middleSeq = collectionSelector(enumerator.current, index++);\r\n\r\n\t\t\t\t\t\t\t\t// Collection is null? Skip it...\r\n\t\t\t\t\t\t\t\tif(!middleSeq)\r\n\t\t\t\t\t\t\t\t\tcontinue;\r\n\r\n\t\t\t\t\t\t\t\tmiddleEnumerator = enumeratorFrom(middleSeq);\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tif(middleEnumerator.moveNext())\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(\r\n\t\t\t\t\t\t\t\t\tresultSelector(\r\n\t\t\t\t\t\t\t\t\t\tenumerator.current, middleEnumerator.current\r\n\t\t\t\t\t\t\t\t\t)\r\n\t\t\t\t\t\t\t\t);\r\n\r\n\t\t\t\t\t\t\t// else no more in this middle? Then clear and reset for next...\r\n\r\n\t\t\t\t\t\t\tmiddleEnumerator.dispose();\r\n\t\t\t\t\t\t\tmiddleEnumerator = null;\r\n\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\twhile(enumerator.moveNext());\r\n\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator, middleEnumerator);\r\n\t\t\t\t\t\tenumerator = null;\r\n\t\t\t\t\t\tmiddleEnumerator = null;\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tchoose<TResult>(selector:Selector<T, TResult>):Enumerable<TResult>\r\n\t{\r\n\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<TResult>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TResult>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tvar result = selector(enumerator.current, index++);\r\n\t\t\t\t\t\t\tif(result!==null && result!==VOID0)\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(result);\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\twhere(predicate:Predicate<T>):Enumerable<T>\r\n\t{\r\n\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\tif(predicate.length<2)\r\n\t\t\treturn new WhereEnumerable(_, predicate);\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tif(predicate(enumerator.current, index++))\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(enumerator.current);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t}\r\n\t\t);\r\n\r\n\t}\r\n\r\n\tofType<TType>(type:{ new (): TType }):Enumerable<TType>;\r\n\tofType<TType>(type:any):Enumerable<TType>\r\n\t{\r\n\t\tvar typeName:string;\r\n\t\tswitch(<any>type)\r\n\t\t{\r\n\t\t\tcase Number:\r\n\t\t\t\ttypeName = Type.NUMBER;\r\n\t\t\t\tbreak;\r\n\t\t\tcase String:\r\n\t\t\t\ttypeName = Type.STRING;\r\n\t\t\t\tbreak;\r\n\t\t\tcase Boolean:\r\n\t\t\t\ttypeName = Type.BOOLEAN;\r\n\t\t\t\tbreak;\r\n\t\t\tcase Function:\r\n\t\t\t\ttypeName = Type.FUNCTION;\r\n\t\t\t\tbreak;\r\n\t\t\tdefault:\r\n\t\t\t\treturn <Enumerable<any>>this\r\n\t\t\t\t\t.where(x=>x instanceof type);\r\n\t\t}\r\n\t\treturn <Enumerable<any>>this\r\n\t\t\t.where(x=>typeof x===typeName);\r\n\t}\r\n\r\n\texcept<TCompare>(\r\n\t\tsecond:IEnumerable<T>,\r\n\t\tcompareSelector?:Selector<T, TCompare>):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar keys:Dictionary<T, boolean>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tkeys = new Dictionary<T, boolean>(compareSelector);\r\n\t\t\t\t\t\tif(second)\r\n\t\t\t\t\t\t\tEnumerable.forEach(second, key => keys.addByKeyValue(key, true));\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tvar current = enumerator.current;\r\n\t\t\t\t\t\t\tif(!keys.containsKey(current))\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tkeys.addByKeyValue(current, true);\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(current);\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t\tkeys.clear();\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tdistinct(compareSelector?:(value:T) => T):Enumerable<T>\r\n\t{\r\n\t\treturn this.except(null, compareSelector);\r\n\t}\r\n\r\n\t// [0,0,0,1,1,1,2,2,2,0,0,0] results in [0,1,2,0];\r\n\tdistinctUntilChanged<TCompare>(compareSelector?:Selector<T, TCompare>):Enumerable<T>\r\n\t{\r\n\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar compareKey:TCompare;\r\n\t\t\t\tvar initial:boolean = true;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tvar key = compareSelector(enumerator.current);\r\n\r\n\t\t\t\t\t\t\tif(initial)\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tinitial = false;\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\telse if(compareKey===key)\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tcontinue;\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tcompareKey = key;\r\n\t\t\t\t\t\t\treturn yielder.yieldReturn(enumerator.current);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\treverse():Enumerable<T>\r\n\t{\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar buffer:T[];\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\tbuffer = _.toArray();\r\n\t\t\t\t\t\tindex = buffer.length;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\tindex>0\r\n\t\t\t\t\t&& yielder.yieldReturn(buffer[--index]),\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tbuffer.length = 0;\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tshuffle():Enumerable<T>\r\n\t{\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar buffer:T[];\r\n\t\t\t\tvar capacity:number;\r\n\t\t\t\tvar len:number;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\tbuffer = _.toArray();\r\n\t\t\t\t\t\tcapacity = len = buffer.length;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\t// Avoid using major array operations like .slice();\r\n\t\t\t\t\t\tif(!len)\r\n\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\r\n\t\t\t\t\t\tvar selectedIndex = Integer.random(len);\r\n\t\t\t\t\t\tvar selectedValue = buffer[selectedIndex];\r\n\r\n\t\t\t\t\t\tbuffer[selectedIndex] = buffer[--len]; // Take the last one and put it here.\r\n\t\t\t\t\t\tbuffer[len] = null; // clear possible reference.\r\n\r\n\t\t\t\t\t\tif(len%32==0) // Shrink?\r\n\t\t\t\t\t\t\tbuffer.length = len;\r\n\r\n\t\t\t\t\t\treturn yielder.yieldReturn(selectedValue);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tbuffer.length = 0;\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tcount(predicate?:Predicate<T>):number\r\n\t{\r\n\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar count:number = 0;\r\n\t\tif(predicate)\r\n\t\t{\r\n\t\t\t_.forEach((x, i) =>\r\n\t\t\t{\r\n\t\t\t\tif(predicate(x, i))++count;\r\n\t\t\t});\r\n\t\t}\r\n\t\telse\r\n\t\t{\r\n\t\t\t_.forEach(() =>\r\n\t\t\t{\r\n\t\t\t\t++count;\r\n\t\t\t});\r\n\t\t}\r\n\r\n\t\treturn count;\r\n\t}\r\n\r\n\t// Akin to '.every' on an array.\r\n\tall(predicate:Predicate<T>):boolean\r\n\t{\r\n\t\tvar result = true;\r\n\t\tthis.forEach(x =>\r\n\t\t{\r\n\t\t\tif(!predicate(x))\r\n\t\t\t{\r\n\t\t\t\tresult = false;\r\n\t\t\t\treturn false; // break\r\n\t\t\t}\r\n\t\t});\r\n\t\treturn result;\r\n\t}\r\n\r\n\t// 'every' has been added here for parity/compatibility with an array.\r\n\tevery(predicate:Predicate<T>):boolean\r\n\t{\r\n\t\treturn this.all(predicate);\r\n\t}\r\n\r\n\t// Akin to '.some' on an array.\r\n\tany(predicate?:Predicate<T>):boolean\r\n\t{\r\n\t\tvar result = false;\r\n\r\n\t\t// Splitting the forEach up this way reduces iterative processing.\r\n\t\t// forEach handles the generation and disposal of the enumerator.\r\n\t\tif(predicate)\r\n\t\t{\r\n\t\t\tthis.forEach(x =>\r\n\t\t\t{\r\n\t\t\t\tresult = predicate(x); // false = not found and therefore it should continue. true = found and break;\r\n\t\t\t\treturn !result;\r\n\t\t\t});\r\n\t\t}\r\n\t\telse\r\n\t\t{\r\n\t\t\tthis.forEach(() =>\r\n\t\t\t{\r\n\t\t\t\tresult = true;\r\n\t\t\t\treturn false;\r\n\t\t\t});\r\n\t\t}\r\n\t\treturn result;\r\n\r\n\t}\r\n\r\n\t// 'some' has been added here for parity/compatibility with an array.\r\n\tsome(predicate:Predicate<T>):boolean\r\n\t{\r\n\t\treturn this.any(predicate);\r\n\t}\r\n\r\n\tisEmpty():boolean\r\n\t{\r\n\t\treturn !this.any();\r\n\t}\r\n\r\n\tcontains<TCompare>(value:T, compareSelector?:Selector<T, TCompare>):boolean\r\n\t{\r\n\t\treturn compareSelector\r\n\t\t\t? this.any(v=> compareSelector(v)===compareSelector(value))\r\n\t\t\t: this.any(v=> v===value);\r\n\t}\r\n\r\n\t// Originally has an overload for a predicate,\r\n\t// but that's a bad idea since this could be an enumeration of functions and therefore fail the intent.\r\n\t// Better to chain a where statement first to be more explicit.\r\n\tindexOf<TCompare>(value:T, compareSelector?:Selector<T, TCompare>):number\r\n\t{\r\n\t\tvar found:number = -1;\r\n\r\n\t\tif(compareSelector)\r\n\t\t\tthis.forEach((element:T, i?:number) =>\r\n\t\t\t{\r\n\t\t\t\tif(Values.areEqual(compareSelector(element), compareSelector(value), true))\r\n\t\t\t\t{\r\n\t\t\t\t\tfound = i;\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\telse\r\n\t\t\tthis.forEach((element:T, i?:number) =>\r\n\t\t\t{\r\n\t\t\t\t// Why? Because NaN doesn't equal NaN. :P\r\n\t\t\t\tif(Values.areEqual(element, value, true))\r\n\t\t\t\t{\r\n\t\t\t\t\tfound = i;\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\t\t});\r\n\r\n\t\treturn found;\r\n\t}\r\n\r\n\tlastIndexOf<TCompare>(value:T, compareSelector?:Selector<T, TCompare>):number\r\n\t{\r\n\t\tvar result:number = -1;\r\n\r\n\t\tif(compareSelector)\r\n\t\t\tthis.forEach((element:T, i?:number) =>\r\n\t\t\t{\r\n\t\t\t\tif(Values.areEqual(compareSelector(element), compareSelector(value), true)) result\r\n\t\t\t\t\t= i;\r\n\t\t\t});\r\n\t\telse\r\n\t\t\tthis.forEach((element:T, i?:number) =>\r\n\t\t\t{\r\n\t\t\t\tif(Values.areEqual(element, value, true)) result = i;\r\n\t\t\t});\r\n\r\n\t\treturn result;\r\n\t}\r\n\r\n\tdefaultIfEmpty(defaultValue:T = null):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this, disposed:boolean = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar isFirst:boolean;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tisFirst = true;\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\tif(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tisFirst = false;\r\n\t\t\t\t\t\t\treturn yielder.yieldReturn(enumerator.current);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\telse if(isFirst)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tisFirst = false;\r\n\t\t\t\t\t\t\treturn yielder.yieldReturn(defaultValue);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tzip<TSecond, TResult>(\r\n\t\tsecond:IEnumerable<TSecond> | IArray<TSecond>,\r\n\t\tresultSelector:(first:T, second:TSecond, index?:number) => TResult):Enumerable<TResult>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<TResult>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar firstEnumerator:IEnumerator<T>;\r\n\t\t\t\tvar secondEnumerator:IEnumerator<TSecond>;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TResult>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tfirstEnumerator = _.getEnumerator();\r\n\t\t\t\t\t\tsecondEnumerator = enumeratorFrom<TSecond>(second);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\tfirstEnumerator.moveNext() && secondEnumerator.moveNext()\r\n\t\t\t\t\t&& yielder.yieldReturn(resultSelector(firstEnumerator.current, secondEnumerator.current, index++)),\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(firstEnumerator, secondEnumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tzipMultiple<TSecond, TResult>(\r\n\t\tsecond:IArray<IEnumerable<TSecond> | IArray<TSecond>>,\r\n\t\tresultSelector:(first:T, second:TSecond, index?:number) => TResult):Enumerable<TResult>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\tif(!second.length)\r\n\t\t\treturn Enumerable.empty<TResult>();\r\n\r\n\t\treturn new Enumerable<TResult>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar secondTemp:Queue<any>;\r\n\t\t\t\tvar firstEnumerator:IEnumerator<T>;\r\n\t\t\t\tvar secondEnumerator:IEnumerator<TSecond>;\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TResult>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tsecondTemp = new Queue<any>(second);\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t\tfirstEnumerator = _.getEnumerator();\r\n\t\t\t\t\t\tsecondEnumerator = null;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tif(firstEnumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\twhile(true)\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\twhile(!secondEnumerator)\r\n\t\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\t\tif(secondTemp.count)\r\n\t\t\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\t\t\tvar next = secondTemp.dequeue();\r\n\t\t\t\t\t\t\t\t\t\tif(next) // In case by chance next is null, then try again.\r\n\t\t\t\t\t\t\t\t\t\t\tsecondEnumerator = enumeratorFrom<TSecond>(next);\r\n\t\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\t\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\t\tif(secondEnumerator.moveNext())\r\n\t\t\t\t\t\t\t\t\treturn yielder.yieldReturn(\r\n\t\t\t\t\t\t\t\t\t\tresultSelector(firstEnumerator.current, secondEnumerator.current, index++)\r\n\t\t\t\t\t\t\t\t\t);\r\n\r\n\t\t\t\t\t\t\t\tsecondEnumerator.dispose();\r\n\t\t\t\t\t\t\t\tsecondEnumerator = null;\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(firstEnumerator, secondTemp);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t// #region Join Methods\r\n\r\n\tjoin<TInner, TKey, TResult, TCompare>(\r\n\t\tinner:IEnumerable<TInner> | IArray<TInner>,\r\n\t\touterKeySelector:Selector<T, TKey>,\r\n\t\tinnerKeySelector:Selector<TInner, TKey>,\r\n\t\tresultSelector:(outer:T, inner:TInner) => TResult,\r\n\t\tcompareSelector:Selector<TKey, TCompare> = Functions.Identity):Enumerable<TResult>\r\n\t{\r\n\r\n\t\tvar _ = this;\r\n\t\treturn new Enumerable<TResult>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar outerEnumerator:IEnumerator<T>;\r\n\t\t\t\tvar lookup:ILookup<TKey,TInner>;\r\n\t\t\t\tvar innerElements:TInner[] = null;\r\n\t\t\t\tvar innerCount:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TResult>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\touterEnumerator = _.getEnumerator();\r\n\t\t\t\t\t\tlookup = Enumerable.from<TInner>(inner)\r\n\t\t\t\t\t\t\t.toLookup(innerKeySelector, Functions.Identity, compareSelector);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\twhile(true)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tif(innerElements!=null)\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tvar innerElement = innerElements[innerCount++];\r\n\t\t\t\t\t\t\t\tif(innerElement!==VOID0)\r\n\t\t\t\t\t\t\t\t\treturn yielder.yieldReturn(resultSelector(outerEnumerator.current, innerElement));\r\n\r\n\t\t\t\t\t\t\t\tinnerElement = null;\r\n\t\t\t\t\t\t\t\tinnerCount = 0;\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tif(outerEnumerator.moveNext())\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tvar key = outerKeySelector(outerEnumerator.current);\r\n\t\t\t\t\t\t\t\tinnerElements = lookup.get(key);\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(outerEnumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tgroupJoin<TInner, TKey, TResult, TCompare>(\r\n\t\tinner:IEnumerable<TInner> | IArray<TInner>,\r\n\t\touterKeySelector:Selector<T, TKey>,\r\n\t\tinnerKeySelector:Selector<TInner, TKey>,\r\n\t\tresultSelector:(outer:T, inner:TInner[]) => TResult,\r\n\t\tcompareSelector:Selector<TKey, TCompare> = Functions.Identity):Enumerable<TResult>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<TResult>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar lookup:ILookup<TKey, TInner> = null;\r\n\r\n\t\t\t\treturn new EnumeratorBase<TResult>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tlookup = Enumerable.from<TInner>(inner)\r\n\t\t\t\t\t\t\t.toLookup(innerKeySelector, Functions.Identity, compareSelector);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\tenumerator.moveNext()\r\n\t\t\t\t\t&& yielder.yieldReturn(\r\n\t\t\t\t\t\tresultSelector(\r\n\t\t\t\t\t\t\tenumerator.current,\r\n\t\t\t\t\t\t\tlookup.get(outerKeySelector(enumerator.current))\r\n\t\t\t\t\t\t)\r\n\t\t\t\t\t),\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tconcatWith(other:IEnumerable<T> | IArray<T>):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar firstEnumerator:IEnumerator<T>;\r\n\t\t\t\tvar secondEnumerator:IEnumerator<T>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tfirstEnumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder) =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tif(firstEnumerator!=null)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tif(firstEnumerator.moveNext()) return yielder.yieldReturn(firstEnumerator.current);\r\n\t\t\t\t\t\t\tsecondEnumerator = enumeratorFrom<T>(other);\r\n\t\t\t\t\t\t\tfirstEnumerator.dispose();\r\n\t\t\t\t\t\t\tfirstEnumerator = null;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tif(secondEnumerator.moveNext()) return yielder.yieldReturn(secondEnumerator.current);\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(firstEnumerator, secondEnumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tmerge(enumerables:IArray<IEnumerable<T> | IArray<T>>):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\tif(!enumerables.length)\r\n\t\t\treturn _;\r\n\r\n\t\tif(enumerables.length==1)\r\n\t\t\treturn _.concatWith(enumerables[0]);\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar queue:Queue<IEnumerable<T> | IArray<T>>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\t// 1) First get our values...\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tqueue = new Queue<IEnumerable<T> | IArray<T>>(enumerables);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder) =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\twhile(true)\r\n\t\t\t\t\t\t{\r\n\r\n\t\t\t\t\t\t\twhile(!enumerator && queue.count)\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tenumerator = enumeratorFrom<T>(queue.dequeue()); // 4) Keep going and on to step 2. Else fall through to yieldBreak().\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tif(enumerator && enumerator.moveNext()) // 2) Keep returning until done.\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(enumerator.current);\r\n\r\n\t\t\t\t\t\t\tif(enumerator) // 3) Dispose and reset for next.\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tenumerator.dispose();\r\n\t\t\t\t\t\t\t\tenumerator = null;\r\n\t\t\t\t\t\t\t\tcontinue;\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator, queue); // Just in case this gets disposed early.\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tconcat(...enumerables:Array<IEnumerable<T> | IArray<T>>):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\t\tif(enumerables.length==0)\r\n\t\t\treturn _;\r\n\r\n\t\tif(enumerables.length==1)\r\n\t\t\treturn _.concatWith(enumerables[0]);\r\n\r\n\t\treturn _.merge(enumerables);\r\n\t}\r\n\r\n\r\n\tinsertAt(index:number, other:IEnumerable<T> | IArray<T>):Enumerable<T>\r\n\t{\r\n\t\tif(isNaN(index) || index<0 || !isFinite(index))\r\n\t\t\tthrow new Error(\"'index' is invalid or out of bounds.\");\r\n\r\n\t\tInteger.assert(index, \"index\");\r\n\t\tvar n:number = index;\r\n\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\r\n\t\t\t\tvar firstEnumerator:IEnumerator<T>;\r\n\t\t\t\tvar secondEnumerator:IEnumerator<T>;\r\n\r\n\t\t\t\tvar count:number = 0;\r\n\t\t\t\tvar isEnumerated:boolean = false;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tcount = 0;\r\n\t\t\t\t\t\tfirstEnumerator = _.getEnumerator();\r\n\t\t\t\t\t\tsecondEnumerator = enumeratorFrom<T>(other);\r\n\t\t\t\t\t\tisEnumerated = false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder) =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tif(count==n)\r\n\t\t\t\t\t\t{ // Inserting?\r\n\t\t\t\t\t\t\tisEnumerated = true;\r\n\t\t\t\t\t\t\tif(secondEnumerator.moveNext())\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(secondEnumerator.current);\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tif(firstEnumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tcount++;\r\n\t\t\t\t\t\t\treturn yielder.yieldReturn(firstEnumerator.current);\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\treturn !isEnumerated\r\n\t\t\t\t\t\t\t&& secondEnumerator.moveNext()\r\n\t\t\t\t\t\t\t&& yielder.yieldReturn(secondEnumerator.current);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(firstEnumerator, secondEnumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\r\n\talternateMultiple(sequence:IEnumerable<T> | IArray<T>):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar buffer:T,\r\n\t\t\t\t mode:EnumerableAction,\r\n\t\t\t\t enumerator:IEnumerator<T>,\r\n\t\t\t\t alternateEnumerator:IEnumerator<T>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\t// Instead of recalling getEnumerator every time, just reset the existing one.\r\n\t\t\t\t\t\talternateEnumerator = new ArrayEnumerator(\r\n\t\t\t\t\t\t\tEnumerable.toArray<T>(sequence)\r\n\t\t\t\t\t\t); // Freeze\r\n\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\r\n\t\t\t\t\t\tvar hasAtLeastOne = enumerator.moveNext();\r\n\t\t\t\t\t\tmode = hasAtLeastOne\r\n\t\t\t\t\t\t\t? EnumerableAction.Return\r\n\t\t\t\t\t\t\t: EnumerableAction.Break;\r\n\r\n\t\t\t\t\t\tif(hasAtLeastOne)\r\n\t\t\t\t\t\t\tbuffer = enumerator.current;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tswitch(mode)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tcase EnumerableAction.Break: // We're done?\r\n\t\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\r\n\t\t\t\t\t\t\tcase EnumerableAction.Skip:\r\n\t\t\t\t\t\t\t\tif(alternateEnumerator.moveNext())\r\n\t\t\t\t\t\t\t\t\treturn yielder.yieldReturn(alternateEnumerator.current);\r\n\t\t\t\t\t\t\t\talternateEnumerator.reset();\r\n\t\t\t\t\t\t\t\tmode = EnumerableAction.Return;\r\n\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tvar latest = buffer;\r\n\r\n\t\t\t\t\t\t// Set up the next round...\r\n\r\n\t\t\t\t\t\t// Is there another one? Set the buffer and setup instruct for the next one to be the alternate.\r\n\t\t\t\t\t\tvar another = enumerator.moveNext();\r\n\t\t\t\t\t\tmode = another\r\n\t\t\t\t\t\t\t? EnumerableAction.Skip\r\n\t\t\t\t\t\t\t: EnumerableAction.Break;\r\n\r\n\t\t\t\t\t\tif(another)\r\n\t\t\t\t\t\t\tbuffer = enumerator.current;\r\n\r\n\t\t\t\t\t\treturn yielder.yieldReturn(latest);\r\n\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator, alternateEnumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\talternateSingle(value:T):Enumerable<T>\r\n\t{\r\n\t\treturn this.alternateMultiple(Enumerable.make(value));\r\n\t}\r\n\r\n\talternate(...sequence:T[]):Enumerable<T>\r\n\t{\r\n\t\treturn this.alternateMultiple(sequence);\r\n\t}\r\n\r\n\r\n\tintersect<TCompare>(\r\n\t\tsecond:IEnumerable<T> | IArray<T>,\r\n\t\tcompareSelector?:Selector<T, TCompare>):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar keys:Dictionary<T,boolean>;\r\n\t\t\t\tvar outs:Dictionary<T,boolean>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\r\n\t\t\t\t\t\tkeys = new Dictionary<T, boolean>(compareSelector);\r\n\t\t\t\t\t\touts = new Dictionary<T, boolean>(compareSelector);\r\n\r\n\t\t\t\t\t\tEnumerable.from<T>(second)\r\n\t\t\t\t\t\t\t.forEach(key=>\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tkeys.addByKeyValue(key, true);\r\n\t\t\t\t\t\t\t});\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tvar current = enumerator.current;\r\n\t\t\t\t\t\t\tif(!outs.containsKey(current) && keys.containsKey(current))\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\touts.addByKeyValue(current, true);\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(current);\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t); // Should Dictionary be IDisposable?\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tsequenceEqual(\r\n\t\tsecond:IEnumerable<T> | IArray<T>,\r\n\t\tequalityComparer:EqualityComparison<T> = Values.areEqual):boolean\r\n\t{\r\n\t\treturn using(\r\n\t\t\tthis.getEnumerator(),\r\n\t\t\te1=> using(\r\n\t\t\t\tEnumerable.from<T>(second).getEnumerator(),\r\n\t\t\t\te2=>\r\n\t\t\t\t{\r\n\t\t\t\t\twhile(e1.moveNext())\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tif(!e2.moveNext() || !equalityComparer(e1.current, e2.current))\r\n\t\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\treturn !e2.moveNext();\r\n\t\t\t\t}\r\n\t\t\t)\r\n\t\t);\r\n\t}\r\n\r\n\t//isEquivalent(second:IEnumerable<T> | IArray<T>,\r\n\t//\tequalityComparer:EqualityComparison<T> = Values.areEqual):boolean\r\n\t//{\r\n\t//\treturn this\r\n\t//\t\t.orderBy(keySelector)\r\n\t//\t\t.sequenceEqual(Enumerable.from(second).orderBy(keySelector))\r\n\t//}\r\n\r\n\tunion<TCompare>(\r\n\t\tsecond:IEnumerable<T> | IArray<T>,\r\n\t\tcompareSelector:Selector<T, TCompare> = Functions.Identity):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar firstEnumerator:IEnumerator<T>;\r\n\t\t\t\tvar secondEnumerator:IEnumerator<T>;\r\n\t\t\t\tvar keys:Dictionary<T, any>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tfirstEnumerator = _.getEnumerator();\r\n\t\t\t\t\t\tkeys = new Dictionary<T, any>(compareSelector);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar current:T;\r\n\t\t\t\t\t\tif(secondEnumerator===VOID0)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\twhile(firstEnumerator.moveNext())\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tcurrent = firstEnumerator.current;\r\n\t\t\t\t\t\t\t\tif(!keys.containsKey(current))\r\n\t\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\t\tkeys.addByKeyValue(current, null);\r\n\t\t\t\t\t\t\t\t\treturn yielder.yieldReturn(current);\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\tsecondEnumerator = Enumerable.from<T>(second).getEnumerator();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\twhile(secondEnumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tcurrent = secondEnumerator.current;\r\n\t\t\t\t\t\t\tif(!keys.containsKey(current))\r\n\t\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t\tkeys.addByKeyValue(current, null);\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(current);\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(firstEnumerator, secondEnumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\t// #region Ordering Methods\r\n\r\n\torderBy<TKey extends Comparable>(keySelector:Selector<T, TKey> = Functions.Identity):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn new OrderedEnumerable<T,TKey>(this, keySelector, Order.Ascending);\r\n\t}\r\n\r\n\torderUsing(comparison:Comparison<T>):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn new OrderedEnumerable<T,any>(this, null, Order.Ascending, null, comparison);\r\n\t}\r\n\r\n\torderUsingReversed(comparison:Comparison<T>):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn new OrderedEnumerable<T,any>(this, null, Order.Descending, null, comparison);\r\n\t}\r\n\r\n\torderByDescending<TKey extends Comparable>(keySelector:Selector<T, TKey> = Functions.Identity):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn new OrderedEnumerable<T,TKey>(this, keySelector, Order.Descending);\r\n\t}\r\n\r\n\t/*\r\n\t\t weightedSample(weightSelector) {\r\n\t\t weightSelector = Utils.createLambda(weightSelector);\r\n\t\t var source = this;\r\n\r\n\t\t return new Enumerable<T>(() => {\r\n\t\t var sortedByBound;\r\n\t\t var totalWeight = 0;\r\n\r\n\t\t return new EnumeratorBase<T>(\r\n\t\t () => {\r\n\t\t sortedByBound = source\r\n\t\t .choose(function (x) {\r\n\t\t var weight = weightSelector(x);\r\n\t\t if (weight <= 0) return null; // ignore 0\r\n\r\n\t\t totalWeight += weight;\r\n\t\t return { value: x, bound: totalWeight }\r\n\t\t })\r\n\t\t .toArray();\r\n\t\t },\r\n\t\t () => {\r\n\t\t if (sortedByBound.length > 0) {\r\n\t\t var draw = (Math.random() * totalWeight) + 1;\r\n\r\n\t\t var lower = -1;\r\n\t\t var upper = sortedByBound.length;\r\n\t\t while (upper - lower > 1) {\r\n\t\t var index = ((lower + upper) / 2);\r\n\t\t if (sortedByBound[index].bound >= draw) {\r\n\t\t upper = index;\r\n\t\t }\r\n\t\t else {\r\n\t\t lower = index;\r\n\t\t }\r\n\t\t }\r\n\r\n\t\t return (<any>this).yieldReturn(sortedByBound[upper].value);\r\n\t\t }\r\n\r\n\t\t return (<any>this).yieldBreak();\r\n\t\t },\r\n\t\t Functions.Blank);\r\n\t\t });\r\n\t\t }\r\n\t\t */\r\n\t// #endregion\r\n\r\n\t// #region Grouping Methods\r\n\r\n\t// Originally contained a result selector (not common use), but this could be done simply by a select statement after.\r\n\r\n\r\n\tgroupBy<TKey>(keySelector:Selector<T, TKey>):Enumerable<IGrouping<TKey, T>>;\r\n\tgroupBy<TKey, TElement, TCompare>(\r\n\t\tkeySelector:Selector<T, TKey>,\r\n\t\telementSelector:Selector<T, TElement>,\r\n\t\tcompareSelector?:Selector<TKey, TCompare>):Enumerable<IGrouping<TKey, TElement>>;\r\n\tgroupBy<TKey, TElement, TCompare>(\r\n\t\tkeySelector:Selector<T, TKey>,\r\n\t\telementSelector?:Selector<T, TElement>,\r\n\t\tcompareSelector?:Selector<TKey, TCompare>):Enumerable<IGrouping<TKey, T>>|Enumerable<IGrouping<TKey, TElement>>\r\n\t{\r\n\t\tvar _ = this;\r\n\t\tif(!elementSelector) elementSelector = Functions.Identity; // Allow for 'null' and not just undefined.\r\n\t\treturn new Enumerable<IGrouping<TKey, TElement>>(\r\n\t\t\t() => _.toLookup(keySelector, elementSelector, compareSelector)\r\n\t\t\t\t.getEnumerator()\r\n\t\t);\r\n\t}\r\n\r\n\tpartitionBy<TKey>(keySelector:Selector<T, TKey>):Enumerable<IGrouping<TKey, T>>;\r\n\tpartitionBy<TKey, TElement, TCompare>(\r\n\t\tkeySelector:Selector<T, TKey>,\r\n\t\telementSelector:Selector<T, TElement>,\r\n\t\tresultSelector?:(key:TKey, element:TElement[]) => IGrouping<TKey, TElement>,\r\n\t\tcompareSelector?:Selector<TKey, TCompare>):Enumerable<IGrouping<TKey, TElement>>;\r\n\tpartitionBy<TKey, TElement, TCompare>(\r\n\t\tkeySelector:Selector<T, TKey>,\r\n\t\telementSelector?:Selector<T, TElement>,\r\n\t\tresultSelector:(key:TKey, element:TElement[]) => IGrouping<TKey, TElement>\r\n\t\t\t= (key:TKey, elements:TElement[]) => new Grouping<TKey, TElement>(key, elements),\r\n\t\tcompareSelector:Selector<TKey, TCompare>\r\n\t\t\t= Functions.Identity):Enumerable<IGrouping<TKey, T>>|Enumerable<IGrouping<TKey, TElement>>\r\n\t{\r\n\r\n\t\tvar _ = this;\r\n\t\tif(!elementSelector) elementSelector = Functions.Identity; // Allow for 'null' and not just undefined.\r\n\t\treturn new Enumerable<IGrouping<TKey, TElement>>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\tvar key:TKey;\r\n\t\t\t\tvar compareKey:TCompare;\r\n\t\t\t\tvar group:TElement[];\r\n\t\t\t\tvar len:number;\r\n\r\n\t\t\t\treturn new EnumeratorBase<IGrouping<TKey, TElement>>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tif(enumerator.moveNext())\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tkey = keySelector(enumerator.current);\r\n\t\t\t\t\t\t\tcompareKey = compareSelector(key);\r\n\t\t\t\t\t\t\tgroup = [elementSelector(enumerator.current)];\r\n\t\t\t\t\t\t\tlen = 1;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\tgroup = null;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tif(!group)\r\n\t\t\t\t\t\t\treturn yielder.yieldBreak();\r\n\r\n\t\t\t\t\t\tvar hasNext:boolean, c:T;\r\n\t\t\t\t\t\twhile((hasNext = enumerator.moveNext()))\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tc = enumerator.current;\r\n\t\t\t\t\t\t\tif(compareKey===compareSelector(keySelector(c)))\r\n\t\t\t\t\t\t\t\tgroup[len++] = elementSelector(c);\r\n\t\t\t\t\t\t\telse\r\n\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tvar result:IGrouping<TKey, TElement>\r\n\t\t\t\t\t\t\t = resultSelector(key, group);\r\n\r\n\t\t\t\t\t\tif(hasNext)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tc = enumerator.current;\r\n\t\t\t\t\t\t\tkey = keySelector(c);\r\n\t\t\t\t\t\t\tcompareKey = compareSelector(key);\r\n\t\t\t\t\t\t\tgroup = [elementSelector(c)];\r\n\t\t\t\t\t\t\tlen = 1;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\telse\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tgroup = null;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\treturn yielder.yieldReturn(result);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t\tgroup = null;\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\tbuffer(size:number):IEnumerable<T[]>\r\n\t{\r\n\t\tif(size<1 || !isFinite(size))\r\n\t\t\tthrow new Error(\"Invalid buffer size.\");\r\n\r\n\t\tInteger.assert(size, \"size\");\r\n\r\n\t\tvar _ = this, len:number;\r\n\r\n\t\treturn new Enumerable<T[]>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\t\t\t\treturn new EnumeratorBase<T[]>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tvar array:T[] = ArrayUtility.initialize<T>(size);\r\n\t\t\t\t\t\tlen = 0;\r\n\t\t\t\t\t\twhile(len<size && enumerator.moveNext)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tarray[len++] = enumerator.current;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tarray.length = len;\r\n\t\t\t\t\t\treturn len && yielder.yieldReturn(array);\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t// #region Aggregate Methods\r\n\r\n\taggregate(\r\n\t\tfunc:(a:T, b:T) => T,\r\n\t\tseed?:T):T\r\n\t{\r\n\t\treturn this.scan(func, seed).lastOrDefault();\r\n\t}\r\n\r\n\taverage(selector:Selector<T, number> = Type.numberOrNaN):number\r\n\t{\r\n\t\tvar sum = 0;\r\n\t\t// This allows for infinity math that doesn't destroy the other values.\r\n\t\tvar sumInfinite = 0; // Needs more investigation since we are really trying to retain signs.\r\n\r\n\t\tvar count = 0; // No need to make integer if the result could be a float.\r\n\r\n\t\tthis.forEach(\r\n\t\t\tfunction(x)\r\n\t\t\t{\r\n\t\t\t\tvar value = selector(x);\r\n\t\t\t\tif(isNaN(value))\r\n\t\t\t\t{\r\n\t\t\t\t\tsum = NaN;\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\t\t\tif(isFinite(value))\r\n\t\t\t\t\tsum += value;\r\n\t\t\t\telse\r\n\t\t\t\t\tsumInfinite += value>0 ? (+1) : (-1);\r\n\t\t\t\t++count;\r\n\t\t\t}\r\n\t\t);\r\n\r\n\t\tif(sumInfinite) // Not zero?\r\n\t\t\treturn sumInfinite*Infinity;\r\n\r\n\t\treturn (isNaN(sum) || !count)\r\n\t\t\t? NaN\r\n\t\t\t: (sum/count);\r\n\t}\r\n\r\n\t// If using numbers, it may be useful to call .takeUntil(v=>v==Infinity,true) before calling max. See static versions for numbers.\r\n\tmax():T\r\n\t{\r\n\t\treturn this.aggregate(Functions.Greater);\r\n\t}\r\n\r\n\tmin():T\r\n\t{\r\n\t\treturn this.aggregate(Functions.Lesser);\r\n\t}\r\n\r\n\tmaxBy<TCompare>(keySelector:Selector<T, TCompare> = Functions.Identity):T\r\n\t{\r\n\t\treturn this.aggregate((a:T, b:T) => (keySelector(a)>keySelector(b)) ? a : b);\r\n\t}\r\n\r\n\tminBy<TCompare>(keySelector:Selector<T, TCompare> = Functions.Identity):T\r\n\t{\r\n\t\treturn this.aggregate((a:T, b:T) => (keySelector(a)<keySelector(b)) ? a : b);\r\n\t}\r\n\r\n\t// Addition... Only works with numerical enumerations.\r\n\tsum(selector:Selector<T, number> = Type.numberOrNaN):number\r\n\t{\r\n\t\tvar sum = 0;\r\n\r\n\t\t// This allows for infinity math that doesn't destroy the other values.\r\n\t\tvar sumInfinite = 0; // Needs more investigation since we are really trying to retain signs.\r\n\r\n\t\tthis.forEach(\r\n\t\t\tx=>\r\n\t\t\t{\r\n\t\t\t\tvar value = selector(x);\r\n\t\t\t\tif(isNaN(value))\r\n\t\t\t\t{\r\n\t\t\t\t\tsum = NaN;\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\t\t\tif(isFinite(value))\r\n\t\t\t\t\tsum += value;\r\n\t\t\t\telse\r\n\t\t\t\t\tsumInfinite += value>0 ? (+1) : (-1);\r\n\t\t\t}\r\n\t\t);\r\n\r\n\t\treturn isNaN(sum) ? NaN : (sumInfinite ? (sumInfinite*Infinity) : sum);\r\n\t}\r\n\r\n\t// Multiplication...\r\n\tproduct(selector:Selector<T, number> = Type.numberOrNaN):number\r\n\t{\r\n\t\tvar result = 1, exists:boolean = false;\r\n\r\n\t\tthis.forEach(\r\n\t\t\tx=>\r\n\t\t\t{\r\n\t\t\t\texists = true;\r\n\t\t\t\tvar value = selector(x);\r\n\t\t\t\tif(isNaN(value))\r\n\t\t\t\t{\r\n\t\t\t\t\tresult = NaN;\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tif(value==0)\r\n\t\t\t\t{\r\n\t\t\t\t\tresult = 0; // Multiplying by zero will always end in zero.\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Multiplication can never recover from infinity and simply must retain signs.\r\n\t\t\t\t// You could cancel out infinity with 1/infinity but no available representation exists.\r\n\t\t\t\tresult *= value;\r\n\t\t\t}\r\n\t\t);\r\n\r\n\t\treturn (exists && isNaN(result)) ? NaN : result;\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\t// #region Single Value Return...\r\n\r\n\telementAt(index:number):T\r\n\t{\r\n\t\tif(isNaN(index) || index<0 || !isFinite(index))\r\n\t\t\tthrow new Error(\"'index' is invalid or out of bounds.\");\r\n\r\n\t\tInteger.assert(index, \"index\");\r\n\t\tvar n:number = index;\r\n\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar value:T = undefined;\r\n\t\tvar found = false;\r\n\t\t_.forEach(\r\n\t\t\t(x:T, i:number) =>\r\n\t\t\t{\r\n\t\t\t\tif(i==n)\r\n\t\t\t\t{\r\n\t\t\t\t\tvalue = x;\r\n\t\t\t\t\tfound = true;\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t);\r\n\r\n\t\tif(!found) throw new Error(\"index is less than 0 or greater than or equal to the number of elements in source.\");\r\n\t\treturn value;\r\n\t}\r\n\r\n\telementAtOrDefault(index:number, defaultValue:T = null):T\r\n\t{\r\n\r\n\t\tif(isNaN(index) || index<0 || !isFinite(index))\r\n\t\t\tthrow new Error(\"'index' is invalid or out of bounds.\");\r\n\r\n\t\tInteger.assert(index, \"index\");\r\n\t\tvar n:number = index;\r\n\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar value:T = undefined;\r\n\t\tvar found = false;\r\n\t\t_.forEach(\r\n\t\t\t(x:T, i:number) =>\r\n\t\t\t{\r\n\t\t\t\tif(i==n)\r\n\t\t\t\t{\r\n\t\t\t\t\tvalue = x;\r\n\t\t\t\t\tfound = true;\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t);\r\n\r\n\t\treturn (!found) ? defaultValue : value;\r\n\t}\r\n\r\n\t/* Note: Unlike previous implementations, you could pass a predicate into these methods.\r\n\t * But since under the hood it ends up calling .where(predicate) anyway,\r\n\t * it may be better to remove this to allow for a cleaner signature/override.\r\n\t * JavaScript/TypeScript does not easily allow for a strict method interface like C#.\r\n\t * Having to write extra override logic is error prone and confusing to the consumer.\r\n\t * Removing the predicate here may also cause the consumer of this method to think more about how they structure their query.\r\n\t * The end all difference is that the user must declare .where(predicate) before .first(), .single(), or .last().\r\n\t * */\r\n\r\n\tfirst():T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar value:T = undefined;\r\n\t\tvar found:boolean = false;\r\n\t\t_.forEach(\r\n\t\t\tx =>\r\n\t\t\t{\r\n\t\t\t\tvalue = x;\r\n\t\t\t\tfound = true;\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\t\t);\r\n\r\n\t\tif(!found) throw new Error(\"first:No element satisfies the condition.\");\r\n\t\treturn value;\r\n\t}\r\n\r\n\tfirstOrDefault(defaultValue:T = null):T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar value:T = undefined;\r\n\t\tvar found = false;\r\n\t\t_.forEach(\r\n\t\t\tx =>\r\n\t\t\t{\r\n\t\t\t\tvalue = x;\r\n\t\t\t\tfound = true;\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\t\t);\r\n\t\treturn (!found) ? defaultValue : value;\r\n\t}\r\n\r\n\tlast():T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar value:T = undefined;\r\n\t\tvar found:boolean = false;\r\n\t\t_.forEach(\r\n\t\t\tx =>\r\n\t\t\t{\r\n\t\t\t\tfound = true;\r\n\t\t\t\tvalue = x;\r\n\t\t\t}\r\n\t\t);\r\n\r\n\t\tif(!found) throw new Error(\"last:No element satisfies the condition.\");\r\n\t\treturn value;\r\n\t}\r\n\r\n\tlastOrDefault(defaultValue:T = null):T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar value:T = undefined;\r\n\t\tvar found:boolean = false;\r\n\t\t_.forEach(\r\n\t\t\tx=>\r\n\t\t\t{\r\n\t\t\t\tfound = true;\r\n\t\t\t\tvalue = x;\r\n\t\t\t}\r\n\t\t);\r\n\t\treturn (!found) ? defaultValue : value;\r\n\t}\r\n\r\n\tsingle():T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar value:T = undefined;\r\n\t\tvar found:boolean = false;\r\n\t\t_.forEach(\r\n\t\t\tx=>\r\n\t\t\t{\r\n\t\t\t\tif(!found)\r\n\t\t\t\t{\r\n\t\t\t\t\tfound = true;\r\n\t\t\t\t\tvalue = x;\r\n\t\t\t\t}\r\n\t\t\t\telse throw new Error(\"single:sequence contains more than one element.\");\r\n\t\t\t}\r\n\t\t);\r\n\r\n\t\tif(!found) throw new Error(\"single:No element satisfies the condition.\");\r\n\t\treturn value;\r\n\t}\r\n\r\n\tsingleOrDefault(defaultValue:T = null):T\r\n\t{\r\n\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar value:T = undefined;\r\n\t\tvar found:boolean = false;\r\n\t\t_.forEach(\r\n\t\t\tx=>\r\n\t\t\t{\r\n\t\t\t\tif(!found)\r\n\t\t\t\t{\r\n\t\t\t\t\tfound = true;\r\n\t\t\t\t\tvalue = x;\r\n\t\t\t\t}\r\n\t\t\t\telse throw new Error(\"single:sequence contains more than one element.\");\r\n\t\t\t}\r\n\t\t);\r\n\r\n\t\treturn (!found) ? defaultValue : value;\r\n\t}\r\n\r\n\t// #endregion\r\n\r\n\tshare():Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar sharedEnumerator:IEnumerator<T>;\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\t// assertIsNotDisposed(disposed); This doesn't need an assertion since disposing the underlying enumerable disposes the enumerator.\r\n\r\n\t\t\t\t\t\tif(!sharedEnumerator)\r\n\t\t\t\t\t\t\tsharedEnumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\tsharedEnumerator.moveNext()\r\n\t\t\t\t\t&& yielder.yieldReturn(sharedEnumerator.current)\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdispose(sharedEnumerator);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\r\n\tmemoize():Enumerable<T>\r\n\t{\r\n\t\tvar _ = this, disposed:boolean = !_.throwIfDisposed();\r\n\r\n\t\tvar cache:T[];\r\n\t\tvar enumerator:IEnumerator<T>;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\r\n\t\t\t\tvar index:number = 0;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\tif(!enumerator)\r\n\t\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\tif(!cache)\r\n\t\t\t\t\t\t\tcache = [];\r\n\t\t\t\t\t\tindex = 0;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\r\n\t\t\t\t\t\tvar i = index++;\r\n\r\n\t\t\t\t\t\tif(i>=cache.length)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\treturn (enumerator.moveNext())\r\n\t\t\t\t\t\t\t\t? yielder.yieldReturn(cache[i] = enumerator.current)\r\n\t\t\t\t\t\t\t\t: false;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\treturn yielder.yieldReturn(cache[i]);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdisposed = true;\r\n\t\t\t\tif(cache)\r\n\t\t\t\t\tcache.length = 0;\r\n\t\t\t\tcache = null;\r\n\r\n\t\t\t\tdispose(enumerator);\r\n\t\t\t\tenumerator = null;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\t// #region Error Handling\r\n\tcatchError(handler:(e:Error) => void):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\ttry\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tcatch(e)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\t// Don't init...\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\ttry\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\t\tif(enumerator.moveNext())\r\n\t\t\t\t\t\t\t\treturn yielder.yieldReturn(enumerator.current);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tcatch(e)\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\thandler(e);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tfinallyAction(action:() => void):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this, disposed = !_.throwIfDisposed();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tvar enumerator:IEnumerator<T>;\r\n\r\n\t\t\t\treturn new EnumeratorBase<T>(\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\tenumerator = _.getEnumerator();\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t(yielder)=>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tthrowIfDisposed(disposed);\r\n\t\t\t\t\t\treturn (enumerator.moveNext())\r\n\t\t\t\t\t\t\t? yielder.yieldReturn(enumerator.current)\r\n\t\t\t\t\t\t\t: false;\r\n\t\t\t\t\t},\r\n\r\n\t\t\t\t\t() =>\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\ttry\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tdispose(enumerator);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tfinally\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\taction();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n}\r\n\r\n\r\nclass ArrayEnumerable<T>\r\nextends Enumerable<T>\r\n{\r\n\tprivate _source:IArray<T>;\r\n\r\n\tconstructor(source:IArray<T>)\r\n\t{\r\n\t\tsuper(() =>\r\n\t\t{\r\n\t\t\t_.throwIfDisposed();\r\n\t\t\treturn new ArrayEnumerator<T>(() =>\r\n\t\t\t{\r\n\t\t\t\t_.throwIfDisposed(\"The underlying ArrayEnumerable was disposed.\", \"ArrayEnumerator\");\r\n\r\n\t\t\t\treturn _._source; // Could possibly be null, but ArrayEnumerable if not disposed simply treats null as empty array.\r\n\t\t\t});\r\n\t\t});\r\n\r\n\t\tvar _ = this;\r\n\t\t_._disposableObjectName = \"ArrayEnumerable\";\r\n\t\t_._source = source;\r\n\r\n\t}\r\n\r\n\tprotected _onDispose():void\r\n\t{\r\n\t\tsuper._onDispose();\r\n\t\tthis._source = <any>null;\r\n\t}\r\n\r\n\tget source():IArray<T>\r\n\t{\r\n\t\treturn this._source;\r\n\t}\r\n\r\n\ttoArray():T[]\r\n\t{\r\n\t\tvar s = this.source;\r\n\t\tif(!s)\r\n\t\t\treturn [];\r\n\r\n\t\tif(Array.isArray(s))\r\n\t\t\treturn (<any>s).slice();\r\n\r\n\t\tvar len = s.length, result:T[] = ArrayUtility.initialize<T>(len);\r\n\t\tfor(let i = 0; i<len; ++i)\r\n\t\t{\r\n\t\t\tresult[i] = s[i];\r\n\t\t}\r\n\r\n\t\treturn result;\r\n\t}\r\n\r\n\tasEnumerable():ArrayEnumerable<T>\r\n\t{\r\n\t\treturn new ArrayEnumerable<T>(this._source);\r\n\t}\r\n\r\n\t// Optimize forEach so that subsequent usage is optimized.\r\n\tforEach(action:Predicate<T> | Action<T>):void\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar source = _._source;\r\n\t\tif(source)\r\n\t\t{\r\n\r\n\t\t\t// Return value of action can be anything, but if it is (===) false then the forEach will discontinue.\r\n\t\t\tfor(let i = 0; i<source.length; ++i)\r\n\t\t\t{\r\n\t\t\t\t// _.assertIsNotDisposed(); // Assertion here is unnecessary since we already have a reference to the source array.\r\n\t\t\t\tif(<any>action(source[i], i)===false)\r\n\t\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t// These methods should ALWAYS check for array length before attempting anything.\r\n\r\n\tany(predicate?:Predicate<T>):boolean\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar source = _._source, len = source ? source.length : 0;\r\n\t\treturn len && (!predicate || super.any(predicate));\r\n\t}\r\n\r\n\tcount(predicate?:Predicate<T>):number\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar source = _._source, len = source ? source.length : 0;\r\n\t\treturn len && (predicate ? super.count(predicate) : len);\r\n\t}\r\n\r\n\telementAt(index:number):T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar source = _._source;\r\n\t\treturn (index<source.length && index>=0)\r\n\t\t\t? source[index]\r\n\t\t\t: super.elementAt(index);\r\n\t}\r\n\r\n\telementAtOrDefault(index:number, defaultValue:T = null):T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar source = _._source;\r\n\t\treturn (index<source.length && index>=0)\r\n\t\t\t? source[index]\r\n\t\t\t: defaultValue;\r\n\t}\r\n\r\n\tfirst():T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar source = _._source;\r\n\t\treturn (source && source.length)\r\n\t\t\t? source[0]\r\n\t\t\t: super.first();\r\n\t}\r\n\r\n\tfirstOrDefault(defaultValue:T = null):T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar source = _._source;\r\n\t\treturn (source && source.length)\r\n\t\t\t? source[0]\r\n\t\t\t: defaultValue;\r\n\t}\r\n\r\n\tlast():T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar source = _._source, len = source.length;\r\n\t\treturn (len)\r\n\t\t\t? source[len - 1]\r\n\t\t\t: super.last();\r\n\t}\r\n\r\n\tlastOrDefault(defaultValue:T = null):T\r\n\t{\r\n\t\tvar _ = this;\r\n\t\t_.throwIfDisposed();\r\n\r\n\t\tvar source = _._source, len = source.length;\r\n\t\treturn len\r\n\t\t\t? source[len - 1]\r\n\t\t\t: defaultValue;\r\n\t}\r\n\r\n\tskip(count:number):Enumerable<T>\r\n\t{\r\n\r\n\t\tvar _ = this;\r\n\r\n\t\tif(!count || count<0) // Out of bounds? Simply return a unfiltered enumerable.\r\n\t\t\treturn _.asEnumerable();\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() => new ArrayEnumerator<T>(() => _._source, count)\r\n\t\t);\r\n\t}\r\n\r\n\ttakeExceptLast(count:number = 1):Enumerable<T>\r\n\t{\r\n\t\tvar _ = this, len = _._source ? _._source.length : 0;\r\n\t\treturn _.take(len - count);\r\n\t}\r\n\r\n\ttakeFromLast(count:number):Enumerable<T>\r\n\t{\r\n\t\tif(!count || count<0) return Enumerable.empty<T>();\r\n\r\n\t\tvar _ = this,\r\n\t\t len = _._source\r\n\t\t\t ? _._source.length\r\n\t\t\t : 0;\r\n\r\n\t\treturn _.skip(len - count);\r\n\t}\r\n\r\n\treverse():Enumerable<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\r\n\t\treturn new Enumerable<T>(\r\n\t\t\t() => new ArrayEnumerator<T>(\r\n\t\t\t\t() => _._source, _._source\r\n\t\t\t\t\t? (_._source.length - 1)\r\n\t\t\t\t\t: 0, -1\r\n\t\t\t)\r\n\t\t);\r\n\t}\r\n\r\n\tmemoize():ArrayEnumerable<T>\r\n\t{\r\n\t\treturn new ArrayEnumerable<T>(this._source);\r\n\t}\r\n\r\n\tsequenceEqual(\r\n\t\tsecond:IEnumerable<T> | IArray<T>,\r\n\t\tequalityComparer:EqualityComparison<T> = Values.areEqual):boolean\r\n\t{\r\n\t\tif(Array.isArray(second))\r\n\t\t\treturn Arrays.areEqual(this.source, <IArray<T>>second, true, equalityComparer);\r\n\r\n\t\tif(second instanceof ArrayEnumerable)\r\n\t\t\treturn (<ArrayEnumerable<T>>second).sequenceEqual(this.source, equalityComparer);\r\n\r\n\t\treturn super.sequenceEqual(second, equalityComparer);\r\n\t}\r\n\r\n\r\n\ttoJoinedString(separator:string = \"\", selector:Selector<T, string> = Functions.Identity)\r\n\t{\r\n\t\tvar s = this._source;\r\n\t\treturn !selector && Array.isArray(s)\r\n\t\t\t? (<Array<T>>s).join(separator)\r\n\t\t\t: super.toJoinedString(separator, selector);\r\n\t}\r\n\r\n}\r\n\r\n\r\nexport interface IGrouping<TKey, TElement>\r\nextends Enumerable<TElement>\r\n{\r\n\tkey: TKey;\r\n}\r\n\r\nclass Grouping<TKey, TElement>\r\nextends ArrayEnumerable<TElement> implements IGrouping<TKey, TElement>\r\n{\r\n\r\n\tconstructor(private _groupKey:TKey, elements:TElement[])\r\n\t{\r\n\t\tsuper(elements);\r\n\t}\r\n\r\n\tget key():TKey\r\n\t{\r\n\t\treturn this._groupKey;\r\n\t}\r\n}\r\n\r\n\r\nexport interface ILookup<TKey, TElement>\r\nextends IEnumerable<IGrouping<TKey, TElement>>\r\n{\r\n\tcount: number;\r\n\tget(key:TKey): TElement[];\r\n\tcontains(key:TKey): boolean;\r\n}\r\n\r\nclass Lookup<TKey, TElement>\r\nimplements ILookup<TKey, TElement>\r\n{\r\n\r\n\tconstructor(private _dictionary:Dictionary<TKey, TElement[]>)\r\n\t{\r\n\t}\r\n\r\n\tget count():number\r\n\t{\r\n\t\treturn this._dictionary.count;\r\n\t}\r\n\r\n\tget(key:TKey):TElement[]\r\n\t{\r\n\t\treturn this._dictionary.getValue(key);\r\n\t}\r\n\r\n\tcontains(key:TKey):boolean\r\n\t{\r\n\t\treturn this._dictionary.containsKey(key);\r\n\t}\r\n\r\n\tgetEnumerator():IEnumerator<Grouping<TKey, TElement>>\r\n\t{\r\n\r\n\t\tvar _ = this;\r\n\t\tvar enumerator:IEnumerator<IKeyValuePair<TKey, TElement[]>>;\r\n\r\n\t\treturn new EnumeratorBase<Grouping<TKey, TElement>>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tenumerator = _._dictionary.getEnumerator();\r\n\t\t\t},\r\n\t\t\t(yielder)=>\r\n\t\t\t{\r\n\r\n\t\t\t\tif(!enumerator.moveNext())\r\n\t\t\t\t\treturn false;\r\n\r\n\t\t\t\tvar current = enumerator.current;\r\n\r\n\t\t\t\treturn yielder.yieldReturn(new Grouping<TKey, TElement>(current.key, current.value));\r\n\t\t\t},\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdispose(enumerator);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n}\r\n\r\n\r\nclass WhereEnumerable<T>\r\nextends Enumerable<T>\r\n{\r\n\tconstructor(\r\n\t\tprivate prevSource:IEnumerable<T>,\r\n\t\tprivate prevPredicate:Predicate<T> // predicate.length always <= 1\r\n\t)\r\n\t{\r\n\t\tsuper(null);\r\n\t}\r\n\r\n\twhere(predicate:Predicate<T>):Enumerable<T>\r\n\t{\r\n\r\n\t\tif(predicate.length>1)\r\n\t\t\treturn super.where(predicate);\r\n\r\n\t\tvar prevPredicate = this.prevPredicate;\r\n\t\tvar composedPredicate = (x:T) => prevPredicate(x) && predicate(x);\r\n\t\treturn new WhereEnumerable<T>(this.prevSource, composedPredicate);\r\n\t}\r\n\r\n\tselect<TSelect>(selector:Selector<T, TSelect>):Enumerable<TSelect>\r\n\t{\r\n\r\n\t\tif(selector.length>1)\r\n\t\t\treturn super.select(selector);\r\n\r\n\t\treturn new WhereSelectEnumerable<T, TSelect>(\r\n\t\t\tthis.prevSource,\r\n\t\t\tthis.prevPredicate,\r\n\t\t\tselector\r\n\t\t);\r\n\t}\r\n\r\n\tgetEnumerator():IEnumerator<T>\r\n\t{\r\n\t\tvar predicate = this.prevPredicate;\r\n\t\tvar source = this.prevSource;\r\n\t\tvar enumerator:IEnumerator<T>;\r\n\r\n\t\treturn new EnumeratorBase<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tenumerator = source.getEnumerator();\r\n\t\t\t},\r\n\r\n\t\t\t(yielder)=>\r\n\t\t\t{\r\n\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t{\r\n\t\t\t\t\tif(predicate(enumerator.current))\r\n\t\t\t\t\t\treturn yielder.yieldReturn(enumerator.current);\r\n\t\t\t\t}\r\n\r\n\t\t\t\treturn false;\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdispose(enumerator);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tprotected _onDispose():void\r\n\t{\r\n\t\tsuper._onDispose();\r\n\t\tthis.prevPredicate = null;\r\n\t\tthis.prevSource = null;\r\n\t}\r\n}\r\n\r\nclass WhereSelectEnumerable<TSource, T>\r\nextends Enumerable<T>\r\n{\r\n\tconstructor(\r\n\t\tprivate prevSource:IEnumerable<TSource>,\r\n\t\tprivate prevPredicate:Predicate<TSource>, // predicate.length always <= 1\r\n\t\tprivate prevSelector:Selector<TSource, T> // selector.length always <= 1\r\n\t)\r\n\t{\r\n\t\tsuper(null);\r\n\t}\r\n\r\n\twhere(predicate:(value:T, index?:number) => boolean):Enumerable<T>\r\n\t{\r\n\t\tif(predicate.length>1)\r\n\t\t\treturn super.where(predicate);\r\n\r\n\t\treturn new WhereEnumerable<T>(this, predicate);\r\n\t}\r\n\r\n\tselect<TSelect>(selector:Selector<T, TSelect>):Enumerable<TSelect>\r\n\t{\r\n\r\n\t\tif(selector.length>1)\r\n\t\t// if selector use index, can't compose\r\n\t\t\treturn super.select(selector);\r\n\r\n\t\tvar _ = this;\r\n\t\tvar prevSelector = _.prevSelector;\r\n\t\tvar composedSelector = (x:TSource) => selector(prevSelector(x));\r\n\t\treturn new WhereSelectEnumerable(_.prevSource, _.prevPredicate, composedSelector);\r\n\t}\r\n\r\n\tgetEnumerator():IEnumerator<T>\r\n\t{\r\n\t\tvar _ = this,\r\n\t\t predicate = _.prevPredicate,\r\n\t\t source = _.prevSource,\r\n\t\t selector:Selector<TSource, T> = _.prevSelector, // Type definition needed for correct inference.\r\n\t\t enumerator:IEnumerator<TSource>;\r\n\r\n\t\treturn new EnumeratorBase<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tenumerator = source.getEnumerator();\r\n\t\t\t},\r\n\r\n\t\t\t(yielder)=>\r\n\t\t\t{\r\n\t\t\t\twhile(enumerator.moveNext())\r\n\t\t\t\t{\r\n\t\t\t\t\tvar c = enumerator.current;\r\n\t\t\t\t\tif(predicate==null || predicate(c))\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\treturn yielder.yieldReturn(selector(c));\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\treturn false;\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tdispose(enumerator);\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tprotected _onDispose():void\r\n\t{\r\n\t\tvar _ = this;\r\n\t\tsuper._onDispose();\r\n\t\t_.prevPredicate = null;\r\n\t\t_.prevSource = null;\r\n\t\t_.prevSelector = null;\r\n\t}\r\n}\r\n\r\nexport interface IOrderedEnumerable<T>\r\nextends Enumerable<T>\r\n{\r\n\tthenBy(keySelector:(value:T) => any):IOrderedEnumerable<T>;\r\n\tthenByDescending(keySelector:(value:T) => any):IOrderedEnumerable<T>;\r\n\tthenUsing(comparison:Comparison<T>):IOrderedEnumerable<T>;\r\n\tthenUsingReversed(comparison:Comparison<T>):IOrderedEnumerable<T>\r\n}\r\n\r\nclass OrderedEnumerable<T,TOrderBy extends Comparable>\r\nextends Enumerable<T> implements IOrderedEnumerable<T>\r\n{\r\n\r\n\tconstructor(\r\n\t\tprivate source:IEnumerable<T>,\r\n\t\tpublic keySelector:(value:T) => TOrderBy,\r\n\t\tpublic order:Order,\r\n\t\tpublic parent?:OrderedEnumerable<T,any>,\r\n\t\tpublic comparer:Comparison<T> = Values.compare)\r\n\t{\r\n\t\tsuper(null);\r\n\t}\r\n\r\n\tprivate createOrderedEnumerable(\r\n\t\tkeySelector:(value:T) => TOrderBy,\r\n\t\torder:Order):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn new OrderedEnumerable<T,TOrderBy>(this.source, keySelector, order, this);\r\n\t}\r\n\r\n\tthenBy(keySelector:(value:T) => TOrderBy):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn this.createOrderedEnumerable(keySelector, Order.Ascending);\r\n\t}\r\n\r\n\tthenUsing(comparison:Comparison<T>):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn new OrderedEnumerable<T,any>(this.source, null, Order.Ascending, this, comparison);\r\n\t}\r\n\r\n\tthenByDescending(keySelector:(value:T) => TOrderBy):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn this.createOrderedEnumerable(keySelector, Order.Descending);\r\n\t}\r\n\r\n\tthenUsingReversed(comparison:Comparison<T>):IOrderedEnumerable<T>\r\n\t{\r\n\t\treturn new OrderedEnumerable<T,any>(this.source, null, Order.Descending, this, comparison);\r\n\t}\r\n\r\n\tgetEnumerator():EnumeratorBase<T>\r\n\t{\r\n\t\tvar _ = this;\r\n\t\tvar buffer:T[];\r\n\t\tvar indexes:number[];\r\n\t\tvar index:number = 0;\r\n\r\n\t\treturn new EnumeratorBase<T>(\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tindex = 0;\r\n\t\t\t\tbuffer = Enumerable.toArray(_.source);\r\n\t\t\t\tindexes = createSortContext(_).generateSortedIndexes(buffer);\r\n\t\t\t},\r\n\r\n\t\t\t(yielder)=>\r\n\t\t\t{\r\n\t\t\t\treturn (index<indexes.length)\r\n\t\t\t\t\t? yielder.yieldReturn(buffer[indexes[index++]])\r\n\t\t\t\t\t: false;\r\n\t\t\t},\r\n\r\n\t\t\t() =>\r\n\t\t\t{\r\n\t\t\t\tif(buffer)\r\n\t\t\t\t\tbuffer.length = 0;\r\n\t\t\t\tbuffer = null;\r\n\t\t\t\tif(indexes)\r\n\t\t\t\t\tindexes.length = 0;\r\n\t\t\t\tindexes = null;\r\n\t\t\t}\r\n\t\t);\r\n\t}\r\n\r\n\tprotected _onDispose():void\r\n\t{\r\n\t\tsuper._onDispose();\r\n\t\tthis.source = null;\r\n\t\tthis.keySelector = null;\r\n\t\tthis.order = null;\r\n\t\tthis.parent = null;\r\n\t}\r\n\r\n}\r\n\r\n/**\r\n * Recursively builds a SortContext chain.\r\n * @param orderedEnumerable\r\n * @param currentContext\r\n * @returns {any}\r\n */\r\nfunction createSortContext<T, TOrderBy extends Comparable>(\r\n\torderedEnumerable:OrderedEnumerable<T,TOrderBy>,\r\n\tcurrentContext:IComparer<T> = null):KeySortedContext<T, TOrderBy>\r\n{\r\n\r\n\tvar context = new KeySortedContext<T, TOrderBy>(\r\n\t\tcurrentContext,\r\n\t\torderedEnumerable.keySelector,\r\n\t\torderedEnumerable.order,\r\n\t\torderedEnumerable.comparer);\r\n\r\n\tif(orderedEnumerable.parent)\r\n\t\treturn createSortContext(orderedEnumerable.parent, context);\r\n\r\n\treturn context;\r\n}\r\n\r\n// #region Helper Functions...\r\n// This allows for the use of a boolean instead of calling this.throwIfDisposed()\r\n// since there is a strong chance of introducing a circular reference.\r\nfunction throwIfDisposed(disposed:boolean, className:string = \"Enumerable\"):void\r\n{\r\n\tif(disposed) throw new ObjectDisposedException(className);\r\n}\r\n// #endregion\r\n\r\nexport default Enumerable;\r\n"]}